diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..64b8e8b --- /dev/null +++ b/Makefile @@ -0,0 +1,96 @@ +# +# 4sports Makefile +# assembles source code, optionally builds a disk image and mounts it +# note: Windows users should probably use winmake.bat instead +# +# original by Quinn Dunki on 2014-08-15 +# One Girl, One Laptop Productions +# http://www.quinndunki.com/blondihacks +# +# adapted by 4am on 2021-02-12 +# + +DISK=4sports.hdv +VOLUME=INSTANT.REPLAY + +# third-party tools required to build + +# https://sourceforge.net/projects/acme-crossass/ +ACME=acme + +# https://github.com/sicklittlemonkey/cadius +# version 1.4.0 or later +CADIUS=cadius + +# https://bitbucket.org/magli143/exomizer/wiki/Home +EXOMIZER=exomizer mem -q -P23 -lnone + +dsk: asm + cp res/blank.hdv build/"$(DISK)" >>build/log + cp res/_FileInformation.txt build/ >>build/log + $(CADIUS) ADDFILE build/"$(DISK)" "/$(VOLUME)/" "build/LAUNCHER.SYSTEM" >>build/log + rsync -aP res/PREFS.CONF build/PREFS.CONF >> build/log + bin/padto.sh 512 build/PREFS.CONF >>build/log + for f in res/TITLE res/COVER res/HELP res/GAMES.CONF res/ATTRACT.CONF res/FX.CONF res/DFX.CONF build/PREFS.CONF res/CREDITS res/HELPTEXT res/DECRUNCH res/JOYSTICK res/Finder.Data res/Finder.Root; do $(CADIUS) ADDFILE build/"$(DISK)" "/$(VOLUME)/" "$$f" >>build/log; done + bin/buildfileinfo.sh res/TITLE.HGR "06" "4000" >>build/log + bin/buildfileinfo.sh res/TITLE.DHGR "06" "4000" >>build/log + bin/buildfileinfo.sh res/ACTION.HGR "06" "3FF8" >>build/log + bin/buildfileinfo.sh res/ACTION.DHGR "06" "3FF8" >>build/log + bin/buildfileinfo.sh res/ACTION.GR "06" "6000" >>build/log + bin/buildfileinfo.sh res/ARTWORK.SHR "06" "1FF8" >>build/log + bin/buildfileinfo.sh res/ATTRACT "04" "8000" >>build/log + bin/buildfileinfo.sh res/SS "04" "4000" >>build/log + bin/buildfileinfo.sh res/ICONS "CA" "0000" >>build/log + for f in res/TITLE.HGR res/TITLE.DHGR res/ACTION.HGR res/ACTION.DHGR res/ACTION.GR res/ARTWORK.SHR res/ATTRACT res/SS res/DEMO res/ICONS; do rm -f "$$f"/.DS_Store; $(CADIUS) ADDFOLDER build/"$(DISK)" "/$(VOLUME)/$$(basename $$f)" "$$f" >>build/log; done + $(CADIUS) ADDFOLDER build/"$(DISK)" "/$(VOLUME)/FX" "build/FX" >>build/log + for f in res/dsk/*.po; do $(CADIUS) EXTRACTVOLUME "$${f}" build/X/ >> build/log; done + rm -f build/X/**/.DS_Store build/X/**/PRODOS* build/X/**/LOADER.SYSTEM* + $(CADIUS) CREATEFOLDER build/"$(DISK)" "/$(VOLUME)/X/" >>build/log + for f in build/X/*; do $(CADIUS) ADDFOLDER build/"$(DISK)" "/$(VOLUME)/X/$$(basename $$f)" "$$f"; done >>build/log + bin/buildfileinfo.sh build/PRELAUNCH "06" "0106" >>build/log + $(CADIUS) ADDFOLDER build/"$(DISK)" "/$(VOLUME)/PRELAUNCH" "build/PRELAUNCH" >>build/log + rsync -aP --exclude=STANDARD res/GAMEHELP build/ >>build/log + for f in res/TITLE.HGR/*; do rsync --ignore-existing res/GAMEHELP/STANDARD build/GAMEHELP/$$(basename $$f); done + bin/buildfileinfo.sh build/GAMEHELP "04" "8000" >>build/log + $(CADIUS) ADDFOLDER build/"$(DISK)" "/$(VOLUME)/GAMEHELP" "build/GAMEHELP" >>build/log + bin/changebootloader.sh build/"$(DISK)" res/proboothd + +asm: asmlauncher asmfx asmprelaunch + +asmlauncher: md + $(ACME) -DBUILDNUMBER=`git rev-list --count HEAD` src/4sports.a 2>build/relbase.log + $(ACME) -r build/4sports.lst -DBUILDNUMBER=`git rev-list --count HEAD` -DRELBASE=`cat build/relbase.log | grep "RELBASE =" | cut -d"=" -f2 | cut -d"(" -f2 | cut -d")" -f1` src/4sports.a + +asmfx: md + for f in src/fx/*.a; do grep "^\!to" $${f} >/dev/null && $(ACME) $${f} >> build/log || true; done + bin/buildfileinfo.sh build/FX "06" "6000" >>build/log + +asmprelaunch: md + for f in src/prelaunch/*.a; do grep "^\!to" $${f} >/dev/null && $(ACME) $${f} >> build/log; done + for f in res/TITLE.HGR/*; do rsync --ignore-existing build/PRELAUNCH/STANDARD build/PRELAUNCH/$$(basename $$f); done + +chd: dsk + chdman createhd -c none -i build/"$(DISK)" -o build/"$(DISK)".chd >>build/log + +compress: md + for f in res/ACTION.HGR.UNCOMPRESSED/*; do o=res/ACTION.HGR/$$(basename $$f); [ -f "$$o" ] || ${EXOMIZER} "$$f"@0x4000 -o "$$o" >>build/log; done + #for f in res/ACTION.DHGR.UNCOMPRESSED/*; do o=res/ACTION.DHGR/$$(basename $$f); [ -f "$$o" ] || ${EXOMIZER} "$$f"@0x4000 -o "$$o" >>build/log; done + #for f in res/ARTWORK.SHR.UNCOMPRESSED/*; do o=res/ARTWORK.SHR/$$(basename $$f); [ -f "$$o" ] || ${EXOMIZER} "$$f"@0x2000 -o "$$o" >>build/log; done + +attract: compress + bin/check-attract-mode.sh + bin/generate-mini-attract-mode.sh + +mount: dsk + osascript bin/V2Make.scpt "`pwd`" bin/4sports.vii build/"$(DISK)" + +md: + mkdir -p build/X build/FX build/PRELAUNCH build/GAMEHELP + touch build/log + +clean: + rm -rf build/ || rm -rf build + +all: clean dsk mount + +al: all diff --git a/README.md b/README.md new file mode 100644 index 0000000..47945a8 --- /dev/null +++ b/README.md @@ -0,0 +1,92 @@ +# Building the code + +## Mac OS X + +You will need + - [Xcode command line tools](https://www.google.com/search?q=xcode+command+line+tools) + - [ACME](https://sourceforge.net/projects/acme-crossass/) + - [sicklittlemonkey's Cadius fork](https://github.com/sicklittlemonkey/cadius) + - [Exomizer](https://bitbucket.org/magli143/exomizer/wiki/Home) + +Then open a terminal window and type + +``` +$ cd 4sports/ +$ make +``` + +If all goes well, the `build/` subdirectory will contain a `4sports.hdv` image which can be mounted in emulators like [OpenEmulator](https://archive.org/details/OpenEmulatorSnapshots) or [Virtual II](http://virtualii.com/). + +## Windows + +You will need + - [ACME](https://sourceforge.net/projects/acme-crossass/) + - [Cadius for Windows](https://www.brutaldeluxe.fr/products/crossdevtools/cadius/) + - [Exomizer](https://bitbucket.org/magli143/exomizer/wiki/Home) + +(Those tools will need to be added to your command-line PATH.) + +Then open a `CMD.EXE` window and type + +``` +C:\> CD 4SPORTS +C:\4SPORTS> WINMAKE +``` +If all goes well, the `BUILD\` subdirectory will contain a `4SPORTS.HDV` image which can be mounted in emulators like [AppleWin](https://github.com/AppleWin/AppleWin). + +# Navigating the code + +## Initialization + +[`4sports.a`](https://github.com/a2-4am/4cade/blob/master/src/4sports.a) is the main assembler target. It builds the launcher itself. Launcher code is split into code that can be run once from main memory then discarded, and code which is relocated to the language card and persists throughout the lifetime of the launcher. As the language card is only 16KB and will also need to store some persistent data structures, memory is precious and tightly managed. + +[`4sports.init.a`](https://github.com/a2-4am/4cade/blob/master/src/4sports.init.a) contains the code that is run once at program startup. First, we do some hardware detection, like how much memory you have, whether you have a joystick, and whether you have a IIgs. Then we relocate selected code to the language card. [`constants.a`](https://github.com/a2-4am/4sports/blob/master/src/constants.a) has a rough map of what ends up where, within the language card and its overlapping memory regions. Then we load and parse the global preferences file ([`PREFS.CONF`](https://github.com/a2-4am/4sports/blob/master/res/prefs.conf)) and master game list ([`GAMES.CONF`](https://github.com/a2-4am/4sports/blob/master/res/games.conf)) and store the results in the language card. Finally, we jump to the main entry point (`Reenter`). The launcher is initialized; anything left in main memory is discarded. + +## Search mode + +There are three major modes in the launcher: search mode, browse mode, and mega-attract mode. Search mode is the default, and it is always the first mode you enter when launching the program. [`ui.search.mode.a`](https://github.com/a2-4am/4sports/blob/master/src/ui.search.mode.a) tracks your keystrokes to determine the best match within the game list for the keys you have typed, then loads the game's title screenshot and displays the game name and other information at the bottom of the screen. If you have not yet typed any keys, it displays the title page and welcome message instead. The `InputKeys` table documents all other recognized keys. + +The text ranking algorithm is in [`textrank.a`](https://github.com/a2-4am/4sports/blob/master/src/textrank.a). It was inspired by [Quicksilver](https://github.com/quicksilver/Quicksilver) but is an independent implementation. + +## Browse mode + +The user enters browse mode by pressing the right or down arrow key. [`ui.browse.mode.a`](https://github.com/a2-4am/4sports/blob/master/src/ui.browse.mode.a) then watches for other arrow keys and displays the next or previous game in the game list. The `BrowseKeys` table documents all other recognized keys. + +## Mega-Attract mode + +If the user presses `Esc` from any other mode, or does not type anything for 30 seconds, the launcher goes into Mega-Attract mode, a.k.a. screensaver mode. [`ui.attract.mode.a`](https://github.com/a2-4am/4sports/blob/master/src/ui.attract.mode.a) manages loading and executing attract mode modules. An attract mode module can be a short slideshow, a self-running demo, or just a single screenshot. Modules are listed in [`ATTRACT.CONF`](https://github.com/a2-4am/4sports/blob/master/res/attract.conf) and are run in order until end-of-file, then it starts over from the beginning. The entire cycle is quite long (several hours), and some screenshots appear in multiple slideshows, but there is no actual randomness in selecting the next attract mode module. + +# Navigating the configuration files + +## `GAMES.CONF` + +[`GAMES.CONF`](https://github.com/a2-4am/4sports/blob/master/res/GAMES.CONF) is the master games list. It contains 1 record for every game in Total Replay. However, not every game is playable on every device, so each record also contains metadata, e.g. "this game requires a joystick," or "this game requires 128K," or "this game has a double hi-res title screen" (which is not identical to "this game requires 128K"). + +The format of the `GAMES.CONF` file has changed as new requirements have appeared, and it may change again in the future. There is up-to-date format information at the bottom of the file itself, which I will not duplicate here. However, in general, each record is 1 line and contains the name and flags for 1 game. The file is parsed once at program startup, and the (possibly filtered) list of available games is stored persistently in the language card. + +Many records in `GAMES.CONF` do not list the game's display name, i.e. the mixed-case, human-readable name displayed in search mode, browse mode, and slideshows. Wherever possible, display names are calculated from a game's filename, so `WAVY.NAVY` is displayed as `Wavy Navy`, while `SUMMER.GAMES.II` is displayed as `Summer Games II`, and so on. + +Each game's filename is used as a "foreign key" (in database terms) to build directory paths, to locate files in subdirectories, and to reference the game in other configuration files. + +- A game's main executable is always `X/FILENAME/FILENAME` +- A game's HGR title screenshot is always `TITLE.HGR/FILENAME` +- A game's super hi-res box art is always `ARTWORk.SHR/FILENAME` +- A game's mini-attract mode configuration file is always `ATTRACT/FILENAME` +- Games are included in other attract mode configuration files by `FILENAME` +- The source disk image of a game (in [`res/dsk`](https://github.com/a2-4am/4sports/tree/master/res/dsk)) must have a volume name of `FILENAME`, and there must be a file in the disk image's root directory also named `FILENAME` which is the game's main executable + +## `ATTRACT.CONF` + +TODO + +## `FX.CONF`, `DFX.CONF` + +[`FX.CONF`](https://github.com/a2-4am/4sports/blob/master/res/FX.CONF) and its sister [`DFX.CONF`](https://github.com/a2-4am/4sports/blob/master/res/DFX.CONF) list the HGR and DHGR transition effects used in hi-res and double hi-res slideshows. Each record is a filename of a transition effect file, which is an executable file [assembled at build time](https://github.com/a2-4am/4sports/tree/master/src/fx) and stored in the `FX/` subdirectory. At the beginning of each slideshow, we query the global preferences to find the filename of the FX or DFX file, then update the global preferences with the next filename (wrapping around to the beginning of the list). If you watch the Mega-Attract mode long enough, you will eventually see all the transition effects, and since the cycle of transition effects is separate from the cycle of slideshows, you will eventually see the same slideshow with different transition effects. + +These files are read from disk and parsed every time they are needed. Due to memory restrictions, the parsed data is not persisted. + +## `PREFS.CONF` + +[`PREFS.CONF`](https://github.com/a2-4am/4sports/blob/master/res/PREFS.CONF) contains persistent global state, including Mega-Attract mode state and whether cheats are enabled. There is up-to-date format information in the file itself. + +This file is read and parsed once at program startup, and the parsed data is stored persistently in the language card. It is written to disk every time global state changes, which is often during Mega-Attract mode, or if the user toggles cheat mode. diff --git a/bin/4sports.vii b/bin/4sports.vii new file mode 100644 index 0000000..cc4fcc6 Binary files /dev/null and b/bin/4sports.vii differ diff --git a/bin/V2Make.scpt b/bin/V2Make.scpt new file mode 100644 index 0000000..d90d095 Binary files /dev/null and b/bin/V2Make.scpt differ diff --git a/bin/buildfileinfo.js b/bin/buildfileinfo.js new file mode 100644 index 0000000..4ca6bc1 --- /dev/null +++ b/bin/buildfileinfo.js @@ -0,0 +1,12 @@ +a = new ActiveXObject("scripting.filesystemobject") +fileinfo = "# This file is automatically generated\r\n" + +for (b = new Enumerator(a.GetFolder(WScript.Arguments(0)).files); !b.atEnd(); b.moveNext()) +{ + if (b.item().Name.toUpperCase() != "_FILEINFORMATION.TXT") + { + fileinfo += "\r\n" + b.item().Name.toUpperCase() + "=Type(" + WScript.Arguments(1) + "),AuxType(" + WScript.Arguments(2) + "),Access(C3)" + } +} +fileinfo += "\r\n" + "_FileInformation.txt=Type(" + WScript.Arguments(1) + "),AuxType(" + WScript.Arguments(2) + "),Access(C3)\r\n" +a.createtextfile(WScript.Arguments(0)+"\\_FILEINFORMATION.TXT", 1).write(fileinfo) diff --git a/bin/buildfileinfo.sh b/bin/buildfileinfo.sh new file mode 100755 index 0000000..cb6b798 --- /dev/null +++ b/bin/buildfileinfo.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +indir=$1 +intype=$2 +inaddress=$3 +cd "$indir" +rm -f _FileInformation.txt +(echo "# This file is automatically generated\n" + for f in *; do + echo "$f=Type($intype),AuxType($inaddress),Access(C3)" + done) > _FileInformation.txt diff --git a/bin/changebootloader.js b/bin/changebootloader.js new file mode 100644 index 0000000..06dc1a5 --- /dev/null +++ b/bin/changebootloader.js @@ -0,0 +1,6 @@ +a = new ActiveXObject("scripting.filesystemobject") +b = a.opentextfile(WScript.Arguments(0)) +b.skip(0x200) +d = b.read(a.getfile(WScript.Arguments(0)).size-0x200) +b.close() +b=a.createtextfile(WScript.Arguments(0), 1).write(a.opentextfile(WScript.Arguments(1)).read(512)+d) diff --git a/bin/changebootloader.sh b/bin/changebootloader.sh new file mode 100755 index 0000000..bb0417d --- /dev/null +++ b/bin/changebootloader.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +dd of="$1" bs=1 count=512 conv=notrunc < "$2" diff --git a/bin/check-attract-mode.sh b/bin/check-attract-mode.sh new file mode 100755 index 0000000..bc9bab1 --- /dev/null +++ b/bin/check-attract-mode.sh @@ -0,0 +1,76 @@ +#!/bin/bash + +# run from project root directory + +fatal_error() { + echo "$1" "$2" + exit 1 +} + +check_title_slideshow() { + [ -f "$1" ] || + fatal_error "Can't find HGR title slideshow" "$1" + cat "$1" | + grep -v "^#" | + grep -v "^\[" | + grep -v "^$" | + while read ssline; do + [ -f "$2"/"$ssline" ] || + fatal_error "Can't find title screenshot" "$ssline" + done +} + +check_action_slideshow() { + [ -f "$1" ] || + fatal_error "Can't find HGR action slideshow" "$1" + cat "$1" | + grep -v "^#" | + grep -v "^\[" | + grep -v "^$" | + while read ssline; do + IFS="=" read -r filename gamename <<< "$ssline" + if [ -z "$gamename" ]; then + gamename=$filename + fi + [ -f "$2"/"$filename" ] || + fatal_error "Can't find action screenshot" "$filename" + grep "^$gamename$" /tmp/games >/dev/null || + fatal_error "Action screenshot links to non-existent game" "$gamename" + done +} + +cat res/GAMES.CONF | + grep -v "^#" | + grep -v "^\[" | + grep -v "^$" | + cut -d"," -f2 | + cut -d"=" -f1 > /tmp/games + +cat res/ATTRACT.CONF | + grep "=" | + grep -v "^#" | + while read line; do + IFS="=" read -r module_name module_type <<< "$line" +# echo "$module_name" "$module_type" + if [ "$module_type" = "0" ]; then + [ -f res/DEMO/"$module_name" ] || + [ "${module_name%???}" = "SPCARTOON" ] || + fatal_error "Can't find demo" $module_name + elif [ "$module_type" = "1" ]; then + check_title_slideshow res/SS/"$module_name" res/TITLE.HGR/ + elif [ "$module_type" = "2" ]; then + check_action_slideshow res/SS/"$module_name" res/ACTION.HGR/ + elif [ "$module_type" = "3" ]; then + check_title_slideshow res/SS/"$module_name" res/TITLE.DHGR/ + elif [ "$module_type" = "4" ]; then + check_action_slideshow res/SS/"$module_name" res/ACTION.DHGR/ + elif [ "$module_type" = "5" ]; then + check_title_slideshow res/SS/"$module_name" res/ARTWORK.SHR/ + elif [ "$module_type" = "6" ]; then + check_action_slideshow res/SS/"$module_name" res/ACTION.GR/ + else + fatal_error "Unknown module type" $module_type + fi + done + +#rm -f /tmp/games diff --git a/bin/dumpcr.js b/bin/dumpcr.js new file mode 100644 index 0000000..abb598e --- /dev/null +++ b/bin/dumpcr.js @@ -0,0 +1,17 @@ +a = new ActiveXObject("scripting.filesystemobject") +b = WScript.Arguments(0).lastIndexOf('\\') + 1 +c = WScript.Arguments(0).substr(0, b) +d = WScript.Arguments(0).substr(b) +if (d.substr(0, 2) == '*.') +{ + d = d.substr(2) +} +for (b = new Enumerator(a.GetFolder(c).files); !b.atEnd(); b.moveNext()) +{ + if ((d == '*') || (d == b.item().name) || (d == a.getextensionname(b.item().name))) + { + e = a.opentextfile(c + b.item().name).readall() + e = e.replace(/\r\n/g, "\n") + a.createtextfile(c + b.item().name).write(e) + } +} diff --git a/bin/generate-mini-attract-mode.sh b/bin/generate-mini-attract-mode.sh new file mode 100755 index 0000000..2071cdc --- /dev/null +++ b/bin/generate-mini-attract-mode.sh @@ -0,0 +1,69 @@ +#!/bin/bash + +# run from project root directory + +cat res/GAMES.CONF | + grep "," | + grep -v "^#" | + cut -d"," -f2 | + cut -d"=" -f1 | \ + while read game; do + # initialize attract mode configuration file for this game + echo -e "#\n# Attract mode for $game\n# This file is automatically generated\n#\n" > /tmp/g + + # add box art, if any + [ -f res/ARTWORK.SHR/"$game" ] && + echo "ARTWORK.SHR/$game=C" >> /tmp/g + + # add DHGR action screenshots, if any + cat res/SS/ACTDHGR*.CONF | + egrep "(^|=)""$game""$" | + cut -d"=" -f1 | + sed -e "s/^/ACTION.DHGR\//g" | + sed -e "s/$/=B/g" | + sort | + uniq >> /tmp/g + + # add HGR action screenshots, if any + cat res/SS/ACTION*.CONF | + egrep "(^|=)""$game""$" | + cut -d"=" -f1 | + sed -e "s/^/ACTION.HGR\//g" | + sed -e "s/$/=A/g" | + sort | + uniq >> /tmp/g + + # add GR action screenshots, if any + cat res/SS/ACTGR*.CONF | + egrep "(^|=)""$game""$" | + cut -d"=" -f1 | + sed -e "s/^/ACTION.GR\//g" | + sed -e "s/$/=D/g" | + sort | + uniq >> /tmp/g + + # add self-running demo, if any + cat res/ATTRACT.CONF | + grep "^$game=0" >> /tmp/g + + if [ "$game" == "SPARE.CHANGE" ]; then + echo "SPCARTOON.1=0" >> /tmp/g + echo "SPCARTOON.2=0" >> /tmp/g + echo "SPCARTOON.3=0" >> /tmp/g + echo "SPCARTOON.4=0" >> /tmp/g + echo "SPCARTOON.5=0" >> /tmp/g + echo "SPCARTOON.6=0" >> /tmp/g + fi + + if [ "$game" == "PRINCEUNP" ]; then + echo "ARTWORK.SHR/POP.END=C" >> /tmp/g + fi + + # add eof + echo -e "\n[eof]" >> /tmp/g + + cat /tmp/g > res/ATTRACT/"$game" + + # clean up + rm /tmp/g + done diff --git a/bin/padto.js b/bin/padto.js new file mode 100644 index 0000000..a191dc7 --- /dev/null +++ b/bin/padto.js @@ -0,0 +1,5 @@ +a = new ActiveXObject("scripting.filesystemobject") +b = a.opentextfile(WScript.Arguments(1)) +c = b.readall() +b.close() +a.createtextfile(WScript.Arguments(1)).write(String(c + Array(512).join(" ")).substr(0, 512)) diff --git a/bin/padto.sh b/bin/padto.sh new file mode 100755 index 0000000..eb4deb7 --- /dev/null +++ b/bin/padto.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +totalsize=$1 +outfile=$2 + +[[ "$OSTYPE" == "linux-gnu" ]] \ + && filesize=$(stat -c "%s" "$outfile") \ + || filesize=$(stat -f "%z" "$outfile") + +padsize=$((512-$filesize)) +dd if=/dev/zero bs=1 count=$padsize >> "$outfile" diff --git a/bin/rename.py b/bin/rename.py new file mode 100755 index 0000000..4f8132a --- /dev/null +++ b/bin/rename.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 + +import fileinput +import glob +import subprocess +import sys + +def replace_string_in_file(filename, old_string, new_string): + for line in fileinput.input(glob.glob(filename), inplace=True): + print(line.replace(old_string, new_string), end='') + +def rename_files_in_directory(dirname, old_filename, new_filename): + for filename in glob.glob(f'{dirname}/{old_filename}*'): + subprocess.run(['git', 'mv', filename, filename.replace(old_filename, new_filename)]) + +def rename_one_file_in_directory(dirname, old_filename, new_filename): + for filename in glob.glob(f'{dirname}/{old_filename}'): + subprocess.run(['git', 'mv', f'{dirname}/{old_filename}', f'{dirname}/{new_filename}']) + +def rename_inside_disk_image(filename, old_name, new_name): + rt = subprocess.run(['cadius', 'CATALOG', filename], stdout=subprocess.PIPE, text=True) + if not [line for line in rt.stdout.split('\n') if line == f'/{old_name}/']: + return + subprocess.run(['cadius', 'RENAMEFILE', filename, f'/{old_name}/{old_name}', new_name], stdout=subprocess.PIPE, text=True) + subprocess.run(['cadius', 'RENAMEVOLUME', filename, new_name], stdout=subprocess.PIPE, text=True) + +def rename(old_game_name, new_game_name): + print(old_game_name) + for filename in glob.glob('res/dsk/*'): + rename_inside_disk_image(filename, old_game_name, new_game_name) + + for filename in ('res/GAMES.CONF', + f'res/ATTRACT/{old_game_name}', + 'res/SS/*'): + replace_string_in_file(filename, old_game_name, new_game_name) + + for dirname in ('res/DEMO',): + rename_one_file_in_directory(dirname, old_game_name, new_game_name) + + replace_string_in_file('res/DEMO/_FileInformation.txt', f'{old_game_name}=', f'{new_game_name}=') + + for filename in ('res/ATTRACT.CONF',): + replace_string_in_file(filename, f'{old_game_name}=0', f'{new_game_name}=0') + + replace_string_in_file('src/prelaunch/*', f'build/PRELAUNCH/{old_game_name}', f'build/PRELAUNCH/{new_game_name}') + + for dirname in ('res/ACTION.DHGR', + 'res/ACTION.DHGR.UNCOMPRESSED', + 'res/ACTION.GR', + 'res/ACTION.HGR', + 'res/ACTION.HGR.UNCOMPRESSED', + 'res/ARTWORK.SHR', + 'res/ARTWORK.SHR.UNCOMPRESSED', + 'res/ATTRACT', + 'res/GAMEHELP', + 'res/TITLE.ANIMATED', + 'res/TITLE.DHGR', + 'res/TITLE.HGR'): + rename_files_in_directory(dirname, old_game_name, new_game_name) + +def driver(): + rename("SLICKS", "S8") + rename("CIDER.SPIDER", "AC") + rename("ARCADE.BT.CAMP", "AB") + rename("ARDY.AARDVARK", "AA") + rename("ASTEROID.BLASTR", "AS") + rename("BCS.QUEST", "BQ") + rename("BEACH.HEAD.II", "B2") + rename("BEACH.HEAD", "B1") + rename("BEYOND.WOLFEN", "BW") + rename("BUDGETRILOGY", "BT") + rename("BLOCKCHAIN", "BC") + rename("BOP.N.WRESTLE", "BN") + rename("BOUNCING.KMNGAS", "BK") + rename("BRAINTEASERBLVD", "BB") + rename("BUCK.ROGERS", "BR") + rename("BURGERTIME", "BU") + rename("CALI.GAMES", "CA") + rename("CANNONBALL.BLTZ", "CB") + rename("CAPTN.GOODNIGHT", "CG") + rename("SMURFEN", "CS") + rename("WOLFEN84", "CW") + rename("CAVRNS.CALLISTO", "CC") + rename("CHAMP.LODERUN", "CL") + rename("COPTS.ROBBERS", "CR") + rename("D.GENERATION", "DG") + rename("DARKSTAR.UNHNGD", "DU") + rename("DAVIDS.MAGIC", "DM") + rename("EGGS.IT", "EI") + rename("FUJI.SPEED.WAY", "FC") + rename("IMPOSSIBLE.MISS", "I1") + rename("IMPOSSIBLE.M.II", "I2") + rename("INTL.GRAN.PRIX", "IG") + rename("EAGLES.NEST", "IE") + rename("I.O.SILVER", "IO") + rename("LITTLE.COMP.PPL", "LP") + rename("LOCK.N.CHASE", "LC") + rename("MARIO.BROS", "MB") + rename("MATTERHORN", "MS") + rename("MINGS.CHALLENGE", "MI") + rename("THUNDERHEAD", "MT") + rename("MONTEZUMA", "MZ") + rename("MR.COOL", "MC") + rename("MR.DO", "MD") + rename("MR.ROBOT", "MR") + rename("MS.PACMAN", "MP") + rename("NIGHT.MISSION", "NM") + rename("NIGHTMARE", "NI") + rename("ONE.ON.ONE", "OO") + rename("ORILEYS.MINE", "OM") + rename("OOTW", "OW") + rename("PANDORAS.BOX", "PB") + rename("PHARAOHS.REVNG", "PR") + rename("PIEMAN", "PM") + rename("PRINCEUNP", "PP") + rename("RAID.OVR.MOSCOW", "RM") + rename("REALM.IMPOSS", "RI") + rename("SITUATION.CRTCL", "SC") + rename("SOKO.BAN", "SO") + rename("SPDWAY.CLASSIC", "SP") + rename("SPYS.DEMISE", "SD") + rename("SS.BASEBALL", "SB") + rename("SS.BASKETBALL", "SK") + rename("SS.FOOTBALL", "SF") + rename("SS.SOCCER", "SS") + rename("SUICIDE", "SU") + rename("TAG.TEAM", "TT") + rename("TECHNOCOP", "TC") + rename("THAROLIAN.TUNLS", "TU") + rename("ASTEROID.FIELD", "AF") + rename("SUMMER.EDITION", "SE") + rename("WINTER.EDITION", "WE") + rename("LAST.GLADIATOR", "LG") + rename("SPY.STRIKES.BAK", "S2") + rename("TRACK.AND.FIELD", "TF") + rename("TUBEWAY", "TB") + rename("UP.N.DOWN", "UD") + rename("ROGER.RABBIT", "RR") + rename("WINGS.OF.FURY", "WF") + rename("WORLD.KARATE", "WK") + +if __name__ == '__main__': + driver() diff --git a/bin/rsync.js b/bin/rsync.js new file mode 100644 index 0000000..aec73f0 --- /dev/null +++ b/bin/rsync.js @@ -0,0 +1,19 @@ +a = new ActiveXObject("scripting.filesystemobject") +b = WScript.Arguments(0).lastIndexOf('\\') + 1 +c = WScript.Arguments(0).substr(0, b) +d = WScript.Arguments(0).substr(b) +if (d.substr(0, 2) == '*.') +{ + d = d.substr(2) +} +for (b = new Enumerator(a.GetFolder(c).files); !b.atEnd(); b.moveNext()) +{ + if ((d == '*') || (d == b.item().name) || (d == a.getextensionname(b.item().name))) + { + e = WScript.Arguments(1) + "\\" + b.item().Name + if (!a.fileexists(e) || (a.getfile(e).datelastmodified < b.item().datelastmodified)) + { + new ActiveXObject("wscript.shell").run('cmd /c copy "' + c + b.item().name + '" ' + WScript.Arguments(1)+"\\"+b.item().name.toUpperCase(), 0, 1) + } + } +} diff --git a/res/ACTION.DHGR/_FileInformation.txt b/res/ACTION.DHGR/_FileInformation.txt new file mode 100644 index 0000000..f1462b5 --- /dev/null +++ b/res/ACTION.DHGR/_FileInformation.txt @@ -0,0 +1,3 @@ +# This file is automatically generated + +_FileInformation.txt=Type(06),AuxType(3FF8),Access(C3) diff --git a/res/ACTION.GR/_FileInformation.txt b/res/ACTION.GR/_FileInformation.txt new file mode 100644 index 0000000..9208081 --- /dev/null +++ b/res/ACTION.GR/_FileInformation.txt @@ -0,0 +1,3 @@ +# This file is automatically generated + +_FileInformation.txt=Type(06),AuxType(6000),Access(C3) diff --git a/res/ACTION.HGR/_FileInformation.txt b/res/ACTION.HGR/_FileInformation.txt new file mode 100644 index 0000000..c7c9e3e --- /dev/null +++ b/res/ACTION.HGR/_FileInformation.txt @@ -0,0 +1,5 @@ +# This file is automatically generated + +BLACK.BELT=Type(06),AuxType(3FF8),Access(C3) +BLACK.BELT2=Type(06),AuxType(3FF8),Access(C3) +_FileInformation.txt=Type(06),AuxType(3FF8),Access(C3) diff --git a/res/ARTWORK.SHR/_FileInformation.txt b/res/ARTWORK.SHR/_FileInformation.txt new file mode 100644 index 0000000..6fe0edf --- /dev/null +++ b/res/ARTWORK.SHR/_FileInformation.txt @@ -0,0 +1,3 @@ +# This file is automatically generated + +_FileInformation.txt=Type(06),AuxType(1FF8),Access(C3) diff --git a/res/ATTRACT.CONF b/res/ATTRACT.CONF new file mode 100644 index 0000000..207050c --- /dev/null +++ b/res/ATTRACT.CONF @@ -0,0 +1,37 @@ +KARATE.CONF=1 +ACTIONKAR.CONF=2 + +[eof] + +# +# Mega-Attract-Mode configuration file +# +# Mega-Attract-Mode is split into modules. Each module can be a short +# slideshow, a self-running demo (like a game's built-in 'attract mode'), or +# even just a single screenshot. Modules are run in the order listed here, one +# after the next, until interrupted by user input. The last-run module is +# tracked in the global prefs file. +# +# The same format is used by the per-game attract mode configuration files. +# +# Format: +# key=value +# +# |key| must be unique within this file +# +# |value| must be one of +# 0 = self-running demo (|key| is an executable binary file in /DEMO/) +# 1 = HGR title slideshow (|key| is a file in /SS/ containing files in /TITLE.HGR/) +# 2 = HGR action slideshow (|key| is a file in /SS/ containing files in /ACTION.HGR/) +# 3 = DHGR title slideshow (|key| is a file in /SS/ containing files in /TITLE.DHGR/) +# 4 = DHGR action slideshow (|key| is a file in /SS/ containing files in /ACTION.DHGR/) +# 5 = SHR box art slideshow (|key| is a file in /SS/ containing files in /ARTWORK.SHR/) +# 6 = GR action slideshow (|key| is a file in /SS/ containing files in /ACTION.GR/) +# A = single HGR file (|key| is arbitrary path from program root directory) +# B = single DHGR file (|key| is arbitrary path from program root directory) +# C = single SHR file (|key| is arbitrary path from program root directory) +# D = single GR file (|key| is arbitrary path from program root directory) +# +# Blank lines and lines beginning with '#' are ignored (like this one!) +# A line beginning with '[' terminates the parsing +# diff --git a/res/ATTRACT/BLACK.BELT b/res/ATTRACT/BLACK.BELT new file mode 100644 index 0000000..33a6612 --- /dev/null +++ b/res/ATTRACT/BLACK.BELT @@ -0,0 +1,9 @@ +# +# Attract mode for BLACK.BELT +# This file is automatically generated +# + +ACTION.HGR/BLACK.BELT2=A +ACTION.HGR/BLACK.BELT=A + +[eof] diff --git a/res/ATTRACT/_FileInformation.txt b/res/ATTRACT/_FileInformation.txt new file mode 100644 index 0000000..4df049a --- /dev/null +++ b/res/ATTRACT/_FileInformation.txt @@ -0,0 +1,4 @@ +# This file is automatically generated + +BLACK.BELT=Type(04),AuxType(8000),Access(C3) +_FileInformation.txt=Type(04),AuxType(8000),Access(C3) diff --git a/res/COVER b/res/COVER new file mode 100644 index 0000000..bf4c152 Binary files /dev/null and b/res/COVER differ diff --git a/res/CREDITS b/res/CREDITS new file mode 100644 index 0000000..9a2f6fe --- /dev/null +++ b/res/CREDITS @@ -0,0 +1,21 @@ + + + + T O T A L + R E P L A Y + 2 + + ~ + + revision 01 / serial number 20210216 + + ~ + +design & interface * * * * * * * * * 4am + +ports & rwts * * * * * * * * * * *qkumba + + ~ + + archive.org/details/TotalReplay +[eof] diff --git a/res/DECRUNCH b/res/DECRUNCH new file mode 100644 index 0000000..30a6859 Binary files /dev/null and b/res/DECRUNCH differ diff --git a/res/DEMO/_FileInformation.txt b/res/DEMO/_FileInformation.txt new file mode 100644 index 0000000..1d9e598 --- /dev/null +++ b/res/DEMO/_FileInformation.txt @@ -0,0 +1 @@ +# This file is maintained by hand diff --git a/res/DFX.CONF b/res/DFX.CONF new file mode 100644 index 0000000..f8bc6c3 --- /dev/null +++ b/res/DFX.CONF @@ -0,0 +1,85 @@ +DHGR.FIZZLE2BIT +DHGR.RIPPLE +DHGR.SOFT.DIAG +DHGR.48BOXES +DHGR.BUBBLES +DHGR.RADIAL +DHGR.SOFT.IRIS +DHGR.WAVY.RIP +DHGR.48.SNAKE +DHGR.SNOWFL.IN +DHGR.MAPLE +DHGR.SLOW.STAR +DHGR.48.SNAKEC +DHGR.HEART.RIP +DHGR.CORNER4 +DHGR.STAR.IN +DHGR.48.ARROW +DHGR.REDLINES +DHGR.BUTTERFLY +DHGR.BLOOM.IN +DHGR.48.SYNCC +DHGR.RADIAL4 +DHGR.TWOPASS.LR +DHGR.WAVY.IN +DHGR.CORNER4RIP +DHGR.STAR +DHGR.48.LDIAGON +DHGR.MAPLE.IN +DHGR.BAR.DISSLV +DHGR.BLOOM +DHGR.SLOW.STARI +DHGR.HEART +DHGR.48.2SNAKES +DHGR.RADIAL3 +DHGR.STAR.RIP +DHGR.BFLY.IN +DHGR.DIAGONAL +DHGR.SNOWFLAKE +DHGR.48.DOWN +DHGR.SOFTIRISIN +DHGR.RADIAL2 +DHGR.IRIS +DHGR.BUBBLES.IN +DHGR.SLOWST.RIP +DHGR.48.SPIRAL +DHGR.RADIAL5 +DHGR.FIZZLE +DHGR.BFLY.RIP +DHGR.IRIS.IN +DHGR.SWIRL +DHGR.48.SPIRALC +DHGR.MAPLE.RIP +DHGR.R.BY.PIXEL +DHGR.HEART.IN +DHGR.SNOWFL.RIP +DHGR.48.SIDES +DHGR.CORNER4.IN +DHGR.WAVY.IRIS +DHGR.BLOOM.RIP +DHGR.48.SYNC +DHGR.FLICK + +[eof] + +# +# transition effects for DHGR slideshows +# +# Each Mega-Attract Module that is a DHGR 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 main +# memory banked in, DHGR page 1 showing, and the next DHGR graphic already +# loaded at $4000/main and $4000/aux. A transition effect has full use of +# auxiliary memory, zero pages (both), text pages (both, but preserve screen +# holes), and main memory $6000-$BEFF. $BF00-$BFFF/main is reserved for the +# ProDOS shim. 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. +# diff --git a/res/FX.CONF b/res/FX.CONF new file mode 100644 index 0000000..7b8ed75 --- /dev/null +++ b/res/FX.CONF @@ -0,0 +1,143 @@ +BOXES48.SNAKE +RIPPLE +SOFT.DIAGONAL +MANDELBROT.IN +RADIAL +STAGGER.LR +SOFT.UD +HEART.IN +CRYSTAL +STAR.RIPPLE +BIT2.FIZZLE +MEETINTHEMIDDLE +BOXES48 +APPLE.IN +FLOWER.RAD.RIP +SOFT.IRIS +W.RIPPLE.BLOOM +DIAGONAL +PINWHEELS +STAGGERWHITE.UD +BOXES48.SYNCC +CORNER4.RIP +BOLT +RADIAL2 +STAR +FLOWER.IN +R.BY.PIXEL +WAVY.IRIS +BIT.FIZZLE +STAR.IN +APPLE +MANDELBROT.RIP +SOFT.L +HEART.RIPPLE +FLOWER.RAD +SLOW.STAR.IN +IRIS.IN +BUTTERFLYRIPPLE +BOXES48.SPIRALC +W.IRIS.BLOOM.IN +CENTER.BY.PIXEL +RADBUBBLES +SNOWFLAKE.IN +FLOWER +APPLE.RIPPLE +DIAGONAL2 +STAR.BLOOM +BOXES48.SYNC +PALETTE.FIZZLE +BUTTERFLY +BUBBLES +FLOWER.RIPPLE +SPLIT.UD.INTRO +WAVY.IRIS.IN +R.BY.2 +HALF.FIZZLE +BOXES48.LDIAGON +SNOWFLAKE.RIP +RADIAL3 +HEART +BOLT.IN +FLOWER.RAD.IN +DIAGONAL3 +MANDELBROT +BOXES48.SPIRAL +WAVY.RIPPLE +CORNER4.OUT +LATTICE +BAR.DISSOLVE +R.BY.PALETTE +FOURSPIRAL +SOFT.R +MAPLE.IN +BOXES48.SNAKEC +RADIAL4 +IRIS +CASCADE +SNOWFLAKE +VERTICAL.BLINDS +BUTTERFLY.IN +LR.BY.PIXEL +CHECKERB.FIZZLE +BOXES48.SIDES +STAGGERWHITE.LR +SOFT.UD.OUT +ONESQUARE +W.IRIS.BLOOM +MAPLE +SWIRL +FIZZLE +SLOW.STAR +ARROW.WHITE +TRI.FIZZLE +BOXES48.DOWN +SOFT.IRIS.IN +DIAMOND +BUBBLES.IN +TWOPASS.LR +RADIAL5 +HALF.MOSAIC +BOLT.RIPPLE +ARROW +FOURSQUARE +FULL.OF.STARS +BLOCK.FIZZLE +BOXES48.2SNAKES +DIAGONAL4 +STAGGER.UD +INTERLOCK.LR +SOFT.UD.IN +BLOCK.MOSAIC +CORNER4.IN +MAPLE.RIPPLE +INTERLOCK.UD +LITTLE.BOXES +SPIRAL +SLOW.STAR.RIP +BOXES48.ARROW +REDLINES +FLICK +[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-$BEFF in main memory, zero page, and +# text page if needed (but preserve the screen holes). $800-$1FFF is reserved +# for the slideshow data. $BF00-$BFFF is reserved for the ProDOS shim. +# 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. +# diff --git a/res/Finder.Data b/res/Finder.Data new file mode 100644 index 0000000..946c902 Binary files /dev/null and b/res/Finder.Data differ diff --git a/res/Finder.Root b/res/Finder.Root new file mode 100644 index 0000000..10e412e Binary files /dev/null and b/res/Finder.Root differ diff --git a/res/GAMEHELP/STANDARD b/res/GAMEHELP/STANDARD new file mode 100644 index 0000000..818f5b0 --- /dev/null +++ b/res/GAMEHELP/STANDARD @@ -0,0 +1,12 @@ + + + + + + + + + + + T O D O +[eof] diff --git a/res/GAMES.CONF b/res/GAMES.CONF new file mode 100755 index 0000000..55d66e7 --- /dev/null +++ b/res/GAMES.CONF @@ -0,0 +1,26 @@ +0000,BLACK.BELT + +[eof] + +# +# 4cade master game list +# +# Format: +# ABCD,directory=name +# +# A=1 if game requires joystick, 0 if playable on keyboard +# B=1 if game requires 128K, 0 if playable on 64K +# C=1 if game has DHGR title, 0 if HGR +# D=cheat mode category +# 0=no cheats (yet!) +# 1=infinite lives +# 2=infinite weapons +# 3=infinite lives & weapons +# 4=invincibility +# 5=has in-game cheats +# +# if no name, it will be calculated from the directory when we need to display it +# +# all other values for A -> ignore entire line (allows inline comments) +# A line beginning with '[' terminates the parsing +# diff --git a/res/HELP b/res/HELP new file mode 100644 index 0000000..cea01e0 Binary files /dev/null and b/res/HELP differ diff --git a/res/HELPTEXT b/res/HELPTEXT new file mode 100644 index 0000000..1680919 --- /dev/null +++ b/res/HELPTEXT @@ -0,0 +1,20 @@ + + + + + < and > to browse games + + T Y P E to find a game + + [Return] to play + + [Space] to preview + + [Esc] to go back + + [Ctrl-C] to cheat + + [Ctrl-P] joystick + + [Ctrl-A] credits +[eof] diff --git a/res/ICONS/TR.ICONS b/res/ICONS/TR.ICONS new file mode 100644 index 0000000..24b07d5 Binary files /dev/null and b/res/ICONS/TR.ICONS differ diff --git a/res/ICONS/_FileInformation.txt b/res/ICONS/_FileInformation.txt new file mode 100644 index 0000000..0430b70 --- /dev/null +++ b/res/ICONS/_FileInformation.txt @@ -0,0 +1,4 @@ +# This file is automatically generated + +TR.ICONS=Type(CA),AuxType(0000),Access(C3) +_FileInformation.txt=Type(CA),AuxType(0000),Access(C3) diff --git a/res/JOYSTICK b/res/JOYSTICK new file mode 100644 index 0000000..7454767 Binary files /dev/null and b/res/JOYSTICK differ diff --git a/res/PREFS.CONF b/res/PREFS.CONF new file mode 100644 index 0000000..3634789 --- /dev/null +++ b/res/PREFS.CONF @@ -0,0 +1,17 @@ +# Total Replay preferences file +# Do not edit by hand. +# Or do. I'm a comment, not a cop. + +# value=attract mode module listed in ATTRACT.CONF, or empty +NEXTATTRACT= + +# value=transition effect listed in FX.CONF, or empty +NEXTFX= + +# value=transition effect listed in DFX.CONF, or empty +NEXTDFX= + +# value=0 or 1 +CHEAT=0 + +[eof] diff --git a/res/SS/ACTIONKAR.CONF b/res/SS/ACTIONKAR.CONF new file mode 100644 index 0000000..4a594f7 --- /dev/null +++ b/res/SS/ACTIONKAR.CONF @@ -0,0 +1,8 @@ +# +# Karate action slideshow +# + +BLACK.BELT +BLACK.BELT2=BLACK.BELT + +[eof] diff --git a/res/SS/KARATE.CONF b/res/SS/KARATE.CONF new file mode 100644 index 0000000..9dbabf7 --- /dev/null +++ b/res/SS/KARATE.CONF @@ -0,0 +1,7 @@ +# +# Karate slideshow +# + +BLACK.BELT + +[eof] diff --git a/res/SS/_FileInformation.txt b/res/SS/_FileInformation.txt new file mode 100644 index 0000000..52861c5 --- /dev/null +++ b/res/SS/_FileInformation.txt @@ -0,0 +1,5 @@ +# This file is automatically generated + +ACTIONKAR.CONF=Type(04),AuxType(4000),Access(C3) +KARATE.CONF=Type(04),AuxType(4000),Access(C3) +_FileInformation.txt=Type(04),AuxType(4000),Access(C3) diff --git a/res/TITLE b/res/TITLE new file mode 100644 index 0000000..bf4c152 Binary files /dev/null and b/res/TITLE differ diff --git a/res/TITLE.ANIMATED/_FileInformation.txt b/res/TITLE.ANIMATED/_FileInformation.txt new file mode 100644 index 0000000..1d9e598 --- /dev/null +++ b/res/TITLE.ANIMATED/_FileInformation.txt @@ -0,0 +1 @@ +# This file is maintained by hand diff --git a/res/TITLE.DHGR/_FileInformation.txt b/res/TITLE.DHGR/_FileInformation.txt new file mode 100644 index 0000000..956501c --- /dev/null +++ b/res/TITLE.DHGR/_FileInformation.txt @@ -0,0 +1,3 @@ +# This file is automatically generated + +_FileInformation.txt=Type(06),AuxType(4000),Access(C3) diff --git a/res/TITLE.HGR/_FileInformation.txt b/res/TITLE.HGR/_FileInformation.txt new file mode 100644 index 0000000..64ddec5 --- /dev/null +++ b/res/TITLE.HGR/_FileInformation.txt @@ -0,0 +1,4 @@ +# This file is automatically generated + +BLACK.BELT=Type(06),AuxType(4000),Access(C3) +_FileInformation.txt=Type(06),AuxType(4000),Access(C3) diff --git a/res/_FileInformation.txt b/res/_FileInformation.txt new file mode 100644 index 0000000..634f205 --- /dev/null +++ b/res/_FileInformation.txt @@ -0,0 +1,17 @@ +# This file is maintained by hand + +LAUNCHER.SYSTEM=Type(FF),AuxType(2000),Access(C3) +PREFS.CONF=Type(04),AuxType(8000),Access(C3) +GAMES.CONF=Type(04),AuxType(8000),Access(C3) +ATTRACT.CONF=Type(04),AuxType(8000),Access(C3) +FX.CONF=Type(04),AuxType(8000),Access(C3) +DFX.CONF=Type(04),AuxType(8000),Access(C3) +COVER=Type(06),AuxType(2000),Access(C3) +TITLE=Type(06),AuxType(2000),Access(C3) +HELP=Type(06),AuxType(2000),Access(C3) +CREDITS=Type(04),AuxType(8000),Access(C3) +HELPTEXT=Type(04),AuxType(8000),Access(C3) +DECRUNCH=Type(06),AuxType(0200),Access(C3) +JOYSTICK=Type(06),AuxType(0800),Access(C3) +Finder.Data=Type(C9),AuxType(0000),Access(E7) +Finder.Root=Type(C9),AuxType(0000),Access(E7) diff --git a/res/history.md b/res/history.md new file mode 100644 index 0000000..96802d6 --- /dev/null +++ b/res/history.md @@ -0,0 +1,9 @@ +# Revision 1 / unreleased + +## New games + + - Black Belt + +## Migrated from Total Replay + + - ... diff --git a/res/proboothd b/res/proboothd new file mode 100644 index 0000000..ad00609 Binary files /dev/null and b/res/proboothd differ diff --git a/src/4sports.a b/src/4sports.a new file mode 100644 index 0000000..5f1a592 --- /dev/null +++ b/src/4sports.a @@ -0,0 +1,205 @@ +;license:MIT +;(c) 2018-2021 by 4am +; +!cpu 6502 +!to "build/LAUNCHER.SYSTEM",plain +*=$2000 + +!ifndef RELBASE { +RELBASE=$2000 +} + + !source "src/constants.a" ; no code in these + !source "src/macros.a" + + ; first-run initialization, relocates code to language card and jumps + ; to |Reenter| + !source "src/4sports.init.a" + !source "src/4sports.init.cffa.a" + !source "src/4sports.init.gs.a" + +FirstMover +!pseudopc RELBASE { +;------------------------------------------------------------------------------ +; Reenter +; This is the primary entry point for returning to the launcher from anywhere. +; - Self-running demos call this when the user presses a key or when the demo +; cycles ends naturally. +; - It is set as the reset vector, so the user can play a game then press +; Ctrl-Reset to return to the launcher and choose another. +; - It also functions as a reset vector while the launcher is running. +; - It is also called on program startup, after the first-run initialization. +; +; When execution reaches this point, we may have previously backed up the stack +; and stack pointer, in which case it is now our job to restore it and return +; to the caller. This allows magic like 'JSR PlayGame' then continuing once the +; JSR returns. +; +; If there is no stack to restore, this exits via SearchMode. +; +; in: none +; out: see above +;------------------------------------------------------------------------------ +Reenter + cld + ldx #$ff + txs ; so that we never trash the reset vector + jsr SwitchToBank2 + jsr DisableAccelerator ; back to 1 MHz (especially important on IIgs + ; which restores default speed on Ctrl-Reset) + jsr CloseHandles ; close any open handles to restore ProRWTS + ldx #(end_promote-promote-1) +- lda promote,x ; copy ProDOS shim to main memory for GS/OS exit + sta $bf00,x + dex + bpl - + ldx #5 +- lda ResetVector,x ; copy reentry wrapper to bottom of stack + sta $100,x ; (used as reset vector because //e always + dex ; switches to ROM on Ctrl-Reset) + bpl - + inx + stx $3F2 ; page 3 reset vector to ($100) + sei + stx $3FE ; page 3 IRQ vector to ($100) + inx + stx $3FF + cli + stx $3F3 + ldx #$A4 + stx $3F4 +RestoreStackNextTime + bne SearchMode ; (SMC) not an unconditional branch because code + ; might change the branch target to the next opcode + ; If we fall through to here, it's because we backed up the stack and + ; stack pointer and wanted this routine to restore it and return to + ; caller. + lda #(SearchMode - RestoreStackNextTime) - 2 + ; reset to branch so we don't try to + sta RestoreStackNextTime + 1 + ; restore the same stack twice + ldx #$F1 +- lda STACKBASE - $EF,x ; restore stack + sta $100,x + inx + bne - +STACKPTR + ldx #$D1 ; SMC, restore stack pointer + txs +SwitchToBank1 + +READ_RAM1_WRITE_RAM1 + rts +ResetVector ; 6 bytes, copied to $100 + +READ_RAM1_NO_WRITE + jmp Reenter + + ; these routines will only be called after relocating to language card + !source "src/ui.search.mode.a" ; \__ execution falls through + !source "src/ui.animation.a" ; / + + !source "src/ui.browse.mode.a" + !source "src/ui.attract.mode.a" + !source "src/ui.attract.hgr.a" + !source "src/ui.attract.dhgr.a" + !source "src/ui.attract.shr.a" + !source "src/ui.attract.gr.a" + !source "src/ui.offscreen.a" + !source "src/ui.cheats.a" + !source "src/ui.credits.a" + !source "src/ui.reboot.a" + !source "src/ui.common.a" + !source "src/ui.font.a" + !source "src/ui.overlay.a" + !source "src/parse.prefs.a" + !source "src/parse.common.a" + !source "src/glue.launch.a" + !source "src/glue.prorwts2.a" + !source "src/glue.decompress.a" + !source "src/textrank.a" + !source "src/okvs.a" + !source "src/wait.a" + + ; add new files above here + !source "src/hw.vbl.a" + !source "src/ui.wait.a" +gAttractModeStore +gFXStore +gDFXStore + !word $6000 +gSearchStore + !word $8200 +gSlideshowStore + !word $0800 +gGlobalPrefsStore + !word $D001 ; leave $D000 alone because FastChip accelerator + ; flips out if it has certain values (it will + ; be set to $55 as part of the 64K memory test, + ; which is apparently one of the acceptable values) +gGamesListStore + !word $FDFD ; SMC +SwitchToBank2 + +READ_RAM2_WRITE_RAM2 + rts + !source "src/prodos.path.a" ; paths end up on the same page + +; WaitForVBL (label is in constants.a) + jmp WaitForVBL_iie ; SMC to RTS on a II+ + +; UnwaitForVBL (label is in constants.a) + rts ; SMC to JMP on a IIc + !word iUnwaitForVBL + +; MockingboardStuff (label is in constants.a) +; slot number where Mockingboard was detected and type of board +; #$00 if no Mockingboard detected + !byte $FD ; MockingboardStuff ($FFF8) +; MachineStatus (label is in constants.a so prelaunchers can use it) +; 7 6 5 4 3 2 1 0 +; | | | | | | | +- bit 0 reserved +; | | | | | | +--- bit 1 reserved +; | | | | | +----- bit 2 reserved +; | | | | +------- bit 3 = 1 if cheats are enabled +; | | | +--------- bit 4 = 1 if VidHD +; | | +----------- bit 5 = 1 if IIgs +; | +------------- bit 6 = 1 if 128K +; +--------------- bit 7 = 1 if joystick +; Use the bit masks defined in constants.a + !byte $FD ; MachineStatus ($FFF9) + !word Reenter ; NMI vector ($FFFA-B) + !word Reenter ; reset vector ($FFFC-D) + !word Ignore ; IRQ vector ($FFFE-F) +} +LastMover +COPYSRC = * +!pseudopc hdddataend { + COPYDST = * + !source "src/prodos.impl.lc2.a" + !source "src/ui.font.lc2.a" + !source "src/glue.prorwts2.lc2.a" + !source "src/glue.launch.lc2.a" + !source "src/hw.accel.lc2.a" + STACKBASE = * + LCRAM2_END = STACKBASE + 15 + !if LCRAM2_END >= DisableAccelerator { + !error "code is too large: ends at ", LCRAM2_END + } + FONTDST = (LCRAM2_END + 255) and -256 +} +EvenLasterMover + FONTSRC = * +!pseudopc FONTDST { + !source "src/ui.font.data.lc2.a" + !if * > $E000 { + !error "code is too large: ends at ", * + } +} +!if RELBASE = $2000 { + !ifdef PASS2 { + } else { ;PASS2 + !set PASS2=1 + !warn "ProRWTS ends at ", hdddataend - 1 + !warn "STACK at ", STACKBASE + !warn "LCRAM2 ends at ", LCRAM2_END + !warn "RELBASE = ", $10000 - (LastMover - FirstMover) + } +} diff --git a/src/4sports.init.a b/src/4sports.init.a new file mode 100644 index 0000000..8354e2d --- /dev/null +++ b/src/4sports.init.a @@ -0,0 +1,462 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; first-run initialization code +; +; This file is included directly and is run from $2000/main as soon as the +; .SYSTEM file is loaded +; + + +READ_ROM_NO_WRITE + sta PRIMARYCHARSET + sta CLR80VID + sta STOREOFF + sta READMAINMEM + sta WRITEMAINMEM + jsr ROM_TEXT + jsr ROM_HOME + jsr ROM_NORMAL + jsr ROM_IN0 + jsr ROM_PR0 + jsr Has64K ; check for 64K (required) + bcc + + + ldy #@no64Klen +- lda @s_no64K,y + sta $6B6,y + dey + bpl - +@hang bmi @hang +@s_no64K !scrxor $80,"REQUIRES 64K" +@no64Klen=(*-@s_no64K)-1 + ++ + lda #0 + sta zpMachineStatus + sta SETC3ROM + jsr HasVidHDCard ; check for VidHD card (allows super hi-res artwork even on non-IIgs machines) + sta CLRC3ROM + ror zpMachineStatus + lda ROM_MACHINEID + cmp #$06 + bne @NotGS + sec + jsr $FE1F ; check for IIgs (allows super hi-res artwork) + bcs @NotGS + sec + +HIDE_NEXT_BYTE +@NotGS clc + ror zpMachineStatus + jsr Has128K ; check for 128K (allows DHGR slideshows and 128K games) + ror zpMachineStatus + jsr HasJoystick ; check for joystick (absence is OK but we filter out some games that require a joystick) + ror zpMachineStatus + ; now bit 4 = 1 if VidHD + ; bit 5 = 1 if IIgs + ; bit 6 = 1 if 128K + ; bit 7 = 1 if joystick + ; and all other bits are 0 (we'll set bit 3 after copying it to LC RAM) + + ; accommodate uppercase-only machines (64K ][+ is supported) + lda ROM_MACHINEID + cmp #$A0 + beq + ; Spectrum ED + cmp #$06 + beq + + lda #$DF + +HIDE_NEXT_2_BYTES ++ lda #$FF + sta zpCharMask + + ; print text title in same place as graphical title will appear + ldy #8 +- lda TOTAL,y + ora #$80 + sta $04B7,y + dey + bpl - + ldy #10 +- lda REPLAY,y + ora #$80 + sta $0536,y + dey + bpl - + + ; increase text window width so we can print to the edge of the screen without scrolling + inc $21 + ; print version or build number in lower right corner + ldx #30 + ldy #23 + jsr SetCursorPosition + +LDADDR LoadingVersion + jsr LoadingPrint +!ifndef RELEASE { + lda LoadingBuild + ldx LoadingBuild+1 + ldy #0 + jsr PrintAsDecimal +} + + ; set up text window so it only covers lower left corner + lda #30 + sta $21 + lda #19 + sta $22 + + ; print machine configuration in lower left corner + ldx #0 + ldy #23 + jsr SetCursorPosition + + ; if zpMachineStatus AND IS_IIGS then print 'IIgs' + ; else if zpMachineStatus AND HAS_128K then print '128K' + ; else print '64K' + lda zpMachineStatus + and #IS_IIGS + beq + + +LDADDR LoadingIIgs + bne @printMem ++ lda zpMachineStatus + and #HAS_128K + beq + + +LDADDR Loading128K + bne @printMem ++ + +LDADDR Loading64K +@printMem + jsr LoadingPrint + + ; if zpMachineStatus AND HAS_JOYSTICK then CR & print 'joystick' + lda zpMachineStatus + and #HAS_JOYSTICK + beq + + jsr LoadingCR + +LDADDR LoadingJoystick + jsr LoadingPrint ++ + ; if zpMachineStatus AND HAS_VIDHD then CR & print 'VidHD' + lda zpMachineStatus + and #HAS_VIDHD + beq + + jsr LoadingCR + +LDADDR LoadingVidHD + jsr LoadingPrint ++ + +@Relocate + ; if zpMachineStatus AND IS_IIGS then check for CFFA + ; before performing any further disk access + lda zpMachineStatus + and #IS_IIGS + beq + + jsr HackThaCFFA + ++ + +READ_ROM_WRITE_RAM2 + jsr init ; initialize and relocate ProRWTS2 to $D400 in RAM bank 2 + ; ProRWTS2 disk-data live at $D000-D3FF + ldx #$00 ; relocate program code to top of language card + ; since we end at $0000 now, adjust low offset to avoid destroying zpage +@FM lda FirstMover - (RELBASE & $FF),x + sta RELBASE & $FF00,x + inx + bne @FM + inc @FM+2 + inc @FM+5 + bne @FM + + ldy #>(255 + EvenLasterMover - LastMover) +@LM lda COPYSRC,x ; relocate pseudo-ProDOS to RAM bank 2 + sta COPYDST,x + inx + bne @LM + inc @LM+2 + inc @LM+5 + dey + bne @LM + + ldy #4 +@ELM lda FONTSRC,x + ; relocate font data to RAM bank 2 + sta FONTDST,x + inx + bne @ELM + inc @ELM+2 + inc @ELM+5 + dey + bne @ELM + + +READ_ROM_NO_WRITE + jsr BuildAcceleratorFunction + +READ_RAM2_WRITE_RAM2 + +ST16 @accelSrc + dex +- +@accelSrc=*+1 + lda $FDFD,x ; copy (de)acceleration functions to RAM bank 2 + sta DisableAccelerator,x + dex + bpl - + + +READ_ROM_WRITE_RAM2 + jsr BuildVBLFunction + +DISABLE_ACCEL ; cycle counting in Mockingboard detection requires 1MHz + + +LDADDR FoundMockingboardCallback + jsr GetMockingboardStuff + +READ_RAM2_WRITE_RAM2 + stx MockingboardStuff ; save mockingboard slot and type in LC RAM + +READ_ROM_NO_WRITE + + ; if Mockingboard AND HAS_SPEECH then print CR & '...and it talks!' + txa + and #HAS_SPEECH + beq + + jsr LoadingCR + +LDADDR LoadingMockingboardSpeech + jsr LoadingPrint + ++ + +READ_RAM2_WRITE_RAM2 + jsr EnableAccelerator + jmp OneTimeSetup + + ; ProRWTS2 has its own function to relocate itself + !source "src/prorwts2.a" +ProRWTSBuffer + ; these routines will only be called once, from main memory, before relocating to language card + !source "src/hw.vidhd.a" + !source "src/hw.memcheck.a" + !source "src/hw.joystick.a" + !source "src/hw.mockingboard.a" + +SetCursorPosition + stx HTAB + sty VTAB + jmp $FC22 + +LoadingPrint + +ST16 PTR + ldy #0 + lda (PTR),y + sta @max + sty i +- inc i + ldy i + lda (PTR),y + ora #$80 + +FORCE_UPPERCASE_IF_REQUIRED + jsr ROM_COUT + ldy i +@max=*+1 + cpy #$FD ; SMC + bne - + rts + +LoadingCR + lda #$8D + jmp ROM_COUT + +FoundMockingboardCallback +; in: zp$81 contains slot number in form $Cx + jsr LoadingCR + +LDADDR LoadingMockingboard + jsr LoadingPrint + lda $81 + and #$0F + ora #$B0 + jmp ROM_COUT + +TOTAL + !text "T O T A L" +REPLAY + !text "R E P L A Y" +!ifndef RELEASE { +LoadingVersion + !byte 9 + !text "build 000" +LoadingBuild + !word BUILDNUMBER +} else { +LoadingVersion + !byte 10 + !text " v1.0" +} +Loading64K + !byte 3 + !text "64K" +Loading128K + !byte 4 + !text "128K" +LoadingIIgs + !byte 4 + !text "IIgs" +LoadingJoystick + !byte 8 + !text "joystick" +LoadingVidHD + !byte 5 + !text "VidHD" +LoadingMockingboard + !byte 21 + !text "Mockingboard in slot " +LoadingMockingboardSpeech + !byte 16 + !text "...and it talks!" + +!ifndef RELEASE { +PrintAsDecimal + jsr $FF4A + + lda $FDE2 + cmp #$EA + bne + + dec @addr+1 ; fix for Laser ++ +-- lda #$00 + clv + ldx #$18 +- cmp #$05 + bcc + + sbc #$85 + sec ++ rol $45 + rol $46 + rol $47 + rol + dex + bne - + pha + lda #$FD + pha +@addr lda #$E1 + pha + bvs -- + rts +} + + !source "src/hw.accel.a" + !source "src/hw.vbl.init.a" + !source "src/parse.games.a" + +OneTimeSetup + lda zpMachineStatus + sta MachineStatus ; save machine status in LC RAM + and #IS_IIGS + beq @NotGSOS +!cpu 65816 + lda $E100BD ; Make sure GS/OS was the boot OS +!cpu 6502 + beq @NotGSOS + jsr PrepareGSOS +@NotGSOS + + ldy #$0b +CopyDevs + lda $BF13,y + sta promote + $13,y + dey + bpl CopyDevs + + lda $BF30 + sta promote + ProDOS_unit - $bf00 + ; save unit in LC bank 2 while overriding !pseudopc + + lda hddopendir+1 ; save current directory as 'root' + ldy hddopendir+3 + jsr SwitchToBank1 + +ST16 gRootDirectory + + jsr LoadFile ; load preferences file into $8000 + !word kRootDirectory + !word kGlobalPrefsFilename +- !word $8000 + jsr ParseKeyValueList ; parse contents into OKVS data structure into LC RAM bank + !word gGlobalPrefsStore + !word - + !byte 16 + +LD16 SRC ; (SRC) points to free space after the OKVS data structure we just created + +ST16 gGamesListStore ; save pointer to free space for next store + + jsr LoadFile ; load games list file into $8200 + !word kRootDirectory + !word @kGameListConfFile +- !word $8200 + jsr ParseGamesList ; parse games list into OKVS data structure in LC RAM bank + !word gGamesListStore + !word - + +!ifndef RELEASE { + +READ_ROM_NO_WRITE + lda #40 + sta $21 + lda #36 + sta $24 + dec $25 + jsr $FC22 + lda SRC+1 + jsr $FDDA + lda SRC + jsr $FDDA + +READ_RAM1_WRITE_RAM1 +} + + +LDADDR gGamesListStore + jsr okvs_len + +LD16 WCOUNT + +ST16 GameCount + +ST16 SAVE + + jsr pref_get ; see if cheats are enabled by default + !word kCheat + !word 0 + +ST16 PTR ; (PTR) -> cheat pref value as length-prefixed string '1' or '0' + ldy #1 + lda (PTR),y ; A = #$B1 or #$B0 + and #1 ; A = #$01 or #$00 + asl + asl + asl ; A = #$08 or #$00 + ora MachineStatus + sta MachineStatus ; set bit 3 of MachineStatus + + ; calculate and update visible game count (3-digit decimal number as ASCII string) + dey ; Y = 0 +@outer + lda #0 + pha +@inner + lda SAVE + sec + sbc @kPowersOfTen,y + sta SAVE + lda SAVE+1 + sbc #0 + bcc @digitDone + sta SAVE+1 + pla + adc #0 + pha + jmp @inner +@digitDone + lda SAVE + adc @kPowersOfTen,y + sta SAVE + pla + ora #$30 + sta VisibleGameCount,y + iny + cpy #$03 + bcc @outer + + bit CLEARKBD + jmp Reenter + +@kGameListConfFile + !byte 10 + !text "GAMES.CONF" + +@kPowersOfTen + !byte 100 + !byte 10 + !byte 1 diff --git a/src/4sports.init.cffa.a b/src/4sports.init.cffa.a new file mode 100644 index 0000000..894f7af --- /dev/null +++ b/src/4sports.init.cffa.a @@ -0,0 +1,89 @@ +;license:MIT +;(c) 2020 by qkumba +; +; CFFA-specific work-around for an issue on the GS +; + +HackThaCFFA + ldx #0 + beq @CFFAbase1 +@loopCFFA + cmp @CFFA_ID-1,x + bne @nextslot +@CFFAbase1 + lda $C7F6,x + inx + cpx #5 + bne @loopCFFA + sbc #'0' + cmp #2 ; only 3.0x and 3.1x + bcc @foundCFFA + rts + +@nextslot + dec @CFFAbase1+2 + lda @CFFAbase1+2 + cmp #$C0 + bne HackThaCFFA + rts + +@foundCFFA + lda @CFFAbase1+2 + sta @CFFAbase2+2 + +!cpu 65816 + clc + xce + ldx #0 +- inx + lda $FE0002,x + cmp #$FE ; find anything we can use as bank==#$FE + bne - + stx @patchROM+1 + rep #$30 +!al +!rl + sei + ldx #$00A0 + lda $CFFF +@CFFAbase2 + lda $D100 ; SMC +- dex + beq @returnCFFA + lda $CC04,x + eor #$02AE + bne - + tay +- lda @patchCFFA_b,y + sta $CC00,x + inx + inx + iny + iny + cpy #(@patchCFFA_e-@patchCFFA_b) + bcc - + +@returnCFFA + cli + sec + xce + rts + +!as +!rs +@patchCFFA_b + stz $C806 + stz $C807 ; no error +@patchROM + lda #$D1 ; SMC + sta $C808 + stz $C809 + lda #$FE + sta $C80A ; handle at FE/00xx + stz $C80B + rts +@patchCFFA_e + +@CFFA_ID !text "CF3K" + +!cpu 6502 diff --git a/src/4sports.init.gs.a b/src/4sports.init.gs.a new file mode 100644 index 0000000..0b8dafa --- /dev/null +++ b/src/4sports.init.gs.a @@ -0,0 +1,105 @@ +;license:MIT +;(c) 2020 by qkumba +; +; GS-specific code to support return-to-GS/OS +; + +PrepareGSOS +!cpu 65816 + clc + xce + rep #$30 +!al +!rl + pha ; reserve word return + pea $1100 ; application-type, auxId #1 + ldx #$2003 ; GetNewID + jsl $E10000 + ply + sty @userID+1 + pha + pha ; reserve dword return + pha + pea @return_e-@return_b ; dword size + phy ; ID + pea $8010 ; attrib (locked, can't cross bank) + pha + pha ; dword 0 + ldx #$0902 ; NewHandle + jsl $E10000 + plx + ply ; handle + pha + pea @return_b ; ptr + phy + phx ; handle + pha + pea @return_e-@return_b ; size + tya + xba + sta @handle2+2 + stx @handle2+1 + inx + inx + sta @handle1+2 + stx @handle1+1 + + lda #$FB18 ; CLC / XCE + sta PatchQuit + lda #$005C ; JML + sta PatchQuit+2 + +@handle1 + lda $D1D1D1 ; SMC + sta PatchQuit+5 + xba + sta @copycallback+2 +@handle2 + lda $D1D1D1 ; SMC + sta PatchQuit+3 + adc #@callback_b-@return_b + sta @copycallback+1 + + ldx #$2802 ; PtrToHand + jsl $E10000 ; copy hook code to allocated memory + + sec + xce + rts + +@return_b + rep #$30 ; called from 8-bit code but with e=0 + ldx #((@callback_e-@callback_b)+1) and -2 + +@copycallback + lda $D1D1D1,x ; SMC + sta $BF00,x + dex + dex + bpl @copycallback +@userID pea $D1D1 ; SMC + ldx #$1102 ; DisposeAll + phb + pea ($BF00+@jmpGSOS-@callback_b)-1 + jmp $E10000 + +@callback_b +!cpu 65C02 + plx + inx + inx + inx + phx + lda #$B3 + sta $204 + lda #0 + sta $280 + rts +!cpu 65816 +@jmpGSOS + sep #$30 ; revert to 8-bit mode + jmp $E0D000 +@callback_e +@return_e + +!cpu 6502 diff --git a/src/constants.a b/src/constants.a new file mode 100644 index 0000000..3fae2db --- /dev/null +++ b/src/constants.a @@ -0,0 +1,161 @@ +;license:MIT +;(c) 2018-2020 by 4am +; + +;------------------------------------------------------------------------------ +; YE OLDE GRAND UNIFIED MEMORY MAP +; +; LC RAM BANK 1 +; D000..E92C - persistent data structures (gGlobalPrefsStore, gGamesListStore) +; E92D..FFF1 - main program code +; FFF2..FFF9 - API functions and global constants available for main program +; code, prelaunchers, transition effects, &c. +; (Wait/UnwaitForVBL, MockingboardStuff, MachineStatus) +; FFFA..FFFF - NMI, reset, IRQ vectors +; +; LC RAM BANK 2 +; D000..D3FF - ProRWTS data +; D400..D677 - ProRWTS code +; D678..DB9D - HGR font code & ProRWTS glue code +; DB9E..DBAD - backup of stack (during gameplay and self-running demos) +; ...unused... +; DBB4..DBFF - (de)acceleration function +; DC00..DFFF - HGR font data +;------------------------------------------------------------------------------ + +!ifndef _CONSTANTS_ { + +; soft switches +KBD = $C000 ; last key pressed (if any) +CLEARKBD = $C010 ; clear last key pressed +STOREOFF = $C000 ; STA then use the following 4 flags: +READMAINMEM = $C002 ; STA to read from main mem +READAUXMEM = $C003 ; STA to read from aux mem +WRITEMAINMEM = $C004 ; STA to write to main mem +WRITEAUXMEM = $C005 ; STA to write to aux mem +CLRC3ROM = $C00A ; STA to use internal Slot 3 ROM (required to use 128K and DHGR) +SETC3ROM = $C00B ; STA to use external Slot 3 ROM (required to detect VidHD in slot 3) +CLR80VID = $C00C ; 40 columns (also used to get out of DHGR mode) +SET80VID = $C00D ; 80 columns (also used to get into DHGR mode) +PRIMARYCHARSET= $C00E ; no mousetext for you +SLOT3STATUS = $C017 ; bit 7 only +TBCOLOR = $C022 ; IIgs text foreground and background colors (also VidHD) +NEWVIDEO = $C029 ; IIgs graphics modes (also VidHD) +SPEAKER = $C030 ; chirp chirp +CLOCKCTL = $C034 ; bits 0-3 are IIgs border color (also VidHD) +SHADOW = $C035 ; IIgs auxmem-to-bank-E1 shadowing (also VidHD) +TEXTMODE = $C051 +PAGE1 = $C054 ; page 1 (affects text, HGR, DHGR) +PAGE2 = $C055 ; page 2 (affects text, HGR, DHGR) +DHIRESON = $C05E ; double hi-res on switch +DHIRESOFF = $C05F ; double hi-res off switch + +; ROM routines and addresses +; (prefixed because so much of the program runs from LC RAM, so don't call +; these without thinking about memory banks first) +ROM_TEXT2COPY =$F962 ; turn on alternate display mode on IIgs +ROM_REBOOT = $FAA6 +ROM_TEXT = $FB2F +ROM_MACHINEID =$FBB3 +ROM_HOME = $FC58 +ROM_COUT = $FDED +ROM_NORMAL = $FE84 ; NORMAL text (instead of INVERSE or FLASH) +ROM_IN0 = $FE89 ; SETKBD +ROM_PR0 = $FE93 ; SETVID + +; zero page during init ONLY +zpMachineStatus= $F0 ; bit 7 = 1 if machine has joystick + ; bit 6 = 1 if machine has 128K + ; bit 5 = 1 if machine has a VidHD card + ; bit 4 = 1 if machine is a IIgs + ; only used during init, then copied to MachineStatus in LC RAM +zpCharMask = $F1 ; only used during init, then clobbered + +; zero page +PARAM = $00 ; word (used by PARAMS_ON_STACK macro, so basically everywhere) +PTR = $02 ; word +SRC = $04 ; word +DEST = $06 ; word +SAVE = $08 ; word +WINDEX = $0A ; word +WCOUNT = $0C ; word +HTAB = $24 ; byte +VTAB = $25 ; byte +RNDSEED = $4E ; word +; textrank +BestMatchIndex = $E5 ; word +tmpx = $E7 ; byte +remainder = $E8 ; word +num1 = $EA ; word +num2 = $EC ; byte +Timeout = $ED ; 3 bytes (used by SearchMode) +zpword = $F0 ; word +zpstring = $F2 ; word +runningscore= $F4 ; word +startat = $F6 ; byte +i = $F7 ; byte +tmp = $F8 ; byte +gamelength= $F9 ; byte +firstletter= $FA ; byte +MatchCount = $FB ; byte +BestMatchScore = $FC ; byte + +; $FE ; used by ParseGamesList +; $FF ; used by ParseGamesList + +; main memory +gPathname = $BFD0 ; used by SetPath/AddToPath +gKeyLen = $1F00 ; used by ParseGamesList +gKey = $1F01 +UILine1 = $1FB0 +UILine2 = $1FD8 +UI_ToPlay = $1FF7 + +gValLen = $1F80 +gVal = $1F81 + +; LC RAM 1 +WaitForVBL = $FFF2 +UnwaitForVBL = $FFF5 + +MockingboardStuff = $FFF8 ; bit 7 = 1 if speech chip present (Mockingboard "C") + ; bit 6 = 1 if Mockingboard "B" (stereo) found (else Mockingboard "A") + ; bit 4-5 unused + ; bits 0-3: slot number +MachineStatus = $FFF9 + +; LC RAM 2 +DisableAccelerator = $DBB4 +EnableAccelerator = DisableAccelerator+3 + +; AND masks for MockingboardStuff +MOCKINGBOARD_SLOT = %00001111 +HAS_SPEECH = %10000000 + +; AND masks for game info bitfield (after game display name in gGamesListStore) +HAS_DHGR_TITLE = %10000000 ; this one is hard-coded via BMI instead of AND/BNE +CHEAT_CATEGORY = %00001111 + +; AND masks for MachineStatus +HAS_JOYSTICK = %10000000 +HAS_128K = %01000000 +IS_IIGS = %00100000 ; /!\ do not use this to gate SHR, use SUPPORTS_SHR instead +HAS_VIDHD = %00010000 +SUPPORTS_SHR = %00110000 +CHEATS_ENABLED = %00001000 + +; shared symbols for prelaunch and effects to call ProRWTS2 functions +iCurBlockLo = $D401 +iCurBlockHi = $D403 +iProDOS_enter = $D678 +LoadFileDirect = $DB01 +iAuxReq = $DB27 +launchpatch = $D616 +iAddToPath = $FEC3 +itraverse = $D8E0 +ldrhi = $56 +namlo = $57 +namhi = $58 + +_CONSTANTS_=* +} diff --git a/src/decrunch/exodecrunch.a b/src/decrunch/exodecrunch.a new file mode 100644 index 0000000..346f0a4 --- /dev/null +++ b/src/decrunch/exodecrunch.a @@ -0,0 +1,453 @@ +; This source code is altered and is not the original version found on +; the Exomizer homepage. +; It contains modifications made by qkumba to work with ACME assembler. +!cpu 6502 +!to "DECRUNCH",plain +*=$200 + +; +; Copyright (c) 2002 - 2018 Magnus Lind. +; +; This software is provided 'as-is', without any express or implied warranty. +; In no event will the authors be held liable for any damages arising from +; the use of this software. +; +; Permission is granted to anyone to use this software for any purpose, +; including commercial applications, and to alter it and redistribute it +; freely, subject to the following restrictions: +; +; 1. The origin of this software must not be misrepresented; you must not +; claim that you wrote the original software. If you use this software in a +; product, an acknowledgment in the product documentation would be +; appreciated but is not required. +; +; 2. Altered source versions must be plainly marked as such, and must not +; be misrepresented as being the original software. +; +; 3. This notice may not be removed or altered from any distribution. +; +; 4. The names of this software and/or it's copyright holders may not be +; used to endorse or promote products derived from this software without +; specific prior written permission. +; +; ------------------------------------------------------------------- +; The decruncher jsr:s to the get_crunched_byte address when it wants to +; read a crunched byte into A. This subroutine has to preserve X and Y +; register and must not modify the state of the carry nor the overflow flag. +; ------------------------------------------------------------------- +;.import get_crunched_byte +; ------------------------------------------------------------------- +; this function is the heart of the decruncher. +; It initializes the decruncher zeropage locations and precalculates the +; decrunch tables and decrunches the data +; This function will not change the interrupt status bit and it will not +; modify the memory configuration. +; ------------------------------------------------------------------- +;.export decrunch + +; ------------------------------------------------------------------- +; Controls if the shared get_bits routines should be inlined or not. +;INLINE_GET_BITS=1 +; ------------------------------------------------------------------- +; if literal sequences is not used (the data was crunched with the -c +; flag) then the following line can be uncommented for shorter and. +; slightly faster code. +;LITERAL_SEQUENCES_NOT_USED = 1 +; ------------------------------------------------------------------- +; if the sequence length is limited to 256 (the data was crunched with +; the -M256 flag) then the following line can be uncommented for +; shorter and slightly faster code. +;MAX_SEQUENCE_LENGTH_256 = 1 +; ------------------------------------------------------------------- +; if the sequence length 3 has its own offset table then the following +; line can be uncommented for in some situations slightly better +; compression at the cost of a larger decrunch table. +EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE = 1 +; ------------------------------------------------------------------- +; zero page addresses used +; ------------------------------------------------------------------- +zp_len_lo = $a7 +zp_len_hi = $a8 + +zp_src_lo = $ae +zp_src_hi = zp_src_lo + 1 + +zp_bits_hi = $fc + +zp_bitbuf = $fd +zp_dest_lo = zp_bitbuf + 1 ; dest addr lo +zp_dest_hi = zp_bitbuf + 2 ; dest addr hi + +!IFDEF EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE { +encoded_entries = 68 +} ELSE { +encoded_entries = 52 +} + +tabl_bi = decrunch_table +tabl_lo = decrunch_table + encoded_entries +tabl_hi = decrunch_table + encoded_entries * 2 + + ;; refill bits is always inlined +!MACRO mac_refill_bits { + pha + jsr get_crunched_byte + rol + sta zp_bitbuf + pla +} + +!IFDEF INLINE_GET_BITS { +!MACRO mac_get_bits { + adc #$80 ; needs c=0, affects v + asl + bpl gb_skip +gb_next: + asl zp_bitbuf + bne gb_ok + mac_refill_bits +gb_ok: + rol + bmi gb_next +gb_skip: + bvc skip +gb_get_hi: + sec + sta zp_bits_hi + jsr get_crunched_byte +skip: +} +} ELSE { +!MACRO mac_get_bits { + jsr get_bits +} +} + +; ------------------------------------------------------------------- +; no code below this comment has to be modified in order to generate +; a working decruncher of this source file. +; However, you may want to relocate the tables last in the file to a +; more suitable address. +; ------------------------------------------------------------------- + +; ------------------------------------------------------------------- +; jsr this label to decrunch, it will in turn init the tables and +; call the decruncher +; no constraints on register content, however the +; decimal flag has to be #0 (it almost always is, otherwise do a cld) +decrunch: +; ------------------------------------------------------------------- +; init zeropage, x and y regs. (12 bytes) +; + ldy #0 + ldx #3 +init_zp: + jsr get_crunched_byte + sta zp_bitbuf - 1,x + dex + bne init_zp +; ------------------------------------------------------------------- +; calculate tables (62 bytes) + get_bits macro +; x and y must be #0 when entering +; + clc +table_gen: + tax + tya + and #$0f + sta tabl_lo,y + beq shortcut ; start a new sequence +; ------------------------------------------------------------------- + txa + adc tabl_lo - 1,y + sta tabl_lo,y + lda zp_len_hi + adc tabl_hi - 1,y +shortcut: + sta tabl_hi,y +; ------------------------------------------------------------------- + lda #$01 + sta do special bitcopy logic during codegen + +BuildDrawingRoutineFrom + sta nothing to generate + bmi + ; copymask>=$80 -> assume full byte + lda #k_mask_copy_pre + jsr ProcessToken + lda #1 + sta =$80 + sta * != >STAGE0 { + !error "Templates are not all on same page" +} +; Note: the final k_rts is later copied to zero page $0F and used in MainLoop, +; so don't put any more code before BoxInitialStages. +BoxInitialStages diff --git a/src/fx/fx.dhgr.48boxes.common.unused.a b/src/fx/fx.dhgr.48boxes.common.unused.a new file mode 100644 index 0000000..cf1aef2 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.common.unused.a @@ -0,0 +1,254 @@ +!macro AUXMEM { + sta $C055 + lda auxsrc_hgrhi, x + sta src+1 +} + +!macro MAINMEM { + sta $C054 +} + +!macro INX_AND_RECALC { + inx + lda hgrlo, x + sta src + sta dst + lda hgrhi, x + sta dst+1 + eor #$60 + sta src+1 +} + +!macro BITCOPY .copy, .mask { +!if .mask != %00000000 { +!if .mask = %11111111 { +!if .copy != 0 { + lda (src), y +} else { + lda #$00 +} + sta (dst), y +} else { + lda (dst), y +!if .copy != 0 { + eor (src), y +} else { + bit src +} + and #.mask + eor (dst), y + sta (dst), y +} +} +} + +!macro MIDDLE_STAGE_DHGR .copy, .rowcount, .firstrow, .edge_left_mask_main, .edge_right_mask_main, .left_mask_main, .right_mask_main, .edge_left_mask_aux, .edge_right_mask_aux, .left_mask_aux, .right_mask_aux { + lda #(.rowcount-2) ;k_set_row_count + sta rowcount + txa ;k_set_first_row + adc #(.firstrow-1) + tax + iny ;k_iny + sty tmpy ;k_save_y + jsr + ;k_middle_jsr, k_current_page +- + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, .left_mask_main ;k_bitcopy, k_left_mask_main + iny ;k_iny + iny ;k_iny + +BITCOPY .copy, .right_mask_main ;k_bitcopy, k_right_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, .right_mask_aux ;k_bitcopy, k_right_mask_aux + ldy tmpy ;k_restore_y + +BITCOPY .copy, .left_mask_aux ;k_bitcopy, k_left_mask_aux + +MAINMEM ;k_switch_to_main + dec rowcount ;k_middle_branch + bpl - ++ + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, .edge_left_mask_main ;k_bitcopy, k_edge_left_mask_main + iny ;k_iny + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + iny ;k_iny + +BITCOPY .copy, .edge_right_mask_main ;k_bitcopy, k_edge_right_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, .edge_right_mask_aux ;k_bitcopy, k_edge_right_mask_aux + dey ;k_dey + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + dey ;k_dey + +BITCOPY .copy, .edge_left_mask_aux ;k_bitcopy, k_edge_left_mask_aux + +MAINMEM ;k_switch_to_main + rts +} + +!macro OUTER_STAGE_DHGR .copy, .rowcount, .firstrow, .edge_left_mask_main, .edge_right_mask_main, .left_mask_main, .right_mask_main, .edge_left_mask_aux, .edge_right_mask_aux, .left_mask_aux, .right_mask_aux { + lda #(.rowcount-2) ;k_set_row_count + sta rowcount + txa ;k_set_first_row + adc #(.firstrow-1) + tax + sty tmpy ;k_save_y + jsr + ;k_outer_jsr +- + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, .left_mask_main ;k_bitcopy, k_left_mask_main + iny ;k_iny + iny ;k_iny + iny ;k_iny + iny ;k_iny + +BITCOPY .copy, .right_mask_main ;k_bitcopy, k_right_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, .right_mask_aux ;k_bitcopy, k_right_mask_aux + ldy tmpy ;k_restore_y + +BITCOPY .copy, .left_mask_aux ;k_bitcopy, k_left_mask_aux + +MAINMEM ;k_switch_to_main + dec rowcount ;k_outer_branch + bpl - ++ + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, .edge_left_mask_main ;k_bitcopy, k_edge_left_mask_main + iny ;k_iny + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + iny ;k_iny + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + iny ;k_iny + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + iny ;k_iny + +BITCOPY .copy, .edge_right_mask_main ;k_bitcopy, k_edge_right_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, .edge_right_mask_aux ;k_bitcopy, k_edge_right_mask_aux + dey ;k_dey + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + dey ;k_dey + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + dey ;k_dey + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + dey ;k_dey + +BITCOPY .copy, .edge_left_mask_aux ;k_bitcopy, k_edge_left_mask_aux + +MAINMEM ;k_switch_to_main + rts +} + +!macro STAGE0 .copy { + txa ;k_set_first_row + adc #($0F-1) + tax + iny ;k_iny + iny ;k_iny + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %00011111 ;k_bitcopy, k_left_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %01111100 ;k_bitcopy, k_left_mask_aux + +MAINMEM ;k_switch_to_main + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %00011111 ;k_bitcopy, k_left_mask_main + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %01111100 ;k_bitcopy, k_left_mask_aux + +MAINMEM ;k_switch_to_main + rts +} + +!macro STAGE1 .copy { + txa ;k_set_first_row + adc #($0E-1) + tax + iny ;k_iny + iny ;k_iny + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +MAINMEM ;k_switch_to_main + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +MAINMEM ;k_switch_to_main + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +MAINMEM ;k_switch_to_main + +INX_AND_RECALC ;k_inx_and_recalc + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +AUXMEM ;k_switch_to_aux + +BITCOPY .copy, %11111111 ;k_bitcopy, k_full_mask + +MAINMEM ;k_switch_to_main + rts +} + +;clear00 +*=$7000 + +STAGE0 0 +;clear01 +*=$7100 + +STAGE1 0 +;clear02-0F +*=$7200 + +MIDDLE_STAGE_DHGR 0, $05, $0D, %01100000, %00000000, %01100000, %00000000, %00000000, %00000011, %00000000, %00000011 +*=$7300 + +MIDDLE_STAGE_DHGR 0, $07, $0C, %01111000, %00000000, %00011000, %00000000, %00000000, %00001111, %00000000, %00001100 +*=$7400 + +MIDDLE_STAGE_DHGR 0, $09, $0B, %11111111, %00000000, %00000111, %00000000, %00000000, %11111111, %00000000, %01110000 +*=$7500 + +MIDDLE_STAGE_DHGR 0, $0B, $0A, %11111111, %00000001, %00000000, %00000001, %01000000, %11111111, %01000000, %00000000 +*=$7600 + +MIDDLE_STAGE_DHGR 0, $0D, $09, %11111111, %00000111, %00000000, %00000110, %01110000, %11111111, %00110000, %00000000 +*=$7700 + +MIDDLE_STAGE_DHGR 0, $0F, $08, %11111111, %00011111, %00000000, %00011000, %01111100, %11111111, %00001100, %00000000 +*=$7800 + +MIDDLE_STAGE_DHGR 0, $11, $07, %11111111, %11111111, %00000000, %01100000, %11111111, %11111111, %00000011, %00000000 +*=$7900 + +OUTER_STAGE_DHGR 0, $13, $06, %01100000, %00000000, %01100000, %00000000, %00000000, %00000011, %00000000, %00000011 +*=$7A00 + +OUTER_STAGE_DHGR 0, $15, $05, %01111000, %00000000, %00011000, %00000000, %00000000, %00001111, %00000000, %00001100 +*=$7B00 + +OUTER_STAGE_DHGR 0, $17, $04, %11111111, %00000000, %00000111, %00000000, %00000000, %11111111, %00000000, %01110000 +*=$7C00 + +OUTER_STAGE_DHGR 0, $19, $03, %11111111, %00000001, %00000000, %00000001, %01000000, %11111111, %01000000, %00000000 +*=$7D00 + +OUTER_STAGE_DHGR 0, $1B, $02, %11111111, %00000111, %00000000, %00000110, %01110000, %11111111, %00110000, %00000000 +*=$7E00 + +OUTER_STAGE_DHGR 0, $1D, $01, %11111111, %00011111, %00000000, %00011000, %01111100, %11111111, %00001100, %00000000 +*=$7F00 + +OUTER_STAGE_DHGR 0, $1F, $00, %11111111, %11111111, %00000000, %01100000, %11111111, %11111111, %00000011, %00000000 + +;copy02-08 +; cp rowc frow edgeleft edgeright left right edgeltaux edgertaux leftaux rightaux +*=$A000 + +MIDDLE_STAGE_DHGR 1, $05, $0D, %01100000, %00000000, %01100000, %00000000, %00000000, %00000011, %00000000, %00000011 +*=$A100 + +MIDDLE_STAGE_DHGR 1, $07, $0C, %01111000, %00000000, %00011000, %00000000, %00000000, %00001111, %00000000, %00001100 +*=$A200 + +MIDDLE_STAGE_DHGR 1, $09, $0B, %11111111, %00000000, %00000111, %00000000, %00000000, %11111111, %00000000, %01110000 +*=$A300 + +MIDDLE_STAGE_DHGR 1, $0B, $0A, %11111111, %00000001, %00000000, %00000001, %01000000, %11111111, %01000000, %00000000 +*=$A400 + +MIDDLE_STAGE_DHGR 1, $0D, $09, %11111111, %00000111, %00000000, %00000110, %01110000, %11111111, %00110000, %00000000 +*=$A500 + +MIDDLE_STAGE_DHGR 1, $0F, $08, %11111111, %00011111, %00000000, %00011000, %01111100, %11111111, %00001100, %00000000 +*=$A600 + +MIDDLE_STAGE_DHGR 1, $11, $07, %11111111, %11111111, %00000000, %01100000, %11111111, %11111111, %00000011, %00000000 +;copy09-0F +*=$A700 + +OUTER_STAGE_DHGR 1, $13, $06, %01100000, %00000000, %01100000, %00000000, %00000000, %00000011, %00000000, %00000011 +*=$A800 + +OUTER_STAGE_DHGR 1, $15, $05, %01111000, %00000000, %00011000, %00000000, %00000000, %00001111, %00000000, %00001100 +*=$A900 + +OUTER_STAGE_DHGR 1, $17, $04, %11111111, %00000000, %00000111, %00000000, %00000000, %11111111, %00000000, %01110000 +*=$AA00 + +OUTER_STAGE_DHGR 1, $19, $03, %11111111, %00000001, %00000000, %00000001, %01000000, %11111111, %01000000, %00000000 +*=$AB00 + +OUTER_STAGE_DHGR 1, $1B, $02, %11111111, %00000111, %00000000, %00000110, %01110000, %11111111, %00110000, %00000000 +*=$AC00 + +OUTER_STAGE_DHGR 1, $1D, $01, %11111111, %00011111, %00000000, %00011000, %01111100, %11111111, %00001100, %00000000 +*=$AD00 + +OUTER_STAGE_DHGR 1, $1F, $00, %11111111, %11111111, %00000000, %01100000, %11111111, %11111111, %00000011, %00000000 + +;copy00 +*=$AE00 + +STAGE0 1 +;copy01 +*=$AF00 + +STAGE1 1 + diff --git a/src/fx/fx.dhgr.48boxes.down.a b/src/fx/fx.dhgr.48boxes.down.a new file mode 100644 index 0000000..df78e60 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.down.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.DOWN",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FE,$FD,$FE,$FD,$FE,$FD,$FE,$FD + !byte $FC,$FB,$FC,$FB,$FC,$FB,$FC,$FB + !byte $FA,$F9,$FA,$F9,$FA,$F9,$FA,$F9 + !byte $F8,$F7,$F8,$F7,$F8,$F7,$F8,$F7 + !byte $F6,$F5,$F6,$F5,$F6,$F5,$F6,$F5 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy0F + !byte copy0E + !byte copy0D + !byte copy0C + !byte copy0B + !byte copy0A + !byte copy09 + !byte copy08 + !byte copy07 + !byte copy06 + !byte copy05 + !byte copy04 + !byte copy03 + !byte copy02 + !byte copy01 + !byte copy00 +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.longdiagonal.a b/src/fx/fx.dhgr.48boxes.longdiagonal.a new file mode 100644 index 0000000..f0fb17a --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.longdiagonal.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.LDIAGON",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FE,$FC,$FA,$F8,$F6,$F4,$F2 + !byte $FE,$FC,$FA,$F8,$F6,$F4,$F2,$F0 + !byte $FC,$FA,$F8,$F6,$F4,$F2,$F0,$EE + !byte $FA,$F8,$F6,$F4,$F2,$F0,$EE,$EC + !byte $F8,$F6,$F4,$F2,$F0,$EE,$EC,$EA + !byte $F6,$F4,$F2,$F0,$EE,$EC,$EA,$E8 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy00 + !byte copy01 + !byte copy02 + !byte copy03 + !byte copy04 + !byte copy05 + !byte copy06 + !byte copy07 + !byte copy08 + !byte copy09 + !byte copy0A + !byte copy0B + !byte copy0C + !byte copy0D + !byte copy0E + !byte copy0F +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.sidetoside.a b/src/fx/fx.dhgr.48boxes.sidetoside.a new file mode 100644 index 0000000..3257285 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.sidetoside.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SIDES",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FC,$F8,$F4,$F0,$EC,$E8,$E4 + !byte $E4,$E8,$EC,$F0,$F4,$F8,$FC,$00 + !byte $00,$FC,$F8,$F4,$F0,$EC,$E8,$E4 + !byte $E4,$E8,$EC,$F0,$F4,$F8,$FC,$00 + !byte $00,$FC,$F8,$F4,$F0,$EC,$E8,$E4 + !byte $E4,$E8,$EC,$F0,$F4,$F8,$FC,$00 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy00 + !byte copy01 + !byte copy02 + !byte copy03 + !byte copy04 + !byte copy05 + !byte copy06 + !byte copy07 + !byte copy08 + !byte copy09 + !byte copy0A + !byte copy0B + !byte copy0C + !byte copy0D + !byte copy0E + !byte copy0F +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.snake.a b/src/fx/fx.dhgr.48boxes.snake.a new file mode 100644 index 0000000..243260e --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.snake.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SNAKE",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FF,$FE,$FD,$FC,$FB,$FA,$F9 + !byte $F1,$F2,$F3,$F4,$F5,$F6,$F7,$F8 + !byte $F0,$EF,$EE,$ED,$EC,$EB,$EA,$E9 + !byte $E1,$E2,$E3,$E4,$E5,$E6,$E7,$E8 + !byte $E0,$DF,$DE,$DD,$DC,$DB,$DA,$D9 + !Byte $D1,$D2,$D3,$D4,$D5,$D6,$D7,$D8 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy0F + !byte copy0E + !byte copy0D + !byte copy0C + !byte copy0B + !byte copy0A + !byte copy09 + !byte copy08 + !byte copy07 + !byte copy06 + !byte copy05 + !byte copy04 + !byte copy03 + !byte copy02 + !byte copy01 + !byte copy00 +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.snake.clear.a b/src/fx/fx.dhgr.48boxes.snake.clear.a new file mode 100644 index 0000000..13e6c17 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.snake.clear.a @@ -0,0 +1,53 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SNAKEC",plain +*=$6000 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FF,$FE,$FD,$FC,$FB,$FA,$F9 + !byte $F1,$F2,$F3,$F4,$F5,$F6,$F7,$F8 + !byte $F0,$EF,$EE,$ED,$EC,$EB,$EA,$E9 + !byte $E1,$E2,$E3,$E4,$E5,$E6,$E7,$E8 + !byte $E0,$DF,$DE,$DD,$DC,$DB,$DA,$D9 + !Byte $D1,$D2,$D3,$D4,$D5,$D6,$D7,$D8 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte clear0F + !byte clear0E + !byte clear0D + !byte clear0C + !byte clear0B + !byte clear0A + !byte clear09 + !byte clear08 + !byte clear07 + !byte clear06 + !byte clear05 + !byte clear04 + !byte clear03 + !byte clear02 + !byte clear01 + !byte clear00 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte copy0F + !byte copy0E + !byte copy0D + !byte copy0C + !byte copy0B + !byte copy0A + !byte copy09 + !byte copy08 + !byte copy07 + !byte copy06 + !byte copy05 + !byte copy04 + !byte copy03 + !byte copy02 + !byte copy01 + !byte copy00 +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.spiral.a b/src/fx/fx.dhgr.48boxes.spiral.a new file mode 100644 index 0000000..038e3c3 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.spiral.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SPIRAL",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$E9,$EA,$EB,$EC,$ED,$EE,$EF + !byte $FF,$E8,$D9,$DA,$DB,$DC,$DD,$F0 + !byte $FE,$E7,$D8,$D1,$D2,$D3,$DE,$F1 + !byte $FD,$E6,$D7,$D6,$D5,$D4,$DF,$F2 + !byte $FC,$E5,$E4,$E3,$E2,$E1,$E0,$F3 + !byte $FB,$FA,$F9,$F8,$F7,$F6,$F5,$F4 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy0F + !byte copy0E + !byte copy0D + !byte copy0C + !byte copy0B + !byte copy0A + !byte copy09 + !byte copy08 + !byte copy07 + !byte copy06 + !byte copy05 + !byte copy04 + !byte copy03 + !byte copy02 + !byte copy01 + !byte copy00 +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.spiral.clear.a b/src/fx/fx.dhgr.48boxes.spiral.clear.a new file mode 100644 index 0000000..bbb55f9 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.spiral.clear.a @@ -0,0 +1,56 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SPIRALC",plain +*=$6000 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FE,$FC,$FA,$F8,$F6,$F4,$F2 + !Byte $D0,$CE,$CC,$CA,$C8,$C6,$C4,$F0 + !Byte $D2,$B0,$AE,$AC,$AA,$A8,$C2,$EE + !Byte $D4,$B2,$A0,$A2,$A4,$A6,$C0,$EC + !Byte $D6,$B4,$B6,$B8,$BA,$BC,$BE,$EA + !Byte $D8,$DC,$DE,$E0,$E2,$E4,$E6,$E8 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte clear00 + !byte clear01 + !byte clear02 + !byte clear03 + !byte clear04 + !byte clear05 + !byte clear06 + !byte clear07 + !byte clear08 + !byte clear09 + !byte clear0A + !byte clear0B + !byte clear0C + !byte clear0D + !byte clear0E + !byte clear0F + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 + !byte copy00 + !byte copy01 + !byte copy02 + !byte copy03 + !byte copy04 + !byte copy05 + !byte copy06 + !byte copy07 + !byte copy08 + !byte copy09 + !byte copy0A + !byte copy0B + !byte copy0C + !byte copy0D + !byte copy0E + !byte copy0F +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.sync.a b/src/fx/fx.dhgr.48boxes.sync.a new file mode 100644 index 0000000..479f717 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.sync.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SYNC",plain +*=$6000 + +USES_CLEAR = 0 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte copy0F + !byte copy0E + !byte copy0D + !byte copy0C + !byte copy0B + !byte copy0A + !byte copy09 + !byte copy08 + !byte copy07 + !byte copy06 + !byte copy05 + !byte copy04 + !byte copy03 + !byte copy02 + !byte copy01 + !byte copy00 +EndStagesHi diff --git a/src/fx/fx.dhgr.48boxes.sync.clear.a b/src/fx/fx.dhgr.48boxes.sync.clear.a new file mode 100644 index 0000000..be09d80 --- /dev/null +++ b/src/fx/fx.dhgr.48boxes.sync.clear.a @@ -0,0 +1,50 @@ +;license:MIT +;(c) 2020 by 4am & qkumba +; +!cpu 6502 +!to "build/FX/DHGR.48.SYNCC",plain +*=$6000 + + !source "src/fx/fx.dhgr.48boxes.common.a" + + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + !byte $00,$FF,$00,$FF,$00,$FF,$00,$FF + !byte $FF,$00,$FF,$00,$FF,$00,$FF,$00 + +StagesHi ; high bytes of address of drawing routine for each stage + !byte clear0F + !byte clear0E + !byte clear0D + !byte clear0C + !byte clear0B + !byte clear0A + !byte clear09 + !byte clear08 + !byte clear07 + !byte clear06 + !byte clear05 + !byte clear04 + !byte clear03 + !byte clear02 + !byte clear01 + !byte clear00 + !byte copy00 + !byte copy01 + !byte copy02 + !byte copy03 + !byte copy04 + !byte copy05 + !byte copy06 + !byte copy07 + !byte copy08 + !byte copy09 + !byte copy0A + !byte copy0B + !byte copy0C + !byte copy0D + !byte copy0E + !byte copy0F +EndStagesHi diff --git a/src/fx/fx.dhgr.bar.dissolve.a b/src/fx/fx.dhgr.bar.dissolve.a new file mode 100644 index 0000000..5697632 --- /dev/null +++ b/src/fx/fx.dhgr.bar.dissolve.a @@ -0,0 +1,81 @@ +;license:MIT +;(c) 2020 by 4am +; +!cpu 6502 +!to "build/FX/DHGR.BAR.DISSLV",plain +*=$6000 + +hgrlo = $0200 ; [$C0 bytes, main memory only] +hgr1hi = $0300 ; [$C0 bytes, main memory only] + + !source "src/fx/macros.a" + + ldx #(end-start) ; copy code to zero page +- lda start-1, x + sta $FF, x + dex + bne - + +BUILD_HGR_LOOKUP_TABLES_X_IS_ALREADY_0 hgrlo, hgr1hi + jmp loop + +start +!pseudopc 0 { +row1=*+1 +loop ldx #$40 + lda hgrlo-$40, x + sta +;1GGFFEED (main) + +;1DCCBBAA (aux) +copymasks_aux ; used in reverse order + !byte %11111111 + !byte %11111100 + !byte %11110000 + !byte %11000000 + !byte %00000000 + !byte %00000000 + !byte %00000000 + !byte %00000000 +copymasks_main ; used in reverse order + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111110 + !byte %11111000 + !byte %11100000 + !byte %00000000 + +start +!pseudopc 0 { +loop lda #23 + sta 127 then we're done + +ROW_X_TO_BASE_ADDRESSES + +ROW_X_TO_MIRROR_ADDRESSES + + inc input + lda (input), y + +HIGH_3_LOW_5 input + sty 0 inclusive + sta 0 { + adc #(.offset*4) +} + sta src+1 + eor #$60 + sta dst+1 +} + +!macro RESET_HGR_HI_WITH_OFFSET .offset { + txa + +SET_HGR_HI_WITH_OFFSET .offset +} + +!macro COPY_WITH_MASK .copymask { + lda (src), y + eor (dst), y ; merge source and destination bits + and #.copymask ; isolate the bits to replace, zero the rest + eor (dst), y ; unmerge source and destination bits, leaves 'to keep' destination bits intact + sta (dst), y ; write the result +} + +; note: .copymask is an immediate value, not an indexed array or a memory address +!macro COPY_WITH_OFFSET_AND_MASK .offset, .copymask { + +RESET_HGR_HI_WITH_OFFSET .offset + +COPY_WITH_MASK .copymask +} + +!macro COPY_BYTE .offset { + +RESET_HGR_HI_WITH_OFFSET .offset + lda (src), y + sta (dst), y +} + + !source "src/fx/macros.a" + !source "src/fx/fx.dhgr.common.a" + +exit=*+3 + +COPY_TO_AUXMEM $60, $07 + + lda #(40+24+7) ; columns + rows + blocks per row + sta counter + + lda #40 + sta col + +ColLoop + lda $c000 + bmi exit + dec col + dec counter + beq exit + + lda #24 + sta row + ldy col +RowLoop + dec row + bmi ColLoop + ldx row + lda hgrrowlo, x + sta src + sta dst + lda hgrrowhi, x + tax ; X = high byte of src throughout RowLoop + + +BRANCH_IF_Y_IS_OFFSCREEN @block2 + +SET_HGR_HI_WITH_OFFSET 3 + +COPY_WITH_MASK %10000001 + +COPY_WITH_OFFSET_AND_MASK 4, %10000001 +@block2 + iny + +BRANCH_IF_Y_IS_OFFSCREEN @block3 + +COPY_WITH_OFFSET_AND_MASK 2, %10000110 + +COPY_WITH_OFFSET_AND_MASK 3, %10000001 + +COPY_WITH_OFFSET_AND_MASK 4, %10000001 + +COPY_WITH_OFFSET_AND_MASK 5, %10010110 +@block3 + iny + +BRANCH_IF_Y_IS_OFFSCREEN @block4 + +COPY_WITH_OFFSET_AND_MASK 2, %10000111 + +COPY_WITH_OFFSET_AND_MASK 3, %10000111 + +COPY_WITH_OFFSET_AND_MASK 4, %10000111 + +COPY_WITH_OFFSET_AND_MASK 5, %10000111 +@block4 + iny + +BRANCH_IF_Y_IS_OFFSCREEN @block5 + +COPY_WITH_OFFSET_AND_MASK 1, %10011001 + +COPY_WITH_OFFSET_AND_MASK 2, %10000001 + +COPY_WITH_OFFSET_AND_MASK 3, %10011111 + +COPY_WITH_OFFSET_AND_MASK 4, %10000111 + +COPY_WITH_OFFSET_AND_MASK 5, %10000111 + +COPY_WITH_OFFSET_AND_MASK 6, %10011001 +@block5 + iny + +BRANCH_IF_Y_IS_OFFSCREEN @block6 + +COPY_WITH_OFFSET_AND_MASK 1, %10011111 + +COPY_WITH_OFFSET_AND_MASK 2, %10011111 + +COPY_WITH_OFFSET_AND_MASK 3, %10011111 + +COPY_WITH_OFFSET_AND_MASK 4, %10011111 + +COPY_WITH_OFFSET_AND_MASK 5, %10011111 + +COPY_WITH_OFFSET_AND_MASK 6, %10011111 +@block6 + iny + +LONG_BRANCH_IF_Y_IS_OFFSCREEN @block7 + +COPY_WITH_OFFSET_AND_MASK 0, %11100110 + +COPY_WITH_OFFSET_AND_MASK 1, %10011111 + +COPY_BYTE 2 + +COPY_WITH_OFFSET_AND_MASK 3, %10011111 + +COPY_BYTE 4 + +COPY_WITH_OFFSET_AND_MASK 5, %10011111 + +COPY_WITH_OFFSET_AND_MASK 6, %10011111 + +COPY_WITH_OFFSET_AND_MASK 7, %11100110 +@block7 + iny + +BRANCH_IF_Y_IS_OFFSCREEN @switchtoaux + +COPY_BYTE 0 + +COPY_BYTE 1 + +COPY_BYTE 2 + +COPY_BYTE 3 + +COPY_BYTE 4 + +COPY_BYTE 5 + +COPY_BYTE 6 + +COPY_BYTE 7 +@switchtoaux + sta $C003 + sta $C005 + +BRANCH_IF_Y_IS_OFFSCREEN @block6_aux + +COPY_BYTE 0 + +COPY_BYTE 1 + +COPY_BYTE 2 + +COPY_BYTE 3 + +COPY_BYTE 4 + +COPY_BYTE 5 + +COPY_BYTE 6 + +COPY_BYTE 7 +@block6_aux + dey + +LONG_BRANCH_IF_Y_IS_OFFSCREEN @block5_aux + +COPY_WITH_OFFSET_AND_MASK 0, %10110011 + +COPY_WITH_OFFSET_AND_MASK 1, %11111100 + +COPY_BYTE 2 + +COPY_WITH_OFFSET_AND_MASK 3, %11111100 + +COPY_BYTE 4 + +COPY_WITH_OFFSET_AND_MASK 5, %11111100 + +COPY_WITH_OFFSET_AND_MASK 6, %11111100 + +COPY_WITH_OFFSET_AND_MASK 7, %10110011 +@block5_aux + dey + +BRANCH_IF_Y_IS_OFFSCREEN @block4_aux + +COPY_WITH_OFFSET_AND_MASK 1, %11111100 + +COPY_WITH_OFFSET_AND_MASK 2, %11111100 + +COPY_WITH_OFFSET_AND_MASK 3, %11111100 + +COPY_WITH_OFFSET_AND_MASK 4, %11111100 + +COPY_WITH_OFFSET_AND_MASK 5, %11111100 + +COPY_WITH_OFFSET_AND_MASK 6, %11111100 +@block4_aux + dey + +BRANCH_IF_Y_IS_OFFSCREEN @block3_aux + +COPY_WITH_OFFSET_AND_MASK 1, %11001100 + +COPY_WITH_OFFSET_AND_MASK 2, %11110000 + +COPY_WITH_OFFSET_AND_MASK 3, %11111100 + +COPY_WITH_OFFSET_AND_MASK 4, %11110000 + +COPY_WITH_OFFSET_AND_MASK 5, %11110000 + +COPY_WITH_OFFSET_AND_MASK 6, %11001100 +@block3_aux + dey + +BRANCH_IF_Y_IS_OFFSCREEN @block2_aux + +COPY_WITH_OFFSET_AND_MASK 2, %11110000 + +COPY_WITH_OFFSET_AND_MASK 3, %11110000 + +COPY_WITH_OFFSET_AND_MASK 4, %11110000 + +COPY_WITH_OFFSET_AND_MASK 5, %11110000 +@block2_aux + dey + +BRANCH_IF_Y_IS_OFFSCREEN @block1_aux + +COPY_WITH_OFFSET_AND_MASK 2, %10110000 + +COPY_WITH_OFFSET_AND_MASK 3, %11000000 + +COPY_WITH_OFFSET_AND_MASK 4, %11000000 + +COPY_WITH_OFFSET_AND_MASK 5, %10110000 +@block1_aux + dey + +BRANCH_IF_Y_IS_OFFSCREEN @switchtomain + +COPY_WITH_OFFSET_AND_MASK 3, %11000000 + +COPY_WITH_OFFSET_AND_MASK 4, %11000000 +@switchtomain + sta $C002 + sta $C004 + iny + jmp RowLoop + +; next table can not cross a page boundary +!if <* > $E8 { + !align 255, 0 +} +hgrrowlo + !byte $00,$80,$00,$80,$00,$80,$00,$80 + !byte $28,$A8,$28,$A8,$28,$A8,$28,$A8 + !byte $50,$D0,$50,$D0,$50,$D0,$50,$D0 + +; next table can not cross a page boundary +!if <* > $E8 { + !align 255, 0 +} +hgrrowhi + !byte $40,$40,$41,$41,$42,$42,$43,$43 + !byte $40,$40,$41,$41,$42,$42,$43,$43 + !byte $40,$40,$41,$41,$42,$42,$43,$43 + +!if * > $6700 { + !error "Code too large, adjust COPY_TO_AUXMEM macro" +} diff --git a/src/fx/fx.dhgr.soft.iris.a b/src/fx/fx.dhgr.soft.iris.a new file mode 100644 index 0000000..de20e4f --- /dev/null +++ b/src/fx/fx.dhgr.soft.iris.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.SOFT.IRIS",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/SOFT.IRIS.DATA" diff --git a/src/fx/fx.dhgr.soft.iris.in.a b/src/fx/fx.dhgr.soft.iris.in.a new file mode 100644 index 0000000..49bc1f7 --- /dev/null +++ b/src/fx/fx.dhgr.soft.iris.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.SOFTIRISIN",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/SOFT.IRIS.DATA" diff --git a/src/fx/fx.dhgr.star.a b/src/fx/fx.dhgr.star.a new file mode 100644 index 0000000..a791058 --- /dev/null +++ b/src/fx/fx.dhgr.star.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.STAR",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.dhgr.star.in.a b/src/fx/fx.dhgr.star.in.a new file mode 100644 index 0000000..510abd1 --- /dev/null +++ b/src/fx/fx.dhgr.star.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.STAR.IN",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.dhgr.star.ripple.a b/src/fx/fx.dhgr.star.ripple.a new file mode 100644 index 0000000..c45cd0e --- /dev/null +++ b/src/fx/fx.dhgr.star.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.STAR.RIP",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.dhgr.swirl.a b/src/fx/fx.dhgr.swirl.a new file mode 100644 index 0000000..d2f68bc --- /dev/null +++ b/src/fx/fx.dhgr.swirl.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.SWIRL",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.1bit.a" + + +FX_INITONCE_1BIT CoordinatesFile, Start + +FX_RIPPLE_1BIT aslmod4 +Start + +FX_PRECOMPUTED_1BIT_DHGR Coordinates1Bit + +CoordinatesFile + !byte 15 + !text "FX/CORNER4.DATA" diff --git a/src/fx/fx.dhgr.wavy.iris.a b/src/fx/fx.dhgr.wavy.iris.a new file mode 100644 index 0000000..9356a39 --- /dev/null +++ b/src/fx/fx.dhgr.wavy.iris.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.WAVY.IRIS",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.dhgr.wavy.iris.bloom.a b/src/fx/fx.dhgr.wavy.iris.bloom.a new file mode 100644 index 0000000..1c312e1 --- /dev/null +++ b/src/fx/fx.dhgr.wavy.iris.bloom.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.BLOOM",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.dhgr.wavy.iris.bloom.in.a b/src/fx/fx.dhgr.wavy.iris.bloom.in.a new file mode 100644 index 0000000..6da6cf2 --- /dev/null +++ b/src/fx/fx.dhgr.wavy.iris.bloom.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.BLOOM.IN",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.dhgr.wavy.iris.in.a b/src/fx/fx.dhgr.wavy.iris.in.a new file mode 100644 index 0000000..c20e1f9 --- /dev/null +++ b/src/fx/fx.dhgr.wavy.iris.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.WAVY.IN",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.dhgr.wavy.ripple.a b/src/fx/fx.dhgr.wavy.ripple.a new file mode 100644 index 0000000..a0ba687 --- /dev/null +++ b/src/fx/fx.dhgr.wavy.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.WAVY.RIP",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.dhgr.wavy.ripple.bloom.a b/src/fx/fx.dhgr.wavy.ripple.bloom.a new file mode 100644 index 0000000..729e08a --- /dev/null +++ b/src/fx/fx.dhgr.wavy.ripple.bloom.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/DHGR.BLOOM.RIP",plain +*=$6000 + + !source "src/fx/fx.dhgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT_DHGR Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.gr.fizzle.a b/src/fx/fx.gr.fizzle.a new file mode 100644 index 0000000..53e30a0 --- /dev/null +++ b/src/fx/fx.gr.fizzle.a @@ -0,0 +1,86 @@ +;license:MIT +;(c) 2019 by qkumba + +!cpu 6502 +!to "build/FX/GR.FIZZLE",plain +*=$6400 + + ;init RNG + + ldx #1 + stx @rnd1+1 + dex + stx @rnd2+1 + + ;iterate + +@loop + ldy @rnd1+1 + ldx @rnd2+1 + lsr @rnd2+1 + ror @rnd1+1 + bcc + + + ;feedback polynomial forms #$402 for period of 2047 + + lda @rnd1+1 + eor #2 + sta @rnd1+1 + lda @rnd2+1 + eor #4 + sta @rnd2+1 + + ;little hack to avoid missing offset zero + ;screen hole at $xxFF is missed instead + ++ tya + eor #$ff + sta $26 + sta $3c + and #$78 + cmp #$78 + beq @rnd2 + txa + and #3 + + ;target page 1 + + ora #4 + sta $3d + eor #$64 + sta $27 + + ;set mask according to offset + + lda #$0f + cpx #4 + bcc @src + lda #$f0 + + ;copy half-pixel from other page to this page + +@src sta @mask+1 + ldy #0 + and ($26),y ; isolate source half + eor ($3c),y ; merge with whole target +@mask and #$d1 ; SMC isolate merged half + eor ($3c),y ; unmerge half of target + sta ($3c),y ; store both halves + + ;wait while checking for keypress + + ldx #$10 +@wait lda $c000 + bmi @exit + dex + bne @wait + + ;and exit condition + +@rnd2 lda #0 + bne @loop +@rnd1 lda #0 + cmp #1 + bne @loop + +@exit rts diff --git a/src/fx/fx.hgr.1bit.fizzle.a b/src/fx/fx.hgr.1bit.fizzle.a new file mode 100755 index 0000000..5254ae2 --- /dev/null +++ b/src/fx/fx.hgr.1bit.fizzle.a @@ -0,0 +1,70 @@ +;license:MIT +;(c) 2017-2020 by qkumba/4am/John Brooks + +!cpu 6502 +!to "build/FX/BIT.FIZZLE",plain +*=$6000 + +addrs = $6100 ; [256 bytes, page-aligned] +copymasks = $6200 ; [256 bytes, page-aligned] + + ldx #(end-start) ; copy LFSR code to zero page +- lda start-1, x + sta $FF, x + dex + bne - +-- ldy #$20 ; create copymask table + ora #%10000000 +- sta copymasks, x + inx + dey + bne - + asl + bne -- + pha + pha + clc +-- ldy #$20 ; create address lookup table + tya +- sta addrs, x + adc #1 + inx + dey + bne - + txa + bne -- + rts ; exit via LFSR code on zero page + +start +!pseudopc 0 { +; in: X,Y=0 + !byte %00000001 +loop txa +loop1 eor #$B4 ; LFSR form 0xB400 with period 65535 + tax ; X is LFSR high byte, Y is LFSR low byte +loop2 lda addrs, x ; which means X is the index into the base address lookup table + sta shapemask + sta hgrhi,x + inx + cpx #$C0 + bne - + ldx #0 ; create shapemask table +-- lda hgrlo, x + sta $FE + lda hgrhi, x + sta $FF + txa + lsr + lsr + lsr + lsr + lsr + lsr + lda #%00000000 + bcc + + eor #%11111111 ++ ldy #$27 +- eor #%11111111 + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + sta ($FE), y + dey + bpl - + inx + cpx #$C0 + bne -- + ldx #(end-start) ; copy LFSR code to zero page +- lda start-1, x + sta $FF, x + dex + bne - +-- ldy #$20 ; create copymask lookup table + ora #%10000000 +- sta copymasks, x + inx + dey + bne - + asl + asl + bne -- + tax + clc +-- ldy #$20 ; create address lookup table + tya +- sta addrs, x + adc #1 + inx + dey + bne - + txa + bne -- + clc ; create shapemaskaddrs lookup table +-- ldy #$20 + lda #>shapemask +- sta shapemaskaddrs, x + adc #1 + inx + dey + bne - + txa + bne -- + jsr $1 + lda $4000 ; last lousy byte (because LFSR never hits 0) + sta $2000 + lda #$2C ; BIT + sta Coordinates + stx $FF +--- ldx #0 +-- txa + jsr $FBC1 ; BASCALC +- lda ($28), y + cmp $54 + bne + + tya + pha + txa + jsr @stainc + pla + jsr @stainc + tay ++ iny + cpy #$28 + bne - + lda #$FF + jsr @stainc2 + inx + cpx #$18 + bcc -- + inc $54 + lda $54 + cmp #4 + bne --- + +READ_RAM1_WRITE_RAM1 + + lda #$80 + sta Coordinates+$840 + + lda #$01 + sta $FD +@outerloop + dec $FD + lda #Coordinates + sta $FF + ldy #$00 +@loop + lda ($fe),y + bpl @copy + lda #$10 + jsr WaitForKeyWithTimeout + bmi @exit + bpl @next ; always branches +@copy + tax + iny + lda ($fe),y + tay + txa + bit $FD + bpl + + jsr HGRBlockCopy + beq @next ; always branches ++ jsr HGRBlockToWhite +@next + inc $FE + bne + + inc $FF ++ inc $FE + bne + + inc $FF ++ ldy #$00 + lda ($FE),y + cmp #$80 + bne @loop + bit $FD + bpl @outerloop +@exit rts + +@stainc2 jsr @stainc +@stainc ldy #0 + sta ($FE), y + inc $FE + bne + + inc $FF ++ rts + +@table1 + !byte $05, $AF, $05, $AF, $06, $90, $FA, $50, $FA, $50, $50, $5A, $F0, $5A, $F0, $0F + !byte $A5, $0F, $A5, $05, $A5, $05, $AF, $05, $AF, $FA, $50, $FA, $50, $5A, $FA, $50 + !byte $5A, $F0, $5A, $A5, $0F, $A5, $05, $AF, $0F, $A5, $05, $AF, $05, $50, $FA, $50 + !byte $5A, $F0, $50, $FE, $54, $5E, $F4, $0B, $A1, $01, $AB, $01, $A1, $0B, $A1, $01 + !byte $AB, $FE, $54, $5E, $F4, $5E, $FE, $54, $FE, $54, $5E, $A1, $01, $AB, $01, $AB + !byte $0B, $A1, $0B, $A1, $01, $54, $5E, $F4, $5E, $F4, $54, $FE, $54, $FE, $54, $01 + !byte $AB, $01, $AB, $01, $A1, $0B, $A1, $0B, $A1, $5E, $F0, $5A, $F0, $5A, $3A, $50 + !byte $FA, $50, $FA, $AF, $01, $AB, $01, $A8, $3E, $54, $FE, $54, $FE, $AB, $01, $AB + !byte $01, $A8, $A1, $0B, $A1, $0B, $A1, $5E, $F4, $5E, $F4, $5E, $54, $FE, $54, $FE + !byte $54, $01, $AB, $01, $AB, $01, $0B, $A1, $0B, $A1, $01, $54, $5E, $F4, $5E, $F4 + !byte $FE, $50, $FA, $50, $5A, $A5, $05, $AF, $05, $AF, $A5, $0F, $A5, $05, $AF, $FA + !byte $50, $5A, $F0, $5A, $50, $FA, $50, $5A, $F0, $0F, $A5, $05, $AF, $05, $0F, $A5 + !byte $05, $AF, $05, $50, $FA, $50, $5A, $F0, $FA, $50, $5A, $F0, $5A, $A5, $0F, $A5 + !byte $05, $AF, $A5, $05, $AF, $05, $AF, $FA, $50, $FA, $50, $5A, $50, $5A, $F0, $5A + !byte $F0, $0F, $A5, $0F, $A5, $05, $05, $AF, $05, $AF, $06, $90, $FA, $50, $FA, $50 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_BLOCK_COPY_ROUTINES +Coordinates diff --git a/src/fx/fx.hgr.diagonal.a b/src/fx/fx.hgr.diagonal.a new file mode 100644 index 0000000..47de5ba --- /dev/null +++ b/src/fx/fx.hgr.diagonal.a @@ -0,0 +1,64 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/DIAGONAL",plain +*=$6000 + +row = $fd +col = $fe +counter = $ff + + !source "src/fx/macros.a" + !source "src/constants.a" + + +SWITCH_TO_MASKS copymasks + + lda #64 ; 40 + 24 + sta counter + + lda #39 + sta col +@colloop + lda #23 + sta row + ldy col + jsr WaitForVBL +@rowloop + tya + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopyWithMask ++ iny + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopy ++ + dec row + bpl @rowloop + lda #64 + jsr WaitForKeyWithTimeout + bmi @exit + dec col + dec counter + bne @colloop +@exit jmp UnwaitForVBL + +copymasks + !byte %11111111 + !byte %11111110 + !byte %11111100 + !byte %11111000 + !byte %11110000 + !byte %11100000 + !byte %11000000 + !byte %10000000 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.diagonal2.a b/src/fx/fx.hgr.diagonal2.a new file mode 100644 index 0000000..c6662c3 --- /dev/null +++ b/src/fx/fx.hgr.diagonal2.a @@ -0,0 +1,65 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/DIAGONAL2",plain +*=$6000 + +row = $fd +col = $fe +counter = $ff + + !source "src/fx/macros.a" + !source "src/constants.a" + + +SWITCH_TO_MASKS copymasks + + lda #64 ; 40 + 24 + sta counter + + lda #$FF ; -1 + sta col +@colloop + lda #23 + sta row + ldy col + jsr WaitForVBL +@rowloop + tya + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopy ++ iny + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopyWithMask ++ dey + dey + dec row + bpl @rowloop + lda #64 + jsr WaitForKeyWithTimeout + bmi @exit + inc col + dec counter + bne @colloop +@exit jmp UnwaitForVBL + +copymasks + !byte %11111111 + !byte %10111111 + !byte %10011111 + !byte %10001111 + !byte %10000111 + !byte %10000011 + !byte %10000001 + !byte %10000000 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.diagonal3.a b/src/fx/fx.hgr.diagonal3.a new file mode 100644 index 0000000..87b005d --- /dev/null +++ b/src/fx/fx.hgr.diagonal3.a @@ -0,0 +1,66 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/DIAGONAL3",plain +*=$6000 + +row = $fd +col = $fe +counter = $ff + + !source "src/fx/macros.a" + + +SWITCH_TO_MASKS copymasks + + lda #64 ; 40 + 24 + sta counter + + lda #$FF ; -1 + sta col +@colloop + lda #0 + sta row + ldy col +@rowloop + tya + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopy ++ iny + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopyWithMask ++ dey + dey + inc row + lda row + cmp #24 + bcc @rowloop + lda #64 + jsr WaitForKeyWithTimeout + bmi @exit + inc col + lda col + cmp #64 + bcc @colloop +@exit rts + +copymasks + !byte %10000000 + !byte %10000001 + !byte %10000011 + !byte %10000111 + !byte %10001111 + !byte %10011111 + !byte %10111111 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.diagonal4.a b/src/fx/fx.hgr.diagonal4.a new file mode 100644 index 0000000..6626a4a --- /dev/null +++ b/src/fx/fx.hgr.diagonal4.a @@ -0,0 +1,66 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/DIAGONAL4",plain +*=$6000 + +row = $fd +col = $fe +counter = $ff + + !source "src/fx/macros.a" + !source "src/constants.a" + + +SWITCH_TO_MASKS copymasks + + lda #64 ; 40 + 24 + sta counter + + lda #39 + sta col +@colloop + lda #0 + sta row + ldy col + jsr WaitForVBL +@rowloop + tya + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopyWithMask ++ iny + bmi + + cpy #40 + bcs + + lda row + jsr HGRBlockCopy ++ + inc row + lda row + cmp #24 + bcc @rowloop + lda #64 + jsr WaitForKeyWithTimeout + bmi @exit + dec col + dec counter + bne @colloop +@exit jmp UnwaitForVBL + +copymasks + !byte %10000000 + !byte %11000000 + !byte %11100000 + !byte %11110000 + !byte %11111000 + !byte %11111100 + !byte %11111110 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.diamond.a b/src/fx/fx.hgr.diamond.a new file mode 100644 index 0000000..aaadc28 --- /dev/null +++ b/src/fx/fx.hgr.diamond.a @@ -0,0 +1,150 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/DIAMOND",plain +*=$6000 + +y = $fc +row = $fd +col = $fe +counter = $ff + + !source "src/fx/macros.a" + !source "src/constants.a" + + lda #32 + sta counter + + lda #39 + sta col +@colloop + lda #23 + sta row + ldy col + sty y + jsr WaitForVBL +@rowloop + ; check if this column is visible + ldy y + bpl + +- jmp @skip1 ++ cpy #40 + bcs - + ; do corner 1 + +SWITCH_TO_MASKS copymasks1 + lda row + jsr HGRBlockCopyWithMask + ; do corner 2 (same row, opposing col) + +SWITCH_TO_MASKS copymasks2 + lda #39 + sec + sbc y + tay + lda row + jsr HGRBlockCopyWithMask + ; do corner 3 (opposing row, opposing col) + +SWITCH_TO_MASKS copymasks3 + lda #39 + sec + sbc y + tay + lda #23 + sec + sbc row + jsr HGRBlockCopyWithMask + ; do corner 4 (opposing row, same col) + +SWITCH_TO_MASKS copymasks4 + ldy y + lda #23 + sec + sbc row + jsr HGRBlockCopyWithMask + ; reset y for looping + ldy y +@skip1 + iny + sty y + ; now check if *this* column is visible + bpl + +- jmp @skip2 ++ cpy #40 + bcs - + ; do corner 1 + lda row + jsr HGRBlockCopy + ; do corner 2 + lda #39 + sec + sbc y + tay + lda #23 + sec + sbc row + jsr HGRBlockCopy + ; do corner 3 + lda #39 + sec + sbc y + tay + lda row + jsr HGRBlockCopy + ; do corner 4 + ldy y + lda #23 + sec + sbc row + jsr HGRBlockCopy +@skip2 + dec row + bmi + + jmp @rowloop ++ lda $c000 + bmi @exit + dec col + dec counter + beq @exit + jmp @colloop +@exit jmp UnwaitForVBL + +copymasks1 + !byte %11111111 + !byte %11111110 + !byte %11111100 + !byte %11111000 + !byte %11110000 + !byte %11100000 + !byte %11000000 + !byte %10000000 +copymasks2 + !byte %11111111 + !byte %10111111 + !byte %10011111 + !byte %10001111 + !byte %10000111 + !byte %10000011 + !byte %10000001 + !byte %10000000 +copymasks3 + !byte %10000000 + !byte %10000001 + !byte %10000011 + !byte %10000111 + !byte %10001111 + !byte %10011111 + !byte %10111111 + !byte %11111111 +copymasks4 + !byte %10000000 + !byte %11000000 + !byte %11100000 + !byte %11110000 + !byte %11111000 + !byte %11111100 + !byte %11111110 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.fizzle.a b/src/fx/fx.hgr.fizzle.a new file mode 100644 index 0000000..2758e6d --- /dev/null +++ b/src/fx/fx.hgr.fizzle.a @@ -0,0 +1,71 @@ +;license:MIT +;(c) 2017-2018 by qkumba + +!cpu 6502 +!to "build/FX/FIZZLE",plain +*=$6000 + + ;init RNG + + ldx #1 + stx @rnd1+1 + dex + stx @rnd2+1 + + ;iterate + +@loop + ldy @rnd1+1 + ldx @rnd2+1 + lsr @rnd2+1 + ror @rnd1+1 + bcc + + + ;feedback polynomial forms #$100D for period of 8191 + + lda @rnd1+1 + eor #$0d + sta @rnd1+1 + lda @rnd2+1 + eor #$10 + sta @rnd2+1 + + ;little hack to avoid missing offset zero + ;screen hole at $xxFF is missed instead + ++ tya + eor #$ff + sta $26 + sta $3c + txa + + ;target page 1 + + ora #$20 + sta $27 + eor #$60 + sta $3d + + ;copy pixel from other page to this page + + ldy #0 + lda ($3c),y + sta ($26),y + + ;wait while checking for keypress + + ldx #8 +@wait lda $c000 + bmi @exit + dex + bne @wait + + ;and exit condition + +@rnd2 lda #0 + bne @loop +@rnd1 lda #0 + cmp #1 + bne @loop + +@exit rts diff --git a/src/fx/fx.hgr.flick.a b/src/fx/fx.hgr.flick.a new file mode 100644 index 0000000..8ca3bc2 --- /dev/null +++ b/src/fx/fx.hgr.flick.a @@ -0,0 +1,83 @@ +;license:MIT +;(c) 2020 by 4am +; +!cpu 6502 +!to "build/FX/FLICK",plain +*=$6000 + +rowcount = $FF ; [byte] +hgrlo = $200 ; [$C0 bytes] +startrows_by_column = $2C0 ; [$28 bytes] +hgrhi = $300 ; [$C0 bytes] +rowcounts_by_column = $3C0 ; [$28 bytes] + + !source "src/fx/macros.a" + + +BUILD_HGR_LOOKUP_TABLES hgrlo, hgrhi + + ldy #$27 +- lda #$00 + sta startrows_by_column, y + lda initial_rowcounts, y + sta rowcounts_by_column, y + dey + bpl - +frameloop + ldy #$27 +columnloop + lda rowcounts_by_column, y + beq nextcolumn + bmi nextcolumn + sta rowcount + ldx startrows_by_column, y + cpx #$C0 + bcs nextcolumn +rowloop lda hgrlo, x + sta $3c + sta $26 + lda hgrhi, x + sta $27 + eor #$60 + sta $3d + lda ($3c), y + sta ($26), y + inx + dec rowcount + bne rowloop +nextcolumn + dey + bpl columnloop + + ldy #$27 +- lda rowcounts_by_column, y + bmi + + beq + + tax + clc + adc startrows_by_column, y + sta startrows_by_column, y + lda next_rowcount, x + sta rowcounts_by_column, y + bne ++ ; always branches ++ clc + adc #1 + sta rowcounts_by_column, y +++ dey + bpl - + lda #$48 + jsr WaitForKeyWithTimeout + bmi exit + lda rowcounts_by_column+$27 + cmp #$80 + bne frameloop +exit rts + + !source "src/wait.a" + +initial_rowcounts + !byte $01,$01,$00,$00,$FF,$FF,$FE,$FE,$FD,$FD + !byte $FC,$FC,$FB,$FB,$FA,$FA,$F9,$F9,$F8,$F8 + !byte $F7,$F7,$F6,$F6,$F5,$F5,$F4,$F4,$F3,$F3 + !byte $F2,$F2,$F1,$F1,$F0,$F0,$EF,$EF,$EE,$EE +next_rowcount + !byte $01,$03,$80,$05,$02,$07,$04,$09,$06,$0B,$08,$0D,$0A,$0F,$0C,$11,$0E,$15,$10,$FD,$FD,$12 diff --git a/src/fx/fx.hgr.flower.a b/src/fx/fx.hgr.flower.a new file mode 100644 index 0000000..b654a12 --- /dev/null +++ b/src/fx/fx.hgr.flower.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 14 + !text "FX/FLOWER.DATA" diff --git a/src/fx/fx.hgr.flower.data.a b/src/fx/fx.hgr.flower.data.a new file mode 100644 index 0000000..cc5d01b --- /dev/null +++ b/src/fx/fx.hgr.flower.data.a @@ -0,0 +1,10243 @@ +!cpu 6502 +!to "build/FX/FLOWER.DATA",plain +*=$6B00 + !byte $1F,%00010100 + !byte $1F,%00110100 + !byte $1F,%11110011 + !byte $1E,%00010100 + !byte $20,%00010100 + !byte $1F,%01010100 + !byte $1E,%00110100 + !byte $20,%00110100 + !byte $1E,%11010011 + !byte $20,%11010011 + !byte $1E,%11110011 + !byte $20,%11110011 + !byte $1F,%01110100 + !byte $1F,%10010101; + !byte $1E,%10110011 + !byte $20,%10110011 + !byte $1F,%11010011 + !byte $1D,%00110100 + !byte $21,%00110100 + !byte $1F,%10110101 + !byte $1D,%00010100 + !byte $21,%00010100 + !byte $21,%01010100 + !byte $1D,%01010100 + !byte $1E,%01010100 + !byte $20,%01010100 + !byte $1E,%01110010 + !byte $1E,%10010011; + !byte $20,%01110010 + !byte $20,%10010011; + !byte $1F,%11010101 + !byte $1D,%10110011 + !byte $21,%10110011 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $21,%01110010 + !byte $21,%10010011; + !byte $1C,%00110100 + !byte $22,%00110100 + !byte $1C,%01010100 + !byte $22,%01010100 + !byte $1F,%11110101 + !byte $1D,%01010010 + !byte $21,%01010010 + !byte $1F,%10110011 + !byte $1D,%11010011 + !byte $21,%11010011 + !byte $20,%01010010 + !byte $1E,%01010010 + !byte $1E,%01110100 + !byte $1E,%10010101; + !byte $20,%01110100 + !byte $20,%10010101; + !byte $1E,%10110101 + !byte $21,%01110100 + !byte $21,%10010101; + !byte $1C,%01110100 + !byte $1C,%10010101; + !byte $22,%01110100 + !byte $22,%10010101; + !byte $1D,%01110100 + !byte $1D,%10010101; + !byte $20,%10110101 + !byte $22,%00010100 + !byte $1C,%00010100 + !byte $1F,%00010110 + !byte $20,%11010101 + !byte $1E,%11010101 + !byte $1D,%00110010 + !byte $21,%00110010 + !byte $1B,%01010100 + !byte $23,%01010100 + !byte $21,%11110011 + !byte $1D,%11110011 + !byte $20,%11110101 + !byte $23,%00110100 + !byte $1E,%11110101 + !byte $1B,%00110100 + !byte $1B,%01110100 + !byte $1B,%10010101; + !byte $23,%01110100 + !byte $23,%10010101; + !byte $1F,%00110110 + !byte $1C,%01010010 + !byte $22,%01010010 + !byte $1C,%00110010 + !byte $22,%00110010 + !byte $20,%00110010 + !byte $1E,%00110010 + !byte $1D,%00010010 + !byte $21,%00010010 + !byte $20,%00010110 + !byte $1E,%00010110 + !byte $1C,%01110010 + !byte $1C,%10010011; + !byte $22,%01110010 + !byte $22,%10010011; + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $22,%00010010 + !byte $1C,%00010010 + !byte $1F,%01010110 + !byte $1C,%10110101 + !byte $22,%10110101 + !byte $23,%10110101 + !byte $1B,%10110101 + !byte $1E,%00110110 + !byte $20,%00110110 + !byte $1B,%00010100 + !byte $23,%00010100 + !byte $1A,%01010100 + !byte $24,%01010100 + !byte $1A,%01110100 + !byte $1A,%10010101; + !byte $24,%01110100 + !byte $24,%10010101; + !byte $1C,%11110001 + !byte $22,%11110001 + !byte $1D,%11110001 + !byte $21,%11110001 + !byte $1C,%10110011 + !byte $22,%10110011 + !byte $1F,%01110110 + !byte $1F,%10010111; + !byte $1A,%00110100 + !byte $24,%10110101 + !byte $1A,%10110101 + !byte $24,%00110100 + !byte $1E,%01010110 + !byte $1C,%11110011 + !byte $22,%11110011 + !byte $20,%01010110 + !byte $1E,%00010010 + !byte $1D,%10110101 + !byte $21,%10110101 + !byte $20,%00010010 + !byte $1C,%11010001 + !byte $22,%11010001 + !byte $1B,%00010010 + !byte $23,%00010010 + !byte $1F,%10110111 + !byte $20,%01110110 + !byte $20,%10010111; + !byte $1E,%01110110 + !byte $1E,%10010111; + !byte $1B,%11110001 + !byte $1F,%01010010 + !byte $23,%11110001 + !byte $1B,%00110010 + !byte $23,%00110010 + !byte $19,%01110100 + !byte $19,%10010101; + !byte $25,%01110100 + !byte $25,%10010101; + !byte $23,%11010101 + !byte $1B,%11010101 + !byte $19,%01010100 + !byte $25,%01010100 + !byte $23,%11010001 + !byte $25,%10110101 + !byte $24,%11010101 + !byte $19,%10110101 + !byte $1A,%11010101 + !byte $1B,%11010001 + !byte $1D,%11010001 + !byte $21,%11010001 + !byte $24,%00010100 + !byte $1A,%00010100 + !byte $20,%10110111 + !byte $1E,%10110111 + !byte $23,%01010010 + !byte $1C,%10110001 + !byte $22,%10110001 + !byte $1B,%01010010 + !byte $1F,%11010111 + !byte $23,%10110001 + !byte $1B,%10110001 + !byte $22,%11010101 + !byte $1C,%11010101 + !byte $22,%11010011 + !byte $19,%11010101 + !byte $25,%11010101 + !byte $1C,%11010011 + !byte $25,%00110100 + !byte $19,%00110100 + !byte $23,%11110011 + !byte $1B,%11110011 + !byte $1E,%11110001 + !byte $1E,%11010111 + !byte $20,%11110001 + !byte $20,%11010111 + !byte $1F,%11110111 + !byte $18,%10110101 + !byte $18,%01110100 + !byte $18,%10010101; + !byte $26,%01110100 + !byte $26,%10010101; + !byte $26,%10110101 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $23,%01110000 + !byte $23,%10010001; + !byte $21,%10110001 + !byte $1D,%10110001 + !byte $1C,%01110000 + !byte $1C,%10010001; + !byte $22,%01110000 + !byte $22,%10010001; + !byte $1F,%00110010 + !byte $18,%11010101 + !byte $26,%01010100 + !byte $26,%11010101 + !byte $18,%01010100 + !byte $1A,%11110101 + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $24,%11110101 + !byte $1A,%11010001 + !byte $24,%11010001 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $1D,%11010101 + !byte $21,%11010101 + !byte $1E,%11110111 + !byte $1A,%11110001 + !byte $24,%11110001 + !byte $20,%11110111 + !byte $19,%11110101 + !byte $24,%10110001 + !byte $25,%11110101 + !byte $1A,%10110001 + !byte $1F,%00011000 + !byte $1A,%01110000 + !byte $1A,%10010001; + !byte $1B,%11110101 + !byte $24,%01110000 + !byte $24,%10010001; + !byte $23,%11110101 + !byte $24,%00010010 + !byte $1A,%00010010 + !byte $19,%00010100 + !byte $1B,%01010000 + !byte $23,%01010000 + !byte $25,%00010100 + !byte $1D,%11110101 + !byte $21,%11110101 + !byte $1D,%00010110 + !byte $21,%00010110 + !byte $1D,%00110110 + !byte $21,%00110110 + !byte $26,%11110101 + !byte $18,%11110101 + !byte $1E,%00011000 + !byte $1D,%01010110 + !byte $21,%01010110 + !byte $20,%00011000 + !byte $18,%00110100 + !byte $26,%00110100 + !byte $22,%01010000 + !byte $24,%01010000 + !byte $1A,%01010000 + !byte $1C,%01010000 + !byte $1A,%11110011 + !byte $17,%10110101 + !byte $27,%10110101 + !byte $24,%11110011 + !byte $1F,%00111000 + !byte $21,%01110110 + !byte $21,%10010111; + !byte $1D,%01110110 + !byte $1D,%10010111; + !byte $17,%01110100 + !byte $17,%10010101; + !byte $27,%11010101 + !byte $1E,%11010001 + !byte $27,%01110100 + !byte $27,%10010101; + !byte $17,%11010101 + !byte $20,%11010001 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $21,%01110000 + !byte $21,%10010001; + !byte $24,%00110010 + !byte $1A,%00110010 + !byte $1D,%10110111 + !byte $21,%10110111 + !byte $1B,%00110000 + !byte $23,%00110000 + !byte $20,%00111000 + !byte $1E,%00111000 + !byte $24,%00110000 + !byte $1A,%00110000 + !byte $27,%11110101 + !byte $17,%11110101 + !byte $1F,%00010010 + !byte $27,%01010100 + !byte $17,%01010100 + !byte $19,%00010110 + !byte $25,%00010110 + !byte $1F,%01011000 + !byte $1B,%10110011 + !byte $1D,%11010111 + !byte $23,%10110011 + !byte $21,%11010111 + !byte $18,%00010110 + !byte $26,%00010110 + !byte $1C,%11110101 + !byte $22,%11110101 + !byte $1B,%11010011 + !byte $23,%11010011 + !byte $1A,%00010110 + !byte $24,%00010110 + !byte $19,%01110000 + !byte $19,%10010001; + !byte $25,%01110000 + !byte $25,%10010001; + !byte $19,%10110001 + !byte $25,%10110001 + !byte $22,%00110000 + !byte $1C,%00110000 + !byte $25,%01010000 + !byte $1E,%01011000 + !byte $19,%01010000 + !byte $20,%01011000 + !byte $21,%11110111 + !byte $1D,%11110111 + !byte $1A,%00010000 + !byte $24,%00010000 + !byte $16,%11010101 + !byte $16,%10110101 + !byte $19,%11010001 + !byte $23,%00010000 + !byte $28,%10110101 + !byte $1B,%00010000 + !byte $25,%11010001 + !byte $28,%11010101 + !byte $26,%00010100 + !byte $27,%00010110 + !byte $17,%00010110 + !byte $18,%00010100 + !byte $1F,%01111000 + !byte $1F,%10011001; + !byte $25,%00110000 + !byte $19,%00110000 + !byte $27,%00110100 + !byte $17,%00110100 + !byte $16,%01110100 + !byte $16,%10010101; + !byte $28,%11110101 + !byte $16,%11110101 + !byte $28,%01110100 + !byte $28,%10010101; + !byte $24,%01010010 + !byte $1A,%01010010 + !byte $21,%01010000 + !byte $25,%11110011 + !byte $1D,%00011000 + !byte $21,%00011000 + !byte $19,%11110011 + !byte $1D,%01010000 + !byte $1E,%01111000 + !byte $1E,%10011001; + !byte $25,%00010000 + !byte $20,%01111000 + !byte $20,%10011001; + !byte $19,%00010000 + !byte $1E,%10110001 + !byte $25,%11110001 + !byte $19,%11110001 + !byte $20,%10110001 + !byte $1A,%11101111 + !byte $1B,%00010110 + !byte $24,%11101111 + !byte $23,%00010110 + !byte $1F,%10111001 + !byte $28,%00010110 + !byte $16,%00010110 + !byte $1F,%11110001 + !byte $16,%01010100 + !byte $1D,%00111000 + !byte $28,%01010100 + !byte $21,%00111000 + !byte $18,%00110110 + !byte $26,%00110110 + !byte $1C,%00010000 + !byte $23,%11101111 + !byte $22,%00010000 + !byte $25,%11101111 + !byte $1B,%11101111 + !byte $19,%11101111 + !byte $17,%00110110 + !byte $27,%00110110 + !byte $19,%00110110 + !byte $1E,%10111001 + !byte $20,%10111001 + !byte $25,%00110110 + !byte $15,%11010101 + !byte $29,%11010101 + !byte $15,%10110101 + !byte $29,%11110101 + !byte $15,%11110101 + !byte $29,%10110101 + !byte $1A,%11010011 + !byte $1D,%01011000 + !byte $21,%01011000 + !byte $24,%11010011 + !byte $1F,%11011001 + !byte $25,%00010010 + !byte $19,%00010010 + !byte $1A,%11001111 + !byte $24,%11001111 + !byte $16,%00110110 + !byte $18,%00110000 + !byte $26,%00110000 + !byte $28,%00110110 + !byte $18,%01010000 + !byte $26,%01010000 + !byte $19,%11001111 + !byte $25,%11001111 + !byte $27,%00010100 + !byte $17,%00010100 + !byte $26,%00010000 + !byte $15,%00010110 + !byte $29,%00010110 + !byte $18,%00010000 + !byte $15,%01110100 + !byte $15,%10010101; + !byte $29,%01110100 + !byte $29,%10010101; + !byte $1E,%11011001 + !byte $18,%01110000 + !byte $18,%10010001; + !byte $26,%01110000 + !byte $26,%10010001; + !byte $20,%11011001 + !byte $28,%00110100 + !byte $21,%00110000 + !byte $1D,%00110000 + !byte $16,%00110100 + !byte $18,%11101111 + !byte $26,%11101111 + !byte $24,%00110110 + !byte $21,%01111000 + !byte $21,%10011001; + !byte $1A,%00110110 + !byte $1A,%01110010 + !byte $1A,%10010011; + !byte $24,%01110010 + !byte $24,%10010011; + !byte $1D,%01111000 + !byte $1D,%10011001; + !byte $26,%11110011 + !byte $1C,%00010110 + !byte $18,%11110011 + !byte $23,%11001111 + !byte $1B,%11001111 + !byte $22,%00010110 + !byte $1F,%11111001 + !byte $18,%10110001 + !byte $26,%10110001 + !byte $20,%01110000 + !byte $20,%10010001; + !byte $1E,%01110000 + !byte $1E,%10010001; + !byte $15,%00110110 + !byte $1C,%11101111 + !byte $29,%00110110 + !byte $22,%11101111 + !byte $18,%11001111 + !byte $19,%10101111 + !byte $26,%11001111 + !byte $25,%10101111 + !byte $24,%10101111 + !byte $1A,%10101111 + !byte $1E,%11111001 + !byte $20,%11111001 + !byte $29,%01010100 + !byte $1F,%11010001 + !byte $15,%01010100 + !byte $17,%01010110 + !byte $27,%01010110 + !byte $1D,%10111001 + !byte $14,%11110101 + !byte $14,%11010101 + !byte $2A,%11010101 + !byte $2A,%11110101 + !byte $21,%10111001 + !byte $26,%01010110 + !byte $18,%01010110 + !byte $16,%01010110 + !byte $28,%01010110 + !byte $14,%00010110 + !byte $14,%10110101 + !byte $2A,%00010110 + !byte $2A,%10110101 + !byte $1F,%00011010 + !byte $19,%00110010 + !byte $18,%10101111 + !byte $26,%10101111 + !byte $25,%00110010 + !byte $18,%11010001 + !byte $26,%11010001 + !byte $25,%11010011 + !byte $19,%11010011 + !byte $20,%00011010 + !byte $1E,%00011010 + !byte $1D,%11011001 + !byte $21,%11011001 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $25,%01101110 + !byte $25,%10001111; + !byte $1A,%10110011 + !byte $22,%00110110 + !byte $1C,%00110110 + !byte $15,%01010110 + !byte $24,%10110011 + !byte $2A,%00110110 + !byte $29,%01010110 + !byte $14,%00110110 + !byte $23,%10101111 + !byte $14,%01110100 + !byte $14,%10010101; + !byte $2A,%01110100 + !byte $2A,%10010101; + !byte $1B,%10101111 + !byte $19,%01010110 + !byte $25,%01010110 + !byte $1A,%01101110 + !byte $1A,%10001111; + !byte $24,%01101110 + !byte $24,%10001111; + !byte $28,%00010100 + !byte $26,%01101110 + !byte $26,%10001111; + !byte $16,%00010100 + !byte $18,%01101110 + !byte $18,%10001111; + !byte $21,%00010000 + !byte $1D,%00010000 + !byte $1F,%00111010 + !byte $17,%00010000 + !byte $27,%00010000 + !byte $17,%11101111 + !byte $27,%11101111 + !byte $1B,%00110110 + !byte $23,%00110110 + !byte $1C,%01010110 + !byte $22,%01010110 + !byte $15,%00110100 + !byte $1C,%10110111 + !byte $22,%10110111 + !byte $29,%00110100 + !byte $1C,%01110110 + !byte $1C,%10010111; + !byte $17,%00110000 + !byte $27,%11001111 + !byte $27,%00110000 + !byte $22,%01110110 + !byte $22,%10010111; + !byte $17,%11001111 + !byte $1C,%11010111 + !byte $22,%11010111 + !byte $1C,%11001111 + !byte $22,%11001111 + !byte $21,%11111001 + !byte $1C,%11110111 + !byte $1D,%11111001 + !byte $22,%11110111 + !byte $1E,%00111010 + !byte $27,%11110011 + !byte $17,%11110011 + !byte $20,%00111010 + !byte $13,%11110101 + !byte $2B,%11110101 + !byte $2A,%01010110 + !byte $14,%01010110 + !byte $27,%10101111 + !byte $17,%10101111 + !byte $13,%00010110 + !byte $13,%11010101 + !byte $2B,%11010101 + !byte $2B,%00010110 + !byte $22,%00011000 + !byte $1C,%00011000 + !byte $27,%01010000 + !byte $17,%01010000 + !byte $18,%11110001 + !byte $20,%01010000 + !byte $19,%01001110 + !byte $25,%01001110 + !byte $1E,%01010000 + !byte $26,%11110001 + !byte $2A,%01010100 + !byte $18,%01001110 + !byte $1F,%10110001 + !byte $14,%01010100 + !byte $26,%01001110 + !byte $16,%01110110 + !byte $16,%10010111; + !byte $28,%01110110 + !byte $28,%10010111; + !byte $22,%00111000 + !byte $1F,%01011010 + !byte $1C,%00111000 + !byte $17,%01110110 + !byte $17,%10010111; + !byte $13,%00110110 + !byte $27,%01110110 + !byte $27,%10010111; + !byte $2B,%00110110 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $2B,%10110101 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $13,%10110101 + !byte $15,%01110110 + !byte $15,%10010111; + !byte $29,%01110110 + !byte $29,%10010111; + !byte $1D,%00011010 + !byte $21,%00011010 + !byte $22,%01011000 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $24,%01001110 + !byte $1E,%01011010 + !byte $20,%01011010 + !byte $1C,%01011000 + !byte $1A,%01001110 + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $27,%01110000 + !byte $27,%10010001; + !byte $17,%01110000 + !byte $17,%10010001; + !byte $25,%01010010 + !byte $19,%01010010 + !byte $1A,%01010110 + !byte $24,%01010110 + !byte $17,%01001110 + !byte $27,%01001110 + !byte $13,%01010110 + !byte $26,%11010011 + !byte $2B,%01010110 + !byte $26,%01110110 + !byte $26,%10010111; + !byte $18,%01110110 + !byte $18,%10010111; + !byte $18,%11010011 + !byte $14,%01110110 + !byte $14,%10010111; + !byte $2A,%01110110 + !byte $2A,%10010111; + !byte $13,%01110100 + !byte $13,%10010101; + !byte $22,%01111000 + !byte $22,%10011001; + !byte $2B,%01110100 + !byte $2B,%10010101; + !byte $18,%00101110 + !byte $26,%00101110 + !byte $1C,%01111000 + !byte $1C,%10011001; + !byte $1F,%01111010 + !byte $1F,%10011011; + !byte $25,%00101110 + !byte $19,%00101110 + !byte $1D,%00111010 + !byte $21,%00111010 + !byte $1D,%11101111 + !byte $1C,%10101111 + !byte $20,%01111010 + !byte $20,%10011011; + !byte $12,%11110101 + !byte $15,%00010100 + !byte $21,%11101111 + !byte $2C,%00010110 + !byte $1E,%01111010 + !byte $1E,%10011011; + !byte $12,%00010110 + !byte $2C,%11110101 + !byte $1C,%10111001 + !byte $22,%10101111 + !byte $22,%10111001 + !byte $29,%00010100 + !byte $17,%00101110 + !byte $27,%00101110 + !byte $14,%00110100 + !byte $12,%00110110 + !byte $2C,%00110110 + !byte $12,%11010101 + !byte $2A,%00110100 + !byte $2C,%11010101 + !byte $17,%10110001 + !byte $27,%10110001 + !byte $28,%11001111 + !byte $16,%11001111 + !byte $26,%00010010 + !byte $28,%10101111 + !byte $16,%10101111 + !byte $13,%01110110 + !byte $13,%10010111; + !byte $2B,%01110110 + !byte $2B,%10010111; + !byte $18,%00010010 + !byte $28,%11101111 + !byte $19,%10110011 + !byte $16,%11101111 + !byte $16,%11110011 + !byte $25,%10110011 + !byte $28,%11110011 + !byte $1F,%10111011 + !byte $16,%01101110 + !byte $16,%10001111; + !byte $24,%00101110 + !byte $28,%01101110 + !byte $28,%10001111; + !byte $21,%01011010 + !byte $1D,%01011010 + !byte $1A,%00101110 + !byte $22,%11011001 + !byte $18,%00001110 + !byte $26,%00001110 + !byte $1C,%11011001 + !byte $12,%01010110 + !byte $2C,%01010110 + !byte $15,%10110111 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $29,%10110111 + !byte $20,%00110000 + !byte $2B,%01010100 + !byte $12,%10110101 + !byte $16,%00010000 + !byte $1E,%00110000 + !byte $13,%01010100 + !byte $28,%00010000 + !byte $2C,%10110101 + !byte $16,%10110111 + !byte $28,%10110111 + !byte $23,%01001110 + !byte $16,%01001110 + !byte $1B,%01001110 + !byte $28,%01001110 + !byte $20,%10111011 + !byte $1E,%10111011 + !byte $19,%00001110 + !byte $25,%00001110 + !byte $27,%00001110 + !byte $17,%00001110 + !byte $25,%01110110 + !byte $25,%10010111; + !byte $19,%01110110 + !byte $19,%10010111; + !byte $14,%10110111 + !byte $2A,%10110111 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $19,%01110010 + !byte $19,%10010011; + !byte $22,%11111001 + !byte $1C,%11111001 + !byte $1B,%01010110 + !byte $23,%01010110 + !byte $28,%00101110 + !byte $16,%00101110 + !byte $28,%00110000 + !byte $17,%10110111 + !byte $16,%00110000 + !byte $21,%01111010 + !byte $21,%10011011; + !byte $1D,%01111010 + !byte $1D,%10011011; + !byte $27,%10110111 + !byte $1F,%11011011 + !byte $12,%01110110 + !byte $12,%10010111; + !byte $2C,%01110110 + !byte $2C,%10010111; + !byte $2B,%10110111 + !byte $13,%10110111 + !byte $17,%11010011 + !byte $27,%11010011 + !byte $11,%00010110 + !byte $2C,%01110100 + !byte $2C,%10010101; + !byte $2D,%00010110 + !byte $18,%11101101 + !byte $26,%11101101 + !byte $12,%01110100 + !byte $12,%10010101; + !byte $11,%00110110 + !byte $11,%11110101 + !byte $2D,%11110101 + !byte $2D,%00110110 + !byte $17,%11010001 + !byte $1E,%11011011 + !byte $27,%11010001 + !byte $20,%11011011 + !byte $27,%11101101 + !byte $17,%11101101 + !byte $1C,%00011010 + !byte $16,%00001110 + !byte $28,%00001110 + !byte $22,%00011010 + !byte $22,%01101110 + !byte $22,%10001111; + !byte $1C,%01101110 + !byte $1C,%10001111; + !byte $21,%11001111 + !byte $2D,%01010110 + !byte $11,%01010110 + !byte $1D,%11001111 + !byte $2D,%11010101 + !byte $11,%11010101 + !byte $24,%00001110 + !byte $1A,%00001110 + !byte $21,%10111011 + !byte $16,%01010000 + !byte $1D,%10111011 + !byte $28,%01010000 + !byte $19,%11101101 + !byte $25,%11101101 + !byte $2A,%00010100 + !byte $1F,%11111011 + !byte $14,%00010100 + !byte $2B,%00110100 + !byte $13,%00110100 + !byte $2C,%10110111 + !byte $1C,%00111010 + !byte $12,%10110111 + !byte $16,%11101101 + !byte $28,%11101101 + !byte $22,%00111010 + !byte $23,%00101110 + !byte $18,%00110010 + !byte $1B,%00101110 + !byte $26,%00110010 + !byte $29,%11110011 + !byte $11,%01110110 + !byte $11,%10010111; + !byte $26,%10110111 + !byte $1E,%11111011 + !byte $2D,%01110110 + !byte $2D,%10010111; + !byte $20,%11111011 + !byte $18,%10110111 + !byte $15,%11110011 + !byte $2D,%10110101 + !byte $27,%11001101 + !byte $17,%11001101 + !byte $1F,%01010000 + !byte $11,%10110101 + !byte $14,%11010111 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $29,%01101110 + !byte $29,%10001111; + !byte $2A,%11010111 + !byte $29,%01001110 + !byte $15,%01001110 + !byte $29,%11010111 + !byte $15,%11010111 + !byte $18,%11001101 + !byte $26,%11001101 + !byte $29,%10101111 + !byte $15,%10101111 + !byte $18,%10110011 + !byte $2C,%01010100 + !byte $12,%01010100 + !byte $1E,%00010000 + !byte $26,%10110011 + !byte $1A,%01110110 + !byte $1A,%10010111; + !byte $15,%00101110 + !byte $29,%00101110 + !byte $1D,%11011011 + !byte $24,%01110110 + !byte $24,%10010111; + !byte $21,%11011011 + !byte $20,%00010000 + !byte $13,%11010111 + !byte $2B,%11010111 + !byte $1C,%01011010 + !byte $29,%11001111 + !byte $15,%11001111 + !byte $1F,%00011100 + !byte $22,%01011010 + !byte $16,%11001101 + !byte $28,%11001101 + !byte $23,%01110110 + !byte $23,%10010111; + !byte $16,%11010111 + !byte $1B,%01110110 + !byte $1B,%10010111; + !byte $28,%11010111 + !byte $29,%00001110 + !byte $10,%00110110 + !byte $10,%00010110 + !byte $2E,%00010110 + !byte $2E,%00110110 + !byte $15,%00001110 + !byte $2D,%10110111 + !byte $11,%10110111 + !byte $28,%01110000 + !byte $28,%10010001; + !byte $16,%01110000 + !byte $16,%10010001; + !byte $10,%01010110 + !byte $2E,%01010110 + !byte $1E,%00011100 + !byte $20,%00011100 + !byte $2E,%11110101 + !byte $10,%11110101 + !byte $15,%11101111 + !byte $29,%11101111 + !byte $19,%11001101 + !byte $25,%11001101 + !byte $27,%11110001 + !byte $12,%11010111 + !byte $1A,%11101101 + !byte $24,%11101101 + !byte $2C,%11010111 + !byte $16,%11010011 + !byte $15,%11101101 + !byte $2D,%01110100 + !byte $2D,%10010101; + !byte $17,%11110001 + !byte $29,%11101101 + !byte $11,%01110100 + !byte $11,%10010101; + !byte $17,%10101101 + !byte $27,%10101101 + !byte $28,%11010011 + !byte $21,%11111011 + !byte $1D,%11111011 + !byte $22,%01111010 + !byte $22,%10011011; + !byte $1C,%01001110 + !byte $1C,%01111010 + !byte $1C,%10011011; + !byte $10,%01110110 + !byte $10,%10010111; + !byte $2E,%01110110 + !byte $2E,%10010111; + !byte $10,%11010101 + !byte $22,%01001110 + !byte $2E,%11010101 + !byte $1F,%00111100 + !byte $16,%10101101 + !byte $18,%10101101 + !byte $26,%10101101 + !byte $28,%10101101 + !byte $21,%10101111 + !byte $1D,%10101111 + !byte $15,%11001101 + !byte $29,%11001101 + !byte $1B,%10110111 + !byte $15,%00010000 + !byte $27,%11010111 + !byte $29,%00010000 + !byte $23,%10110111 + !byte $23,%00001110 + !byte $20,%00111100 + !byte $1B,%00001110 + !byte $1E,%00111100 + !byte $17,%11010111 + !byte $11,%11010111 + !byte $2B,%00010100 + !byte $2D,%11010111 + !byte $13,%00010100 + !byte $22,%10111011 + !byte $19,%10110111 + !byte $12,%00110100 + !byte $1C,%10111011 + !byte $25,%10110111 + !byte $10,%10110111 + !byte $2E,%10110111 + !byte $18,%01010010 + !byte $26,%01010010 + !byte $1D,%00011100 + !byte $2C,%00110100 + !byte $21,%00011100 + !byte $1B,%11010111 + !byte $2E,%10110101 + !byte $10,%10110101 + !byte $23,%11010111 + !byte $2A,%11110011 + !byte $14,%11110011 + !byte $1F,%00110000 + !byte $1B,%00111000 + !byte $1B,%00011000 + !byte $1B,%11110111 + !byte $14,%11110111 + !byte $15,%10101101 + !byte $17,%01101100 + !byte $17,%10001101; + !byte $2B,%11110111 + !byte $2A,%11110111 + !byte $23,%11110111 + !byte $23,%00011000 + !byte $23,%00111000 + !byte $13,%11110111 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $29,%10101101 + !byte $1B,%01011000 + !byte $23,%01011000 + !byte $1F,%01011100 + !byte $0F,%00110110 + !byte $16,%01101100 + !byte $16,%10001101; + !byte $28,%10110001 + !byte $2F,%00110110 + !byte $28,%01101100 + !byte $28,%10001101; + !byte $1B,%01111000 + !byte $1B,%10011001; + !byte $0F,%01010110 + !byte $23,%01111000 + !byte $23,%10011001; + !byte $2F,%01010110 + !byte $2F,%00010110 + !byte $25,%10101101 + !byte $0F,%00010110 + !byte $19,%10101101 + !byte $16,%10110001 + !byte $2D,%01010100 + !byte $18,%01110010 + !byte $18,%10010011; + !byte $11,%01010100 + !byte $27,%10110011 + !byte $12,%11110111 + !byte $26,%01110010 + !byte $26,%10010011; + !byte $2C,%11110111 + !byte $17,%10110011 + !byte $1E,%11101111 + !byte $1B,%10111001 + !byte $23,%10111001 + !byte $15,%11110111 + !byte $1A,%11001101 + !byte $1E,%01011100 + !byte $22,%11011011 + !byte $14,%00101110 + !byte $2A,%00101110 + !byte $29,%00110000 + !byte $20,%01011100 + !byte $1C,%11011011 + !byte $29,%11110111 + !byte $20,%11101111 + !byte $14,%00001110 + !byte $14,%01001110 + !byte $2A,%01001110 + !byte $2A,%00001110 + !byte $24,%11001101 + !byte $0F,%01110110 + !byte $0F,%10010111; + !byte $26,%01101100 + !byte $26,%10001101; + !byte $2F,%01110110 + !byte $2F,%10010111; + !byte $15,%00110000 + !byte $0F,%11110101 + !byte $2F,%11110101 + !byte $18,%01101100 + !byte $18,%10001101; + !byte $10,%11010111 + !byte $2E,%11010111 + !byte $23,%11011001 + !byte $1B,%11011001 + !byte $14,%11101101 + !byte $2A,%11101101 + !byte $2A,%01101110 + !byte $2A,%10001111; + !byte $21,%00111100 + !byte $14,%01101110 + !byte $14,%10001111; + !byte $1D,%00111100 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $29,%01101100 + !byte $29,%10001101; + !byte $11,%11110111 + !byte $2D,%11110111 + !byte $23,%11111001 + !byte $0F,%10110111 + !byte $10,%01110100 + !byte $10,%10010101; + !byte $2A,%11001101 + !byte $1B,%11111001 + !byte $14,%11001101 + !byte $29,%11010011 + !byte $2F,%10110111 + !byte $1F,%01111100 + !byte $1F,%10011101; + !byte $15,%11010011 + !byte $2A,%10101111 + !byte $2E,%01110100 + !byte $2E,%10010101; + !byte $17,%00010010 + !byte $14,%10101111 + !byte $0F,%11010101 + !byte $27,%00010010 + !byte $2F,%11010101 + !byte $16,%01001100 + !byte $28,%01001100 + !byte $1C,%11111011 + !byte $27,%01001100 + !byte $17,%01001100 + !byte $22,%11111011 + !byte $22,%00101110 + !byte $18,%11010111 + !byte $1C,%00101110 + !byte $26,%11010111 + !byte $1E,%01111100 + !byte $1E,%10011101; + !byte $1B,%00011010 + !byte $20,%01111100 + !byte $20,%10011101; + !byte $16,%11110111 + !byte $1B,%11101101 + !byte $28,%11110111 + !byte $23,%00011010 + !byte $2A,%10101101 + !byte $14,%10101101 + !byte $23,%11101101 + !byte $1D,%01011100 + !byte $29,%01001100 + !byte $24,%10110111 + !byte $21,%01011100 + !byte $1A,%10110111 + !byte $15,%01001100 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $0F,%11010111 + !byte $2A,%11001111 + !byte $2E,%11110111 + !byte $14,%11001111 + !byte $2F,%11010111 + !byte $1B,%00111010 + !byte $10,%11110111 + !byte $23,%00111010 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $25,%01101100 + !byte $25,%10001101; + !byte $12,%00010100 + !byte $0E,%01010110 + !byte $30,%01010110 + !byte $0E,%00110110 + !byte $30,%00110110 + !byte $15,%01010000 + !byte $14,%01101100 + !byte $14,%10001101; + !byte $1F,%10111101 + !byte $18,%01001100 + !byte $2A,%01101100 + !byte $2A,%10001101; + !byte $29,%01010000 + !byte $26,%01001100 + !byte $22,%00011100 + !byte $2F,%10110101 + !byte $1C,%00011100 + !byte $0F,%10110101 + !byte $2C,%00010100 + !byte $0E,%01110110 + !byte $0E,%10010111; + !byte $0E,%00010110 + !byte $30,%00010110 + !byte $30,%01110110 + !byte $30,%10010111; + !byte $2D,%00110100 + !byte $11,%00110100 + !byte $13,%00011000 + !byte $2B,%00011000 + !byte $1F,%00010000 + !byte $2C,%00011000 + !byte $16,%11010001 + !byte $12,%00011000 + !byte $28,%11010001 + !byte $24,%10101101 + !byte $1E,%10111101 + !byte $16,%00101100 + !byte $1A,%10101101 + !byte $28,%00101100 + !byte $23,%01011010 + !byte $1B,%01011010 + !byte $20,%10111101 + !byte $2B,%11110011 + !byte $13,%11110011 + !byte $0E,%10110111 + !byte $1D,%01111100 + !byte $1D,%10011101; + !byte $10,%01010100 + !byte $30,%10110111 + !byte $14,%00011000 + !byte $27,%00101100 + !byte $2A,%00011000 + !byte $21,%01111100 + !byte $21,%10011101; + !byte $17,%00101100 + !byte $11,%00011000 + !byte $15,%00101100 + !byte $29,%00101100 + !byte $2D,%00011000 + !byte $0E,%11110101 + !byte $2A,%01001100 + !byte $14,%01001100 + !byte $30,%11110101 + !byte $2A,%11101111 + !byte $14,%11101111 + !byte $2E,%01010100 + !byte $28,%10110011 + !byte $16,%10110011 + !byte $0F,%11110111 + !byte $1E,%11001111 + !byte $20,%11001111 + !byte $2F,%11110111 + !byte $23,%01111010 + !byte $23,%10011011; + !byte $22,%00111100 + !byte $1C,%00111100 + !byte $1B,%01111010 + !byte $1B,%10011011; + !byte $1F,%11011101 + !byte $17,%11110111 + !byte $27,%11110111 + !byte $0E,%11010111 + !byte $13,%11101101 + !byte $2B,%11101101 + !byte $2B,%00001110 + !byte $13,%00001110 + !byte $13,%11001101 + !byte $2B,%11001101 + !byte $30,%11010111 + !byte $2E,%00011000 + !byte $10,%00011000 + !byte $1E,%11011101 + !byte $20,%11011101 + !byte $0E,%11010101 + !byte $13,%00101110 + !byte $2B,%00101110 + !byte $30,%11010101 + !byte $13,%10101101 + !byte $14,%00101100 + !byte $29,%00011000 + !byte $0F,%01110100 + !byte $0F,%10010101; + !byte $2A,%00101100 + !byte $2B,%10101101 + !byte $17,%00110010 + !byte $27,%00110010 + !byte $1D,%10111101 + !byte $15,%00011000 + !byte $2F,%01110100 + !byte $2F,%10010101; + !byte $14,%11010011 + !byte $21,%10111101 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $23,%10111011 + !byte $1B,%10111011 + !byte $16,%00001100 + !byte $26,%00101100 + !byte $28,%00001100 + !byte $25,%11010111 + !byte $18,%00101100 + !byte $1B,%11001101 + !byte $22,%00001110 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $2A,%11010011 + !byte $25,%01001100 + !byte $15,%00001100 + !byte $29,%00001100 + !byte $19,%01001100 + !byte $1C,%00001110 + !byte $19,%11010111 + !byte $23,%11001101 + !byte $1C,%01011100 + !byte $2B,%01001110 + !byte $13,%01001110 + !byte $22,%01011100 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $29,%01110000 + !byte $29,%10010001; + !byte $0D,%01010110 + !byte $31,%01010110 + !byte $31,%01110110 + !byte $31,%10010111; + !byte $0D,%01110110 + !byte $0D,%10010111; + !byte $0D,%00110110 + !byte $31,%00110110 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $14,%00010000 + !byte $2A,%00010000 + !byte $1F,%11111101 + !byte $30,%11110111 + !byte $17,%00001100 + !byte $27,%00001100 + !byte $0E,%11110111 + !byte $0F,%00011000 + !byte $2F,%00011000 + !byte $0D,%10110111 + !byte $1D,%01001110 + !byte $31,%10110111 + !byte $13,%01001100 + !byte $23,%11011011 + !byte $2B,%01001100 + !byte $31,%00010110 + !byte $1B,%11011011 + !byte $0D,%00010110 + !byte $2A,%00001100 + !byte $14,%00001100 + !byte $24,%01101100 + !byte $24,%10001101; + !byte $13,%01101110 + !byte $13,%10001111; + !byte $1E,%11111101 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $20,%11111101 + !byte $1A,%01101100 + !byte $1A,%10001101; + !byte $21,%01001110 + !byte $1A,%11010111 + !byte $24,%11010111 + !byte $1D,%11011101 + !byte $30,%10110101 + !byte $0E,%10110101 + !byte $21,%11011101 + !byte $12,%00111000 + !byte $2C,%00111000 + !byte $2D,%00010100 + !byte $11,%00111000 + !byte $1F,%11101111 + !byte $2D,%00111000 + !byte $31,%11010111 + !byte $0D,%11010111 + !byte $2E,%00110100 + !byte $22,%01111100 + !byte $22,%10011101; + !byte $11,%00010100 + !byte $1C,%01111100 + !byte $1C,%10011101; + !byte $10,%00110100 + !byte $13,%00101100 + !byte $15,%11101011 + !byte $29,%11101011 + !byte $2B,%00101100 + !byte $0D,%11110101 + !byte $31,%11110101 + !byte $23,%11111011 + !byte $28,%11101011 + !byte $13,%00111000 + !byte $2B,%00111000 + !byte $16,%11101011 + !byte $17,%01010010 + !byte $16,%11110001 + !byte $27,%01010010 + !byte $1B,%11111011 + !byte $28,%11110001 + !byte $12,%11110011 + !byte $2C,%11110011 + !byte $28,%00011000 + !byte $10,%00111000 + !byte $2E,%00111000 + !byte $16,%00011000 + !byte $1F,%00011110 + !byte $2F,%01010100 + !byte $0F,%01010100 + !byte $13,%10101111 + !byte $30,%00011000 + !byte $0E,%00011000 + !byte $2B,%10101111 + !byte $29,%10110011 + !byte $14,%11101011 + !byte $2A,%11101011 + !byte $15,%10110011 + !byte $18,%00001100 + !byte $20,%00011110 + !byte $1E,%00011110 + !byte $26,%00001100 + !byte $18,%11110111 + !byte $1E,%10101111 + !byte $26,%11110111 + !byte $31,%11110111 + !byte $13,%00001100 + !byte $2B,%00001100 + !byte $1D,%11111101 + !byte $0D,%11110111 + !byte $20,%10101111 + !byte $21,%11111101 + !byte $1B,%00011100 + !byte $25,%00101100 + !byte $22,%10111101 + !byte $1C,%10111101 + !byte $17,%11101011 + !byte $19,%00101100 + !byte $23,%00011100 + !byte $27,%11101011 + !byte $14,%00110000 + !byte $2F,%00111000 + !byte $14,%00111000 + !byte $2A,%00110000 + !byte $2A,%00111000 + !byte $0F,%00111000 + !byte $0D,%11010101 + !byte $31,%11010101 + !byte $0C,%01110110 + !byte $0C,%10010111; + !byte $0C,%01010110 + !byte $32,%01110110 + !byte $32,%10010111; + !byte $32,%01010110 + !byte $23,%10101101 + !byte $1B,%10101101 + !byte $30,%01110100 + !byte $30,%10010101; + !byte $0C,%10110111 + !byte $32,%10110111 + !byte $0E,%01110100 + !byte $0E,%10010101; + !byte $22,%11101101 + !byte $2B,%11010011 + !byte $32,%00110110 + !byte $12,%10101101 + !byte $2C,%10101101 + !byte $0C,%00110110 + !byte $12,%11001101 + !byte $1C,%11101101 + !byte $2C,%11001101 + !byte $15,%11001011 + !byte $29,%11001011 + !byte $13,%11010011 + !byte $2C,%01101100 + !byte $2C,%10001101; + !byte $12,%01101100 + !byte $12,%10001101; + !byte $1F,%00111110 + !byte $12,%11101101 + !byte $1A,%11110111 + !byte $2B,%11101011 + !byte $2C,%11101101 + !byte $15,%10110001 + !byte $13,%11101011 + !byte $24,%11110111 + !byte $29,%10110001 + !byte $14,%11001011 + !byte $16,%11001011 + !byte $28,%11001011 + !byte $2A,%11001011 + !byte $13,%11001111 + !byte $12,%01001100 + !byte $0C,%11010111 + !byte $32,%11010111 + !byte $23,%00111100 + !byte $2C,%01001100 + !byte $1B,%00111100 + !byte $31,%00011000 + !byte $2B,%11001111 + !byte $20,%00111110 + !byte $0D,%00011000 + !byte $1E,%00111110 + !byte $0C,%00010110 + !byte $32,%00010110 + !byte $24,%01001100 + !byte $21,%00011110 + !byte $2C,%00001110 + !byte $1D,%00011110 + !byte $1A,%01001100 + !byte $12,%00001110 + !byte $28,%01110010 + !byte $28,%10010011; + !byte $0E,%00111000 + !byte $30,%00111000 + !byte $22,%11011101 + !byte $1C,%11011101 + !byte $16,%01110010 + !byte $16,%10010011; + !byte $12,%00101100 + !byte $2C,%00101100 + !byte $1D,%00101110 + !byte $0D,%10110101 + !byte $31,%10110101 + !byte $0C,%11110111 + !byte $32,%11110111 + !byte $12,%00101110 + !byte $21,%00101110 + !byte $2C,%00101110 + !byte $15,%00111000 + !byte $11,%01011000 + !byte $13,%11001011 + !byte $18,%11101011 + !byte $2D,%01011000 + !byte $2B,%11001011 + !byte $29,%00111000 + !byte $1F,%11001111 + !byte $10,%01011000 + !byte $12,%00001100 + !byte $32,%11110101 + !byte $2E,%01011000 + !byte $1B,%01011100 + !byte $1F,%01011110 + !byte $0C,%11110101 + !byte $26,%11101011 + !byte $27,%11001011 + !byte $24,%00011000 + !byte $2C,%00001100 + !byte $1A,%00011000 + !byte $23,%01011100 + !byte $17,%00011000 + !byte $27,%00011000 + !byte $17,%11001011 + !byte $2E,%00010100 + !byte $0F,%00110100 + !byte $2C,%01011000 + !byte $12,%01011000 + !byte $15,%10101011 + !byte $29,%10101011 + !byte $10,%00010100 + !byte $2F,%00110100 + !byte $2A,%10101011 + !byte $14,%10101011 + !byte $1C,%11111101 + !byte $16,%00010010 + !byte $21,%00111110 + !byte $20,%01011110 + !byte $0F,%01011000 + !byte $28,%00010010 + !byte $2F,%01011000 + !byte $1E,%01011110 + !byte $0D,%00111000 + !byte $1D,%00111110 + !byte $22,%11111101 + !byte $25,%00001100 + !byte $31,%00111000 + !byte $25,%11110111 + !byte $0E,%01010100 + !byte $19,%11110111 + !byte $19,%00001100 + !byte $24,%00111000 + !byte $1A,%00111000 + !byte $14,%01010000 + !byte $2C,%11101011 + !byte $12,%11101011 + !byte $14,%10110011 + !byte $2D,%11110011 + !byte $16,%10101011 + !byte $28,%10101011 + !byte $2A,%01010000 + !byte $13,%11101111 + !byte $32,%00011000 + !byte $0B,%01110110 + !byte $0B,%10010111; + !byte $2C,%01001110 + !byte $2A,%10110011 + !byte $33,%01110110 + !byte $33,%10010111; + !byte $0C,%00011000 + !byte $11,%11110011 + !byte $12,%01001110 + !byte $2B,%11101111 + !byte $30,%01010100 + !byte $33,%10110111 + !byte $24,%01011000 + !byte $0B,%10110111 + !byte $1A,%01011000 + !byte $1A,%11011001 + !byte $1A,%10111001 + !byte $1A,%01111000 + !byte $1A,%10011001; + !byte $0B,%01010110 + !byte $33,%01010110 + !byte $24,%01111000 + !byte $24,%10011001; + !byte $24,%10111001 + !byte $24,%11011001 + !byte $13,%01011000 + !byte $1B,%01111100 + !byte $1B,%10011101; + !byte $24,%11111001 + !byte $2B,%01011000 + !byte $1A,%11111001 + !byte $2B,%10101011 + !byte $23,%01111100 + !byte $23,%10011101; + !byte $1A,%00011010 + !byte $13,%10101011 + !byte $24,%00011010 + !byte $33,%11010111 + !byte $0C,%11010101 + !byte $0B,%11010111 + !byte $20,%01101110 + !byte $20,%10001111; + !byte $30,%01011000 + !byte $1E,%01101110 + !byte $1E,%10001111; + !byte $32,%11010101 + !byte $0E,%01011000 + !byte $1A,%00111010 + !byte $0B,%00110110 + !byte $33,%00110110 + !byte $1F,%01111110 + !byte $1F,%10011111; + !byte $24,%00111010 + !byte $12,%11001011 + !byte $0D,%01110100 + !byte $0D,%10010101; + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $2C,%11001011 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $22,%00011110 + !byte $1C,%00011110 + !byte $22,%11001101 + !byte $1A,%01011010 + !byte $21,%01011110 + !byte $1E,%01111110 + !byte $1E,%10011111; + !byte $1D,%01011110 + !byte $24,%01011010 + !byte $1C,%11001101 + !byte $31,%01110100 + !byte $31,%10010101; + !byte $20,%01111110 + !byte $20,%10011111; + !byte $0B,%11110111 + !byte $33,%11110111 + !byte $14,%01101010 + !byte $14,%10001011; + !byte $12,%11010011 + !byte $2A,%01101010 + !byte $2A,%10001011; + !byte $2C,%11010011 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $29,%01101010 + !byte $29,%10001011; + !byte $1A,%00101100 + !byte $33,%00010110 + !byte $1B,%10111101 + !byte $0C,%00111000 + !byte $1A,%01111010 + !byte $1A,%10011011; + !byte $23,%10111101 + !byte $0B,%00010110 + !byte $24,%00101100 + !byte $32,%00111000 + !byte $24,%01111010 + !byte $24,%10011011; + !byte $12,%01101110 + !byte $12,%10001111; + !byte $2C,%01101110 + !byte $2C,%10001111; + !byte $15,%11010001 + !byte $27,%10101011 + !byte $17,%10101011 + !byte $29,%11010001 + !byte $11,%01101100 + !byte $11,%10001101; + !byte $26,%11001011 + !byte $2D,%01001100 + !byte $11,%01001100 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $18,%11001011 + !byte $13,%01101010 + !byte $13,%10001011; + !byte $0D,%01011000 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $16,%00111000 + !byte $31,%01011000 + !byte $12,%10101011 + !byte $28,%00111000 + !byte $2D,%00101100 + !byte $2D,%10101101 + !byte $11,%10101101 + !byte $11,%00101100 + !byte $2C,%10101011 + !byte $2A,%01011000 + !byte $28,%01010010 + !byte $1A,%10111011 + !byte $24,%10111011 + !byte $14,%01011000 + !byte $16,%01010010 + !byte $33,%00011000 + !byte $0B,%00011000 + !byte $29,%01110010 + !byte $29,%10010011; + !byte $11,%00001100 + !byte $28,%01101010 + !byte $28,%10001011; + !byte $1F,%10111111 + !byte $15,%01110010 + !byte $15,%10010011; + !byte $2D,%00001100 + !byte $28,%00110010 + !byte $16,%00110010 + !byte $16,%01101010 + !byte $16,%10001011; + !byte $11,%11001101 + !byte $32,%10110101 + !byte $2D,%11001101 + !byte $22,%00111110 + !byte $0C,%10110101 + !byte $13,%00010000 + !byte $1C,%00111110 + !byte $21,%00001110 + !byte $10,%01111000 + !byte $10,%10011001; + !byte $2E,%01111000 + !byte $2E,%10011001; + !byte $2B,%00010000 + !byte $0B,%11110101 + !byte $1D,%00001110 + !byte $33,%11110101 + !byte $1D,%01111110 + !byte $1D,%10011111; + !byte $24,%11011011 + !byte $1E,%10111111 + !byte $0F,%01111000 + !byte $0F,%10011001; + !byte $1F,%10101111 + !byte $19,%11101011 + !byte $2F,%01111000 + !byte $2F,%10011001; + !byte $21,%01111110 + !byte $21,%10011111; + !byte $20,%10111111 + !byte $1B,%11011101 + !byte $1A,%11011011 + !byte $11,%11101011 + !byte $11,%01111000 + !byte $11,%10011001; + !byte $2D,%01111000 + !byte $2D,%10011001; + !byte $2D,%11101011 + !byte $23,%11011101 + !byte $26,%00011000 + !byte $25,%11101011 + !byte $18,%00011000 + !byte $0A,%10110111 + !byte $2D,%11101101 + !byte $34,%10110111 + !byte $0A,%01110110 + !byte $0A,%10010111; + !byte $34,%01110110 + !byte $34,%10010111; + !byte $14,%01001010 + !byte $2A,%01001010 + !byte $11,%11101101 + !byte $2F,%00010100 + !byte $0E,%00110100 + !byte $2C,%01101010 + !byte $2C,%10001011; + !byte $12,%01101010 + !byte $12,%10001011; + !byte $34,%11010111 + !byte $0A,%11010111 + !byte $0F,%00010100 + !byte $0A,%01010110 + !byte $0E,%01111000 + !byte $0E,%10011001; + !byte $32,%01011000 + !byte $30,%01111000 + !byte $30,%10011001; + !byte $34,%01010110 + !byte $12,%10101111 + !byte $0C,%01011000 + !byte $1A,%11111011 + !byte $29,%01001010 + !byte $2B,%01001010 + !byte $2A,%01110000 + !byte $2A,%10010001; + !byte $24,%11111011 + !byte $14,%01110000 + !byte $14,%10010001; + !byte $13,%01001010 + !byte $15,%01001010 + !byte $2C,%10101111 + !byte $30,%00110100 + !byte $11,%11001011 + !byte $2D,%11001011 + !byte $33,%00111000 + !byte $0B,%00111000 + !byte $2B,%10110011 + !byte $13,%10110011 + !byte $2C,%01111000 + !byte $2C,%10011001; + !byte $12,%01111000 + !byte $12,%10011001; + !byte $34,%11110111 + !byte $0A,%11110111 + !byte $2E,%11110011 + !byte $10,%11110011 + !byte $1F,%11011111 + !byte $31,%01010100 + !byte $0A,%00110110 + !byte $34,%00110110 + !byte $22,%01011110 + !byte $1C,%01011110 + !byte $11,%00001110 + !byte $2D,%00001110 + !byte $0D,%01010100 + !byte $23,%11111101 + !byte $1B,%11111101 + !byte $1A,%00011100 + !byte $24,%00011100 + !byte $33,%11010101 + !byte $21,%10111111 + !byte $0D,%01111000 + !byte $0D,%10011001; + !byte $1D,%10111111 + !byte $0B,%11010101 + !byte $31,%01111000 + !byte $31,%10011001; + !byte $11,%10101011 + !byte $1E,%11011111 + !byte $2D,%10101011 + !byte $20,%11011111 + !byte $1E,%01001110 + !byte $17,%01101010 + !byte $17,%10001011; + !byte $27,%01101010 + !byte $27,%10001011; + !byte $23,%01001100 + !byte $12,%01001010 + !byte $1B,%01001100 + !byte $2C,%01001010 + !byte $20,%01001110 + !byte $25,%00011000 + !byte $34,%00011000 + !byte $0A,%00011000 + !byte $19,%00011000 + !byte $16,%01001010 + !byte $28,%01001010 + !byte $29,%01011000 + !byte $26,%10101011 + !byte $0A,%00010110 + !byte $18,%10101011 + !byte $32,%01110100 + !byte $32,%10010101; + !byte $1A,%00001100 + !byte $0C,%01110100 + !byte $0C,%10010101; + !byte $24,%00001100 + !byte $15,%01011000 + !byte $34,%00010110 + !byte $1C,%10101101 + !byte $22,%10101101 + !byte $1A,%00111100 + !byte $14,%00101010 + !byte $24,%00111100 + !byte $2A,%00101010 + !byte $33,%01011000 + !byte $2B,%00101010 + !byte $0B,%01011000 + !byte $11,%01101010 + !byte $11,%10001011; + !byte $13,%00101010 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $2D,%00101110 + !byte $1B,%00011110 + !byte $23,%00011110 + !byte $13,%01111000 + !byte $13,%10011001; + !byte $2B,%01111000 + !byte $2B,%10011001; + !byte $11,%00101110 + !byte $2D,%11010011 + !byte $22,%01111110 + !byte $22,%10011111; + !byte $1C,%01111110 + !byte $1C,%10011111; + !byte $29,%11110001 + !byte $1F,%11111111 + !byte $11,%11010011 + !byte $32,%01111000 + !byte $32,%10011001; + !byte $2C,%11001111 + !byte $27,%00111000 + !byte $0C,%01111000 + !byte $0C,%10011001; + !byte $15,%00101010 + !byte $29,%00101010 + !byte $34,%00111000 + !byte $15,%11110001 + !byte $13,%00110000 + !byte $21,%11011111 + !byte $0A,%00111000 + !byte $1D,%11011111 + !byte $17,%00111000 + !byte $2B,%00110000 + !byte $1E,%11111111 + !byte $12,%11001111 + !byte $1A,%01011100 + !byte $20,%11111111 + !byte $12,%00101010 + !byte $09,%10110111 + !byte $35,%10110111 + !byte $24,%01011100 + !byte $25,%11001011 + !byte $2C,%00101010 + !byte $09,%11010111 + !byte $19,%11001011 + !byte $35,%11010111 + !byte $09,%01110110 + !byte $09,%10010111; + !byte $34,%11110101 + !byte $35,%01110110 + !byte $35,%10010111; + !byte $10,%00101100 + !byte $2E,%00101100 + !byte $33,%10110101 + !byte $0A,%11110101 + !byte $10,%00001100 + !byte $2E,%00001100 + !byte $0B,%10110101 + !byte $0F,%10111001 + !byte $11,%01001010 + !byte $10,%01001100 + !byte $2E,%01001100 + !byte $2F,%10111001 + !byte $2D,%01001010 + !byte $14,%01110010 + !byte $14,%10010011; + !byte $2E,%11101011 + !byte $09,%11110111 + !byte $35,%11110111 + !byte $10,%11101011 + !byte $2E,%10111001 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $10,%10111001 + !byte $2A,%01110010 + !byte $2A,%10010011; + !byte $30,%10111001 + !byte $09,%01010110 + !byte $0E,%10111001 + !byte $35,%01010110 + !byte $1B,%00111110 + !byte $10,%01101100 + !byte $10,%10001101; + !byte $2E,%01101100 + !byte $2E,%10001101; + !byte $10,%11001011 + !byte $23,%00111110 + !byte $21,%11101101 + !byte $2E,%11001011 + !byte $1D,%11101101 + !byte $24,%01111100 + !byte $24,%10011101; + !byte $22,%10111111 + !byte $1A,%01111100 + !byte $1A,%10011101; + !byte $1C,%10111111 + !byte $13,%00001010 + !byte $2B,%00001010 + !byte $34,%01011000 + !byte $11,%01001110 + !byte $33,%01111000 + !byte $33,%10011001; + !byte $14,%00001010 + !byte $35,%00011000 + !byte $0D,%10111001 + !byte $2D,%01001110 + !byte $31,%10111001 + !byte $0A,%01011000 + !byte $09,%00011000 + !byte $2A,%00001010 + !byte $17,%01001010 + !byte $5F,%00000000 + !byte $0B,%01111000 + !byte $0B,%10011001; + !byte $30,%00010100 + !byte $0E,%00010100 + !byte $27,%01001010 + !byte $31,%00110100 + !byte $16,%00101010 + !byte $11,%10111001 + !byte $29,%01010010 + !byte $10,%10101101 + !byte $10,%10101011 + !byte $2E,%10101011 + !byte $2E,%10101101 + !byte $15,%01010010 + !byte $28,%00101010 + !byte $2D,%10111001 + !byte $21,%11111111 + !byte $09,%00110110 + !byte $35,%00110110 + !byte $0D,%00110100 + !byte $1D,%11111111 + !byte $2D,%00101010 + !byte $5E,%00000000 + !byte $11,%00101010 + !byte $60,%00000000 + !byte $14,%10110001 + !byte $2C,%10110011 + !byte $12,%10110011 + !byte $2C,%00001010 + !byte $2A,%10110001 + !byte $12,%00001010 + !byte $26,%01101010 + !byte $26,%10001011; + !byte $18,%01101010 + !byte $18,%10001011; + !byte $0F,%11110011 + !byte $1A,%10111101 + !byte $32,%01010100 + !byte $2A,%01111000 + !byte $2A,%10011001; + !byte $0C,%01010100 + !byte $14,%01111000 + !byte $14,%10011001; + !byte $25,%00111000 + !byte $2E,%01101010 + !byte $2E,%10001011; + !byte $34,%11010101 + !byte $23,%01011110 + !byte $19,%00111000 + !byte $24,%10111101 + !byte $0A,%11010101 + !byte $10,%01101010 + !byte $10,%10001011; + !byte $15,%00001010 + !byte $09,%00111000 + !byte $1B,%01011110 + !byte $29,%00001010 + !byte $32,%10111001 + !byte $0C,%10111001 + !byte $10,%11001101 + !byte $2E,%11001101 + !byte $2F,%11110011 + !byte $35,%00111000 + !byte $23,%00101100 + !byte $1B,%00101100 + !byte $24,%11101011 + !byte $20,%00101110 + !byte $1A,%11101011 + !byte $1E,%00101110 + !byte $35,%00010110 + !byte $16,%01011000 + !byte $1C,%11011111 + !byte $09,%00010110 + !byte $28,%01011000 + !byte $12,%11101111 + !byte $22,%11011111 + !byte $2C,%11101111 + !byte $12,%10111001 + !byte $5F,%00100000 + !byte $2C,%10111001 + !byte $0B,%01110100 + !byte $0B,%10010101; + !byte $15,%00010010 + !byte $10,%01001010 + !byte $0A,%01111000 + !byte $0A,%10011001; + !byte $11,%00001010 + !byte $2E,%01001010 + !byte $29,%00010010 + !byte $2D,%00001010 + !byte $34,%01111000 + !byte $34,%10011001; + !byte $24,%11011101 + !byte $61,%00000000 + !byte $5D,%00000000 + !byte $1A,%11011101 + !byte $13,%11101001 + !byte $2B,%11101001 + !byte $33,%01110100 + !byte $33,%10010101; + !byte $18,%00111000 + !byte $26,%00111000 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $22,%01101100 + !byte $22,%10001101; + !byte $08,%11010111 + !byte $08,%10110111 + !byte $36,%10110111 + !byte $36,%11010111 + !byte $5E,%00100000 + !byte $1C,%01101100 + !byte $1C,%10001101; + !byte $2E,%11010011 + !byte $60,%00100000 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $14,%11101001 + !byte $10,%11010011 + !byte $12,%11101001 + !byte $2C,%11101001 + !byte $35,%01011000 + !byte $0B,%10111001 + !byte $09,%01011000 + !byte $08,%11110111 + !byte $2A,%11101001 + !byte $25,%10101011 + !byte $36,%11110111 + !byte $33,%10111001 + !byte $2E,%11101101 + !byte $08,%01110110 + !byte $08,%10010111; + !byte $19,%10101011 + !byte $10,%11101101 + !byte $1B,%01111110 + !byte $1B,%10011111; + !byte $36,%01110110 + !byte $36,%10010111; + !byte $23,%01111110 + !byte $23,%10011111; + !byte $13,%01010000 + !byte $2E,%00101010 + !byte $08,%00011000 + !byte $36,%00011000 + !byte $10,%00101010 + !byte $2B,%01010000 + !byte $35,%11110101 + !byte $09,%11110101 + !byte $08,%01010110 + !byte $16,%00001010 + !byte $15,%00110010 + !byte $29,%00110010 + !byte $28,%00001010 + !byte $22,%11111111 + !byte $1C,%11111111 + !byte $36,%01010110 + !byte $27,%00101010 + !byte $24,%11111101 + !byte $0E,%11011001 + !byte $30,%11011001 + !byte $17,%00101010 + !byte $2D,%11101001 + !byte $19,%01011000 + !byte $1A,%11111101 + !byte $34,%10110101 + !byte $0A,%10110101 + !byte $0F,%11011001 + !byte $1F,%01001110 + !byte $2F,%11011001 + !byte $25,%01011000 + !byte $11,%11101001 + !byte $31,%11011001 + !byte $0D,%11011001 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $5F,%01000000 + !byte $15,%11101001 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $29,%11101001 + !byte $5D,%00100000 + !byte $36,%00111000 + !byte $08,%00111000 + !byte $61,%00100000 + !byte $2F,%11101011 + !byte $1B,%10111111 + !byte $0F,%11101011 + !byte $10,%00001010 + !byte $2E,%00001010 + !byte $23,%10111111 + !byte $2E,%00001110 + !byte $09,%01111000 + !byte $09,%10011001; + !byte $0F,%11001011 + !byte $2F,%11001011 + !byte $36,%00110110 + !byte $5E,%01000000 + !byte $18,%01001010 + !byte $35,%01111000 + !byte $35,%10011001; + !byte $60,%01000000 + !byte $08,%00110110 + !byte $21,%11001101 + !byte $0A,%10111001 + !byte $0F,%00001100 + !byte $2F,%00001100 + !byte $34,%10111001 + !byte $10,%00001110 + !byte $13,%11001001 + !byte $2B,%11001001 + !byte $10,%11011001 + !byte $0C,%11011001 + !byte $32,%11011001 + !byte $2E,%11011001 + !byte $1D,%11001101 + !byte $12,%11001001 + !byte $0F,%10101011 + !byte $2C,%11001001 + !byte $2F,%10101011 + !byte $13,%10111001 + !byte $26,%01001010 + !byte $2F,%00101100 + !byte $2B,%10111001 + !byte $0F,%00101100 + !byte $31,%00010100 + !byte $24,%00011110 + !byte $0D,%00010100 + !byte $15,%01111000 + !byte $15,%10011001; + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $1A,%00011110 + !byte $29,%01111000 + !byte $29,%10011001; + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $62,%00000000 + !byte $19,%01111000 + !byte $19,%10011001; + !byte $2A,%11001001 + !byte $2D,%10101111 + !byte $5C,%00000000 + !byte $14,%11010001 + !byte $14,%11001001 + !byte $25,%01111000 + !byte $25,%10011001; + !byte $32,%00110100 + !byte $2A,%11010001 + !byte $11,%10110011 + !byte $36,%01011000 + !byte $0C,%00110100 + !byte $08,%01011000 + !byte $2F,%01001100 + !byte $0F,%01001100 + !byte $2D,%10110011 + !byte $2C,%00010000 + !byte $2D,%11001001 + !byte $11,%10101111 + !byte $09,%11010101 + !byte $11,%11001001 + !byte $2F,%01001010 + !byte $35,%11010101 + !byte $0B,%11011001 + !byte $10,%11101001 + !byte $0F,%01001010 + !byte $2E,%11101001 + !byte $33,%01010100 + !byte $30,%11110011 + !byte $0B,%01010100 + !byte $36,%00010110 + !byte $33,%11011001 + !byte $24,%11001011 + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $14,%01010010 + !byte $1A,%11001011 + !byte $08,%00010110 + !byte $0E,%11110011 + !byte $2A,%01010010 + !byte $5D,%01000000 + !byte $61,%01000000 + !byte $12,%00010000 + !byte $07,%11010111 + !byte $37,%11010111 + !byte $2D,%11011001 + !byte $23,%00001100 + !byte $17,%01011000 + !byte $23,%11011111 + !byte $07,%11110111 + !byte $1B,%00001100 + !byte $25,%10111001 + !byte $37,%10110111 + !byte $37,%11110111 + !byte $1B,%11011111 + !byte $19,%10111001 + !byte $27,%01011000 + !byte $07,%10110111 + !byte $11,%11011001 + !byte $5E,%01100000 + !byte $5E,%10000001; + !byte $24,%00111110 + !byte $1A,%00111110 + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $60,%01100000 + !byte $60,%10000001; + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $0F,%00101010 + !byte $07,%00011000 + !byte $09,%10111001 + !byte $35,%10111001 + !byte $20,%00001110 + !byte $19,%11011001 + !byte $16,%11101001 + !byte $2F,%00101010 + !byte $25,%11011001 + !byte $28,%11101001 + !byte $37,%00011000 + !byte $19,%01011010 + !byte $19,%00011010 + !byte $25,%11111001 + !byte $25,%00011010 + !byte $25,%00111010 + !byte $19,%00111010 + !byte $19,%11111001 + !byte $07,%01110110 + !byte $07,%10010111; + !byte $1E,%00001110 + !byte $25,%01011010 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $37,%01110110 + !byte $37,%10010111; + !byte $10,%00101110 + !byte $25,%01111010 + !byte $25,%10011011; + !byte $19,%01111010 + !byte $19,%10011011; + !byte $19,%01101010 + !byte $19,%10001011; + !byte $12,%10101001 + !byte $36,%01111000 + !byte $36,%10011001; + !byte $2E,%00101110 + !byte $34,%01110100 + !byte $34,%10010101; + !byte $08,%01111000 + !byte $08,%10011001; + !byte $2C,%10101001 + !byte $19,%10111011 + !byte $15,%11001001 + !byte $0A,%01110100 + !byte $0A,%10010101; + !byte $13,%10101001 + !byte $2B,%10101001 + !byte $25,%10111011 + !byte $62,%00100000 + !byte $5C,%00100000 + !byte $27,%00001010 + !byte $29,%11001001 + !byte $17,%00001010 + !byte $0A,%11011001 + !byte $2E,%11001001 + !byte $19,%11011011 + !byte $34,%11011001 + !byte $25,%11011011 + !byte $37,%00111000 + !byte $07,%00111000 + !byte $10,%11001001 + !byte $2F,%11010011 + !byte $22,%01001100 + !byte $2F,%00001010 + !byte $0F,%00001010 + !byte $37,%01010110 + !byte $07,%01010110 + !byte $11,%10101001 + !byte $1C,%01001100 + !byte $2D,%10101001 + !byte $25,%11111011 + !byte $19,%11111011 + !byte $0F,%11010011 + !byte $0F,%10101101 + !byte $24,%01011110 + !byte $08,%11110101 + !byte $2F,%10101101 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $1A,%01011110 + !byte $5F,%10100001 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $23,%11111111 + !byte $1B,%11111111 + !byte $2A,%10101001 + !byte $36,%11110101 + !byte $61,%01100000 + !byte $61,%10000001; + !byte $14,%10101001 + !byte $19,%00011100 + !byte $0D,%11111001 + !byte $31,%11111001 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $35,%10110101 + !byte $25,%00011100 + !byte $0E,%11111001 + !byte $60,%10100001 + !byte $14,%10111001 + !byte $18,%00101010 + !byte $5E,%10100001 + !byte $09,%10110101 + !byte $30,%11111001 + !byte $07,%01011000 + !byte $1F,%00101110 + !byte $37,%01011000 + !byte $2A,%10111001 + !byte $32,%11111001 + !byte $0C,%11111001 + !byte $0F,%11101001 + !byte $2F,%11101001 + !byte $12,%11011001 + !byte $26,%00101010 + !byte $2C,%11011001 + !byte $2C,%01110010 + !byte $2C,%10010011; + !byte $19,%00111100 + !byte $36,%10111001 + !byte $26,%01011000 + !byte $18,%01011000 + !byte $25,%00111100 + !byte $37,%00110110 + !byte $5C,%01000000 + !byte $62,%01000000 + !byte $08,%10111001 + !byte $07,%00110110 + !byte $12,%01110010 + !byte $12,%10010011; + !byte $2E,%10101001 + !byte $2F,%11111001 + !byte $10,%10101001 + !byte $35,%11011001 + !byte $0F,%11111001 + !byte $09,%11011001 + !byte $11,%11001111 + !byte $1A,%01111110 + !byte $1A,%10011111; + !byte $2D,%11001111 + !byte $24,%01111110 + !byte $24,%10011111; + !byte $12,%01101000 + !byte $12,%10001001; + !byte $2F,%11001101 + !byte $0B,%11111001 + !byte $2C,%01101000 + !byte $2C,%10001001; + !byte $33,%11111001 + !byte $0F,%11001101 + !byte $10,%01001110 + !byte $21,%10101101 + !byte $25,%01011100 + !byte $1D,%10101101 + !byte $2E,%01001110 + !byte $5B,%00000000 + !byte $19,%01011100 + !byte $14,%11110001 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $16,%01111000 + !byte $16,%10011001; + !byte $13,%01101000 + !byte $13,%10001001; + !byte $28,%01111000 + !byte $28,%10011001; + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $2A,%11110001 + !byte $07,%01111000 + !byte $07,%10011001; + !byte $63,%00000000 + !byte $37,%01111000 + !byte $37,%10011001; + !byte $38,%11110111 + !byte $06,%11110111 + !byte $06,%11010111 + !byte $0E,%10101011 + !byte $2F,%11001001 + !byte $30,%10101011 + !byte $38,%11010111 + !byte $0F,%11001001 + !byte $61,%10100001 + !byte $5F,%11000001 + !byte $0E,%01101010 + !byte $0E,%10001011; + !byte $30,%01101010 + !byte $30,%10001011; + !byte $30,%11001011 + !byte $5D,%10100001 + !byte $10,%10110011 + !byte $0E,%11001011 + !byte $33,%00110100 + !byte $16,%11001001 + !byte $0C,%00010100 + !byte $06,%00011000 + !byte $2E,%10110011 + !byte $0B,%00110100 + !byte $38,%00011000 + !byte $15,%10101001 + !byte $38,%10110111 + !byte $06,%10110111 + !byte $0E,%01001010 + !byte $30,%01001010 + !byte $28,%11001001 + !byte $0E,%11101011 + !byte $30,%11101011 + !byte $25,%01111100 + !byte $25,%10011101; + !byte $29,%10101001 + !byte $60,%11000001 + !byte $19,%01111100 + !byte $19,%10011101; + !byte $34,%11111001 + !byte $5E,%11000001 + !byte $07,%00010110 + !byte $12,%00110000 + !byte $2E,%11111001 + !byte $0A,%11111001 + !byte $36,%11010101 + !byte $10,%11111001 + !byte $24,%10101011 + !byte $2C,%00110000 + !byte $32,%00010100 + !byte $1A,%10101011 + !byte $08,%11010101 + !byte $37,%00010110 + !byte $06,%00111000 + !byte $0E,%00101010 + !byte $1B,%11101011 + !byte $38,%00111000 + !byte $5C,%01100000 + !byte $5C,%10000001; + !byte $30,%00101010 + !byte $0E,%00001100 + !byte $06,%01110110 + !byte $06,%10010111; + !byte $10,%01101000 + !byte $10,%10001001; + !byte $38,%01110110 + !byte $38,%10010111; + !byte $1A,%10111111 + !byte $27,%11101001 + !byte $34,%01010100 + !byte $14,%00110010 + !byte $2E,%01101000 + !byte $2E,%10001001; + !byte $30,%00001100 + !byte $2A,%00110010 + !byte $62,%01100000 + !byte $62,%10000001; + !byte $0A,%01010100 + !byte $14,%01101000 + !byte $14,%10001001; + !byte $17,%11101001 + !byte $24,%10111111 + !byte $36,%11011001 + !byte $25,%10111101 + !byte $25,%01001010 + !byte $31,%11110011 + !byte $19,%01001010 + !byte $2A,%01101000 + !byte $2A,%10001001; + !byte $08,%11011001 + !byte $23,%11101011 + !byte $19,%10111101 + !byte $2F,%11101101 + !byte $0D,%11110011 + !byte $0F,%10101001 + !byte $2F,%10101001 + !byte $5B,%00100000 + !byte $13,%01010010 + !byte $20,%11101101 + !byte $30,%00001010 + !byte $0E,%00001010 + !byte $1E,%11101101 + !byte $07,%10111001 + !byte $2B,%01010010 + !byte $37,%10111001 + !byte $63,%00100000 + !byte $06,%01011000 + !byte $0F,%11101101 + !byte $30,%00101100 + !byte $38,%01011000 + !byte $06,%01010110 + !byte $12,%01001000 + !byte $2C,%01001000 + !byte $35,%01110100 + !byte $35,%10010101; + !byte $0E,%00101100 + !byte $09,%01110100 + !byte $09,%10010101; + !byte $11,%01001000 + !byte $5F,%11100001 + !byte $2D,%01001000 + !byte $38,%01010110 + !byte $5D,%11000001 + !byte $35,%11111001 + !byte $19,%11011101 + !byte $61,%11000001 + !byte $09,%11111001 + !byte $25,%11011101 + !byte $0E,%11101001 + !byte $2A,%00010010 + !byte $30,%11101001 + !byte $13,%11011001 + !byte $14,%00010010 + !byte $22,%00101100 + !byte $2B,%11011001 + !byte $60,%11100001 + !byte $24,%11011111 + !byte $13,%01001000 + !byte $1A,%11011111 + !byte $26,%00001010 + !byte $37,%11110101 + !byte $5E,%11100001 + !byte $1C,%00101100 + !byte $2B,%01001000 + !byte $07,%11110101 + !byte $18,%00001010 + !byte $10,%01101110 + !byte $10,%10001111; + !byte $2E,%01101110 + !byte $2E,%10001111; + !byte $30,%11010011 + !byte $0E,%11010011 + !byte $10,%01001000 + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $2E,%01001000 + !byte $38,%01111000 + !byte $38,%10011001; + !byte $11,%11111001 + !byte $06,%01111000 + !byte $06,%10011001; + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $0E,%01001100 + !byte $62,%10100001 + !byte $30,%01001100 + !byte $5C,%10100001 + !byte $2D,%11111001 + !byte $32,%00011010 + !byte $0C,%00011010 + !byte $15,%10111001 + !byte $0D,%00011010 + !byte $31,%00011010 + !byte $30,%11001001 + !byte $11,%11101111 + !byte $5B,%01000000 + !byte $13,%10110001 + !byte $63,%01000000 + !byte $0E,%11001001 + !byte $29,%10111001 + !byte $1F,%00001110 + !byte $19,%11111101 + !byte $2B,%10110001 + !byte $2D,%11101111 + !byte $06,%00110110 + !byte $0B,%00011010 + !byte $33,%00011010 + !byte $38,%00110110 + !byte $25,%11111101 + !byte $36,%10110101 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $08,%10110101 + !byte $26,%01111000 + !byte $26,%10011001; + !byte $18,%01111000 + !byte $18,%10011001; + !byte $37,%11011001 + !byte $07,%11011001 + !byte $05,%11110111 + !byte $16,%10101001 + !byte $39,%11110111 + !byte $0E,%00011010 + !byte $30,%00011010 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $29,%01101000 + !byte $29,%10001001; + !byte $05,%00011000 + !byte $39,%00011000 + !byte $36,%11111001 + !byte $08,%11111001 + !byte $15,%01101000 + !byte $15,%10001001; + !byte $0F,%00001110 + !byte $05,%11010111 + !byte $39,%11010111 + !byte $27,%01111000 + !byte $27,%10011001; + !byte $5D,%11100001 + !byte $17,%01111000 + !byte $17,%10011001; + !byte $2F,%00001110 + !byte $61,%11100001 + !byte $1A,%11111111 + !byte $28,%10101001 + !byte $5F,%00000010 + !byte $39,%00111000 + !byte $0A,%00011010 + !byte $34,%00011010 + !byte $05,%00111000 + !byte $14,%01001000 + !byte $24,%11111111 + !byte $38,%10111001 + !byte $25,%00011110 + !byte $19,%00011110 + !byte $30,%10101001 + !byte $11,%00101000 + !byte $2D,%00101000 + !byte $0E,%10101001 + !byte $2A,%01001000 + !byte $06,%10111001 + !byte $05,%10110111 + !byte $12,%00101000 + !byte $2C,%00101000 + !byte $39,%10110111 + !byte $0E,%01101100 + !byte $0E,%10001101; + !byte $2F,%01001000 + !byte $0F,%01001000 + !byte $30,%01101100 + !byte $30,%10001101; + !byte $60,%00000010 + !byte $5E,%00000010 + !byte $21,%01101100 + !byte $21,%10001101; + !byte $62,%11000001 + !byte $5C,%11000001 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $05,%01011000 + !byte $27,%11001001 + !byte $10,%00101000 + !byte $39,%01011000 + !byte $2E,%00101000 + !byte $0F,%00011010 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $1A,%01101010 + !byte $1A,%10001011; + !byte $17,%11001001 + !byte $2F,%00011010 + !byte $0F,%10110011 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $06,%00010110 + !byte $07,%11010101 + !byte $39,%01110110 + !byte $39,%10010111; + !byte $37,%11010101 + !byte $05,%01110110 + !byte $05,%10010111; + !byte $38,%00010110 + !byte $09,%00011010 + !byte $35,%00011010 + !byte $2B,%00101000 + !byte $25,%00111110 + !byte $13,%00101000 + !byte $0E,%01101000 + !byte $0E,%10001001; + !byte $2F,%10110011 + !byte $24,%01101010 + !byte $24,%10001011; + !byte $34,%00110100 + !byte $12,%01010000 + !byte $0A,%00110100 + !byte $0D,%01001010 + !byte $19,%00111110 + !byte $30,%01101000 + !byte $30,%10001001; + !byte $31,%01001010 + !byte $33,%00010100 + !byte $64,%00000000 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $2C,%01010000 + !byte $25,%00101010 + !byte $31,%00101010 + !byte $5A,%00000000 + !byte $0B,%00010100 + !byte $0D,%00101010 + !byte $23,%11001011 + !byte $07,%11111001 + !byte $19,%00101010 + !byte $05,%01111000 + !byte $05,%10011001; + !byte $37,%11111001 + !byte $0D,%10101011 + !byte $39,%01111000 + !byte $39,%10011001; + !byte $06,%11011001 + !byte $2C,%11111001 + !byte $32,%11110011 + !byte $38,%11011001 + !byte $0D,%00001010 + !byte $1B,%11001011 + !byte $31,%00001010 + !byte $31,%10101011 + !byte $61,%00000010 + !byte $35,%01010100 + !byte $5F,%00100010 + !byte $5D,%00000010 + !byte $0C,%11110011 + !byte $09,%01010100 + !byte $12,%11111001 + !byte $0F,%00101000 + !byte $0E,%10101101 + !byte $20,%11001101 + !byte $2F,%00101000 + !byte $1E,%11001101 + !byte $30,%10101101 + !byte $05,%01010110 + !byte $31,%11001011 + !byte $39,%01010110 + !byte $0D,%11101001 + !byte $0D,%11001011 + !byte $31,%11101001 + !byte $60,%00100010 + !byte $5E,%00100010 + !byte $10,%10101111 + !byte $2E,%10101111 + !byte $5C,%11100001 + !byte $62,%11100001 + !byte $12,%01010010 + !byte $2A,%11011001 + !byte $11,%00001000 + !byte $2D,%00001000 + !byte $2C,%01010010 + !byte $36,%00011010 + !byte $08,%00011010 + !byte $19,%01011110 + !byte $26,%11101001 + !byte $0E,%01001000 + !byte $25,%01011110 + !byte $36,%01110100 + !byte $36,%10010101; + !byte $0F,%00101110 + !byte $5B,%10100001 + !byte $14,%11011001 + !byte $18,%11101001 + !byte $2F,%00101110 + !byte $30,%01001000 + !byte $63,%10100001 + !byte $08,%01110100 + !byte $08,%10010101; + !byte $10,%00011010 + !byte $15,%01001000 + !byte $26,%10111001 + !byte $10,%00001000 + !byte $18,%10111001 + !byte $12,%00001000 + !byte $2C,%00001000 + !byte $0D,%11001001 + !byte $2E,%00001000 + !byte $2E,%00011010 + !byte $31,%11001001 + !byte $39,%10111001 + !byte $29,%01001000 + !byte $05,%10111001 + !byte $0D,%11101011 + !byte $31,%11101011 + !byte $14,%00101000 + !byte $5A,%00100000 + !byte $38,%11110101 + !byte $22,%00001100 + !byte $28,%01101000 + !byte $28,%10001001; + !byte $16,%01101000 + !byte $16,%10001001; + !byte $1C,%00001100 + !byte $2A,%00101000 + !byte $06,%11110101 + !byte $64,%00100000 + !byte $04,%00011000 + !byte $13,%11010001 + !byte $3A,%11110111 + !byte $3A,%00011000 + !byte $04,%11110111 + !byte $2B,%11010001 + !byte $2B,%00110010 + !byte $31,%11010011 + !byte $0B,%00111010 + !byte $13,%00110010 + !byte $33,%00111010 + !byte $04,%00111000 + !byte $0C,%00111010 + !byte $3A,%00111000 + !byte $32,%00111010 + !byte $0D,%11010011 + !byte $0D,%10101001 + !byte $39,%00110110 + !byte $3A,%11010111 + !byte $05,%00110110 + !byte $31,%10101001 + !byte $61,%00100010 + !byte $04,%11010111 + !byte $19,%01111110 + !byte $19,%10011111; + !byte $11,%00010000 + !byte $5D,%00100010 + !byte $16,%10111001 + !byte $1F,%11101101 + !byte $28,%10111001 + !byte $2D,%00010000 + !byte $25,%01111110 + !byte $25,%10011111; + !byte $2F,%00001000 + !byte $34,%00111010 + !byte $5F,%01000010 + !byte $0F,%00001000 + !byte $0A,%00111010 + !byte $06,%11111001 + !byte $0D,%00001100 + !byte $37,%10110101 + !byte $38,%11111001 + !byte $31,%00111010 + !byte $0D,%00111010 + !byte $10,%01110010 + !byte $10,%10010011; + !byte $13,%00001000 + !byte $3A,%01011000 + !byte $04,%01011000 + !byte $07,%10110101 + !byte $2B,%00001000 + !byte $31,%00001100 + !byte $30,%00101000 + !byte $0E,%00101000 + !byte $5E,%01000010 + !byte $07,%00011010 + !byte $30,%11001101 + !byte $3A,%10110111 + !byte $04,%10110111 + !byte $0E,%11001101 + !byte $60,%01000010 + !byte $37,%00011010 + !byte $17,%10101001 + !byte $5B,%11000001 + !byte $2E,%01110010 + !byte $2E,%10010011; + !byte $05,%11011001 + !byte $62,%00000010 + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $5C,%00000010 + !byte $39,%11011001 + !byte $63,%11000001 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $64,%01000000 + !byte $5A,%01000000 + !byte $09,%00111010 + !byte $35,%00111010 + !byte $27,%10101001 + !byte $04,%01111000 + !byte $04,%10011001; + !byte $3A,%01111000 + !byte $3A,%10011001; + !byte $11,%11100111 + !byte $2D,%11100111 + !byte $10,%11100111 + !byte $2E,%11100111 + !byte $19,%10111111 + !byte $25,%10111111 + !byte $18,%11011001 + !byte $3A,%01110110 + !byte $3A,%10010111; + !byte $0E,%00111010 + !byte $30,%00111010 + !byte $04,%01110110 + !byte $04,%10010111; + !byte $26,%11011001 + !byte $31,%00101100 + !byte $0D,%00101100 + !byte $05,%00010110 + !byte $39,%00010110 + !byte $12,%11100111 + !byte $2C,%11100111 + !byte $30,%00001000 + !byte $31,%01001000 + !byte $0E,%00001000 + !byte $25,%00001010 + !byte $24,%01001010 + !byte $11,%00011010 + !byte $0D,%01001000 + !byte $21,%01001100 + !byte $61,%01000010 + !byte $2F,%11100111 + !byte $5D,%01000010 + !byte $1A,%01001010 + !byte $2D,%00011010 + !byte $08,%00111010 + !byte $0F,%11100111 + !byte $19,%00001010 + !byte $36,%00111010 + !byte $2B,%11111001 + !byte $1D,%01001100 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $04,%10111001 + !byte $38,%11010101 + !byte $0F,%01001110 + !byte $2F,%01001110 + !byte $06,%11010101 + !byte $3A,%10111001 + !byte $35,%00110100 + !byte $30,%10110011 + !byte $09,%00110100 + !byte $15,%00101000 + !byte $38,%00011010 + !byte $5B,%11100001 + !byte $13,%11111001 + !byte $0E,%10110011 + !byte $5E,%01100010 + !byte $5E,%10000011; + !byte $2A,%00001000 + !byte $62,%00100010 + !byte $06,%00011010 + !byte $12,%01110000 + !byte $12,%10010001; + !byte $39,%11111001 + !byte $60,%01100010 + !byte $60,%10000011; + !byte $23,%10101011 + !byte $19,%11011111 + !byte $05,%11111001 + !byte $13,%11110001 + !byte $2C,%01110000 + !byte $2C,%10010001; + !byte $5C,%00100010 + !byte $14,%00001000 + !byte $25,%11011111 + !byte $64,%01100000 + !byte $64,%10000001; + !byte $34,%00010100 + !byte $63,%11100001 + !byte $36,%01010100 + !byte $2B,%11110001 + !byte $3A,%01010110 + !byte $10,%11001111 + !byte $17,%10111001 + !byte $29,%00101000 + !byte $08,%01010100 + !byte $5A,%01100000 + !byte $5A,%10000001; + !byte $04,%01010110 + !byte $1B,%10101011 + !byte $27,%10111001 + !byte $18,%11111001 + !byte $0A,%00010100 + !byte $2E,%11001111 + !byte $26,%11111001 + !byte $13,%00010010 + !byte $0E,%11101101 + !byte $2B,%00010010 + !byte $30,%11101101 + !byte $0D,%00101000 + !byte $31,%01001100 + !byte $31,%00101000 + !byte $0C,%00001010 + !byte $26,%11001001 + !byte $28,%01001000 + !byte $32,%00001010 + !byte $33,%11110011 + !byte $0C,%00101010 + !byte $16,%01001000 + !byte $18,%11001001 + !byte $32,%00101010 + !byte $0D,%01001100 + !byte $1E,%10101101 + !byte $03,%00011000 + !byte $13,%11100111 + !byte $32,%11101001 + !byte $0F,%00111010 + !byte $0C,%11101001 + !byte $3B,%00011000 + !byte $2F,%00111010 + !byte $2B,%11100111 + !byte $03,%00111000 + !byte $3B,%11110111 + !byte $3B,%00111000 + !byte $03,%11110111 + !byte $0B,%11110011 + !byte $04,%11011001 + !byte $29,%11011001 + !byte $32,%01001010 + !byte $10,%11000111 + !byte $2E,%11000111 + !byte $37,%00111010 + !byte $0C,%01001010 + !byte $3A,%11011001 + !byte $30,%11100111 + !byte $0C,%11001001 + !byte $20,%10101101 + !byte $32,%11001001 + !byte $07,%00111010 + !byte $0E,%11100111 + !byte $2D,%01010010 + !byte $15,%11011001 + !byte $11,%01010010 + !byte $11,%11000111 + !byte $2D,%11000111 + !byte $3B,%01011000 + !byte $26,%00011010 + !byte $37,%01110100 + !byte $37,%10010101; + !byte $18,%00011010 + !byte $03,%01011000 + !byte $25,%11111111 + !byte $0C,%01101010 + !byte $0C,%10001011; + !byte $07,%01110100 + !byte $07,%10010101; + !byte $32,%01101010 + !byte $32,%10001011; + !byte $3B,%11010111 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $19,%11111111 + !byte $03,%11010111 + !byte $05,%11110101 + !byte $0C,%10101001 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $0F,%11000111 + !byte $5F,%10100011 + !byte $2F,%11000111 + !byte $32,%10101001 + !byte $26,%00111010 + !byte $18,%00111010 + !byte $39,%11110101 + !byte $31,%00001000 + !byte $22,%11101011 + !byte $18,%11011011 + !byte $3A,%00110110 + !byte $26,%01011010 + !byte $26,%11011011 + !byte $03,%01111000 + !byte $03,%10011001; + !byte $0D,%00001000 + !byte $3B,%01111000 + !byte $3B,%10011001; + !byte $18,%10111011 + !byte $18,%01011010 + !byte $64,%10100001 + !byte $5C,%01000010 + !byte $5B,%00000010 + !byte $0B,%01011010 + !byte $5A,%10100001 + !byte $18,%11111011 + !byte $18,%01111010 + !byte $18,%10011011; + !byte $0A,%01011010 + !byte $26,%01111010 + !byte $26,%10011011; + !byte $34,%01011010 + !byte $33,%01011010 + !byte $26,%10111011 + !byte $26,%11111011 + !byte $04,%00110110 + !byte $5E,%10100011 + !byte $26,%00011100 + !byte $18,%00011100 + !byte $12,%11000111 + !byte $1C,%11101011 + !byte $2C,%11000111 + !byte $0C,%10101011 + !byte $60,%10100011 + !byte $63,%00000010 + !byte $32,%10101011 + !byte $62,%01000010 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $03,%10110111 + !byte $32,%11010011 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $1F,%11001101 + !byte $32,%01101000 + !byte $32,%10001001; + !byte $3B,%10110111 + !byte $26,%00111100 + !byte $18,%00111100 + !byte $0C,%01101000 + !byte $0C,%10001001; + !byte $05,%00011010 + !byte $09,%01011010 + !byte $35,%01011010 + !byte $0C,%11010011 + !byte $39,%00011010 + !byte $0C,%01011010 + !byte $32,%01011010 + !byte $18,%01011100 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $2D,%00110000 + !byte $26,%01011100 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $38,%10110101 + !byte $65,%00000000 + !byte $59,%00000000 + !byte $06,%10110101 + !byte $3A,%11111001 + !byte $03,%10111001 + !byte $06,%00111010 + !byte $18,%01111100 + !byte $18,%10011101; + !byte $04,%11111001 + !byte $3B,%10111001 + !byte $38,%00111010 + !byte $26,%01111100 + !byte $26,%10011101; + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $11,%00110000 + !byte $30,%11000111 + !byte $0E,%11000111 + !byte $32,%01001000 + !byte $0C,%11001011 + !byte $0C,%01001000 + !byte $32,%11001011 + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $2C,%00110010 + !byte $08,%01011010 + !byte $36,%01011010 + !byte $3B,%01110110 + !byte $3B,%10010111; + !byte $03,%01110110 + !byte $03,%10010111; + !byte $12,%00110010 + !byte $0D,%11100111 + !byte $26,%10111101 + !byte $18,%10111101 + !byte $12,%00011010 + !byte $31,%11100111 + !byte $31,%01011010 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $2A,%11100111 + !byte $61,%10100011 + !byte $5D,%10100011 + !byte $2C,%00011010 + !byte $10,%00111010 + !byte $0D,%01011010 + !byte $10,%10100111 + !byte $2E,%10100111 + !byte $2E,%00111010 + !byte $5A,%11000001 + !byte $14,%11100111 + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $15,%00001000 + !byte $29,%00001000 + !byte $5F,%11000011 + !byte $0E,%00001110 + !byte $64,%11000001 + !byte $2F,%10100111 + !byte $0F,%10100111 + !byte $11,%10100111 + !byte $2D,%10100111 + !byte $30,%00001110 + !byte $26,%11011101 + !byte $63,%00100010 + !byte $3A,%00010110 + !byte $5B,%00100010 + !byte $18,%11011101 + !byte $62,%01100010 + !byte $62,%10000011; + !byte $3B,%11011001 + !byte $0C,%00101000 + !byte $5C,%01100010 + !byte $5C,%10000011; + !byte $13,%11000111 + !byte $24,%00101010 + !byte $32,%00101000 + !byte $04,%00010110 + !byte $2B,%11000111 + !byte $5E,%11000011 + !byte $03,%11011001 + !byte $1A,%00101010 + !byte $60,%11000011 + !byte $59,%00100000 + !byte $37,%01011010 + !byte $0C,%11101011 + !byte $07,%01011010 + !byte $32,%11101011 + !byte $25,%11101001 + !byte $31,%10110011 + !byte $14,%11111001 + !byte $39,%11010101 + !byte $65,%00100000 + !byte $1D,%00101100 + !byte $05,%11010101 + !byte $2A,%11111001 + !byte $0D,%10110011 + !byte $19,%11101001 + !byte $26,%11111101 + !byte $16,%00101000 + !byte $18,%11111101 + !byte $39,%00111010 + !byte $05,%00111010 + !byte $02,%00111000 + !byte $03,%01010110 + !byte $3C,%00011000 + !byte $3C,%00111000 + !byte $02,%00011000 + !byte $30,%10100111 + !byte $04,%00011010 + !byte $28,%00101000 + !byte $3B,%01010110 + !byte $26,%10101001 + !byte $3A,%00011010 + !byte $0E,%10100111 + !byte $21,%00101100 + !byte $08,%00110100 + !byte $12,%10110001 + !byte $3C,%01011000 + !byte $0D,%11000111 + !byte $02,%01011000 + !byte $18,%10101001 + !byte $31,%11000111 + !byte $32,%00001000 + !byte $0D,%10101101 + !byte $0C,%00001000 + !byte $3C,%11110111 + !byte $31,%10101101 + !byte $2C,%10110001 + !byte $2E,%11101111 + !byte $2C,%10100111 + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $02,%11110111 + !byte $12,%10100111 + !byte $30,%01011010 + !byte $18,%00011110 + !byte $16,%11011001 + !byte $28,%11011001 + !byte $26,%00011110 + !byte $5A,%11100001 + !byte $0E,%01011010 + !byte $36,%00110100 + !byte $35,%00010100 + !byte $02,%01111000 + !byte $02,%10011001; + !byte $09,%00010100 + !byte $3C,%01111000 + !byte $3C,%10011001; + !byte $64,%11100001 + !byte $10,%11101111 + !byte $61,%11000011 + !byte $37,%01010100 + !byte $3C,%11010111 + !byte $02,%11010111 + !byte $07,%01010100 + !byte $3B,%11111001 + !byte $17,%11011001 + !byte $27,%11011001 + !byte $5D,%11000011 + !byte $03,%11111001 + !byte $65,%01000000 + !byte $06,%01011010 + !byte $63,%01000010 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $5F,%11100011 + !byte $32,%00001100 + !byte $5B,%01000010 + !byte $59,%01000000 + !byte $0C,%00001100 + !byte $38,%01011010 + !byte $1E,%01101100 + !byte $1E,%10001101; + !byte $5C,%10100011 + !byte $62,%10100011 + !byte $10,%01100110 + !byte $10,%10000111; + !byte $18,%00111110 + !byte $2E,%01100110 + !byte $2E,%10000111; + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $02,%10111001 + !byte $10,%01010010 + !byte $20,%01101100 + !byte $20,%10001101; + !byte $26,%00111110 + !byte $34,%11110011 + !byte $5E,%11100011 + !byte $0C,%11100111 + !byte $3C,%10111001 + !byte $60,%11100011 + !byte $32,%11100111 + !byte $2E,%01010010 + !byte $3A,%11110101 + !byte $0A,%11110011 + !byte $38,%01110100 + !byte $38,%10010101; + !byte $06,%01110100 + !byte $06,%10010101; + !byte $0B,%11101001 + !byte $33,%11001001 + !byte $33,%11101001 + !byte $0B,%11001001 + !byte $04,%11110101 + !byte $31,%10100111 + !byte $02,%10110111 + !byte $0D,%10100111 + !byte $11,%01100110 + !byte $11,%10000111; + !byte $27,%01001000 + !byte $3B,%00110110 + !byte $3C,%10110111 + !byte $33,%10101001 + !byte $03,%00110110 + !byte $0B,%10101001 + !byte $17,%01001000 + !byte $0B,%00001010 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $33,%00001010 + !byte $0A,%01111010 + !byte $0A,%10011011; + !byte $09,%01111010 + !byte $09,%10011011; + !byte $34,%01111010 + !byte $34,%10011011; + !byte $35,%01111010 + !byte $35,%10011011; + !byte $26,%01011110 + !byte $0E,%01100110 + !byte $0E,%10000111; + !byte $30,%01100110 + !byte $30,%10000111; + !byte $5A,%00000010 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $33,%01101000 + !byte $33,%10001001; + !byte $04,%00111010 + !byte $33,%00101010 + !byte $3A,%00111010 + !byte $64,%00000010 + !byte $18,%01011110 + !byte $0B,%00101010 + !byte $1F,%10101101 + !byte $2A,%11000111 + !byte $0B,%01111010 + !byte $0B,%10011011; + !byte $11,%00111010 + !byte $14,%11000111 + !byte $30,%00101110 + !byte $33,%01111010 + !byte $33,%10011011; + !byte $59,%01100000 + !byte $59,%10000001; + !byte $22,%11001011 + !byte $3C,%11011001 + !byte $2D,%00111010 + !byte $08,%01111010 + !byte $08,%10011011; + !byte $13,%10100111 + !byte $02,%11011001 + !byte $15,%11100111 + !byte $0B,%11010011 + !byte $36,%01111010 + !byte $36,%10011011; + !byte $03,%00011010 + !byte $0B,%01001000 + !byte $1C,%11001011 + !byte $2B,%10100111 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $3B,%00011010 + !byte $33,%01001000 + !byte $32,%11000111 + !byte $0E,%00101110 + !byte $0C,%00101100 + !byte $39,%01011010 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $05,%01011010 + !byte $29,%11100111 + !byte $5D,%11100011 + !byte $0B,%01001010 + !byte $05,%10110101 + !byte $61,%11100011 + !byte $0F,%01011010 + !byte $32,%00101100 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $0C,%11000111 + !byte $33,%01001010 + !byte $33,%11010011 + !byte $3C,%01110110 + !byte $3C,%10010111; + !byte $02,%01110110 + !byte $02,%10010111; + !byte $2F,%01011010 + !byte $0E,%01110010 + !byte $0E,%10010011; + !byte $0D,%11001101 + !byte $11,%01010000 + !byte $5F,%00000100 + !byte $31,%11001101 + !byte $18,%01111110 + !byte $18,%10011111; + !byte $26,%01111110 + !byte $26,%10011111; + !byte $12,%00010010 + !byte $2D,%01010000 + !byte $2C,%00010010 + !byte $62,%11000011 + !byte $33,%00101000 + !byte $30,%01110010 + !byte $30,%10010011; + !byte $5C,%11000011 + !byte $0C,%01111010 + !byte $0C,%10011011; + !byte $07,%01111010 + !byte $07,%10011011; + !byte $37,%01111010 + !byte $37,%10011011; + !byte $32,%01111010 + !byte $32,%10011011; + !byte $0B,%00101000 + !byte $13,%00011010 + !byte $39,%10110101 + !byte $2F,%10101111 + !byte $0F,%10101111 + !byte $2C,%01100110 + !byte $2C,%10000111; + !byte $12,%01100110 + !byte $12,%10000111; + !byte $2B,%00011010 + !byte $5E,%00000100 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $31,%01100110 + !byte $31,%10000111; + !byte $60,%00000100 + !byte $12,%11010001 + !byte $0F,%01000110 + !byte $2F,%01000110 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $02,%11111001 + !byte $3C,%11111001 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $28,%00001000 + !byte $01,%00111000 + !byte $16,%00001000 + !byte $3D,%00111000 + !byte $10,%01000110 + !byte $2C,%11010001 + !byte $03,%00010110 + !byte $3D,%01011000 + !byte $2E,%01000110 + !byte $01,%01011000 + !byte $65,%10100001 + !byte $3D,%00011000 + !byte $64,%00100010 + !byte $18,%10111111 + !byte $5A,%00100010 + !byte $01,%00011000 + !byte $32,%10100111 + !byte $59,%10100001 + !byte $26,%10111111 + !byte $0B,%00001000 + !byte $25,%11001001 + !byte $11,%00110010 + !byte $33,%00001000 + !byte $19,%11001001 + !byte $30,%01000110 + !byte $0C,%10100111 + !byte $3B,%00010110 + !byte $1A,%00001010 + !byte $01,%01111000 + !byte $01,%10011001; + !byte $0E,%01000110 + !byte $3D,%01111000 + !byte $3D,%10011001; + !byte $2D,%00110010 + !byte $3D,%11110111 + !byte $38,%01111010 + !byte $38,%10011011; + !byte $01,%11110111 + !byte $15,%11111001 + !byte $06,%01111010 + !byte $06,%10011011; + !byte $18,%01101000 + !byte $18,%10001001; + !byte $3A,%11010101 + !byte $29,%11111001 + !byte $3C,%01010110 + !byte $04,%11010101 + !byte $03,%00111010 + !byte $5B,%10100011 + !byte $2D,%01000110 + !byte $02,%01010110 + !byte $11,%01000110 + !byte $33,%10101011 + !byte $3B,%00111010 + !byte $04,%01011010 + !byte $24,%00001010 + !byte $5D,%00000100 + !byte $3A,%01011010 + !byte $61,%00000100 + !byte $17,%11111001 + !byte $01,%10111001 + !byte $3D,%10111001 + !byte $26,%01101000 + !byte $26,%10001001; + !byte $0B,%10101011 + !byte $33,%11100111 + !byte $0D,%01111010 + !byte $0D,%10011011; + !byte $0B,%11100111 + !byte $27,%11111001 + !byte $21,%00001100 + !byte $32,%10110011 + !byte $63,%10100011 + !byte $18,%11011111 + !byte $01,%11010111 + !byte $31,%01111010 + !byte $31,%10011011; + !byte $26,%11011111 + !byte $62,%11100011 + !byte $5C,%11100011 + !byte $1D,%00001100 + !byte $0C,%01001100 + !byte $5F,%00100100 + !byte $0C,%10110011 + !byte $3D,%11010111 + !byte $02,%00011010 + !byte $32,%01001100 + !byte $3C,%00011010 + !byte $2C,%11110001 + !byte $12,%11110001 + !byte $0D,%01000110 + !byte $1B,%01001010 + !byte $31,%01000110 + !byte $10,%00010000 + !byte $37,%00110100 + !byte $5E,%00100100 + !byte $59,%11000001 + !byte $32,%01100110 + !byte $32,%10000111; + !byte $0C,%01100110 + !byte $0C,%10000111; + !byte $2E,%00010000 + !byte $60,%00100100 + !byte $36,%00010100 + !byte $5A,%01000010 + !byte $14,%10100111 + !byte $3D,%11011001 + !byte $01,%11011001 + !byte $07,%00110100 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $64,%01000010 + !byte $65,%11000001 + !byte $27,%00101000 + !byte $05,%01111010 + !byte $05,%10011011; + !byte $08,%00010100 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $39,%01111010 + !byte $39,%10011011; + !byte $0B,%11000111 + !byte $17,%00101000 + !byte $33,%11000111 + !byte $2A,%10100111 + !byte $33,%11001011 + !byte $26,%11111111 + !byte $23,%01001010 + !byte $1E,%01001100 + !byte $09,%11110011 + !byte $0F,%00100110 + !byte $2F,%00100110 + !byte $3D,%10110111 + !byte $38,%01010100 + !byte $01,%10110111 + !byte $31,%11101101 + !byte $18,%11111111 + !byte $29,%11000111 + !byte $30,%01001110 + !byte $06,%01010100 + !byte $0B,%11001011 + !byte $2F,%01010010 + !byte $20,%01001100 + !byte $2C,%01000110 + !byte $03,%11110101 + !byte $15,%11000111 + !byte $10,%01011010 + !byte $02,%00110110 + !byte $30,%00100110 + !byte $2E,%00100110 + !byte $2E,%01011010 + !byte $0F,%01010010 + !byte $0E,%00100110 + !byte $10,%00100110 + !byte $12,%01000110 + !byte $3C,%00110110 + !byte $0D,%11101101 + !byte $09,%10111011 + !byte $35,%10111011 + !byte $63,%11000011 + !byte $12,%00111010 + !byte $5B,%11000011 + !byte $08,%10111011 + !byte $36,%10111011 + !byte $01,%11111001 + !byte $2C,%00111010 + !byte $0E,%01001110 + !byte $3B,%11110101 + !byte $61,%00100100 + !byte $35,%11110011 + !byte $39,%01110100 + !byte $39,%10010101; + !byte $5D,%00100100 + !byte $3D,%11111001 + !byte $03,%01011010 + !byte $3B,%01011010 + !byte $59,%11100001 + !byte $65,%11100001 + !byte $05,%01110100 + !byte $05,%10010101; + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $3C,%00111010 + !byte $34,%10111011 + !byte $0A,%10111011 + !byte $02,%00111010 + !byte $5F,%01000100 + !byte $33,%10100111 + !byte $62,%00000100 + !byte $0B,%10100111 + !byte $32,%01000110 + !byte $30,%01111010 + !byte $30,%10011011; + !byte $58,%00000000 + !byte $66,%00000000 + !byte $5C,%00000100 + !byte $0E,%01111010 + !byte $0E,%10011011; + !byte $0C,%01000110 + !byte $37,%10111011 + !byte $07,%10111011 + !byte $31,%00100110 + !byte $0C,%01101100 + !byte $0C,%10001101; + !byte $0A,%10101001 + !byte $0D,%00100110 + !byte $34,%01101000 + !byte $34,%10001001; + !byte $34,%10101001 + !byte $3D,%01110110 + !byte $3D,%10010111; + !byte $0A,%01101000 + !byte $0A,%10001001; + !byte $3A,%01111010 + !byte $3A,%10011011; + !byte $28,%11111001 + !byte $5A,%01100010 + !byte $5A,%10000011; + !byte $60,%01000100 + !byte $16,%11111001 + !byte $04,%01111010 + !byte $04,%10011011; + !byte $01,%01110110 + !byte $01,%10010111; + !byte $32,%01101100 + !byte $32,%10001101; + !byte $0A,%11001001 + !byte $5E,%01000100 + !byte $0A,%01001000 + !byte $34,%01001000 + !byte $34,%11001001 + !byte $64,%01100010 + !byte $64,%10000011; + !byte $2D,%00100110 + !byte $00,%01011000 + !byte $3E,%00111000 + !byte $3E,%01011000 + !byte $0B,%11101011 + !byte $00,%00111000 + !byte $11,%00100110 + !byte $16,%11100111 + !byte $3A,%10110101 + !byte $33,%11101011 + !byte $22,%10101011 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $1C,%10101011 + !byte $17,%00011010 + !byte $00,%01111000 + !byte $00,%10011001; + !byte $0A,%11101001 + !byte $3E,%01111000 + !byte $3E,%10011001; + !byte $27,%00011010 + !byte $04,%10110101 + !byte $0B,%10111011 + !byte $00,%00011000 + !byte $0A,%00101000 + !byte $34,%11101001 + !byte $34,%00101000 + !byte $3E,%00011000 + !byte $33,%10111011 + !byte $0A,%11010011 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $11,%01110000 + !byte $11,%10010001; + !byte $28,%11100111 + !byte $38,%10111011 + !byte $06,%10111011 + !byte $34,%11010011 + !byte $0F,%11001111 + !byte $01,%00011010 + !byte $00,%10111001 + !byte $14,%00011010 + !byte $31,%01110010 + !byte $31,%10010011; + !byte $3D,%00011010 + !byte $0A,%00001000 + !byte $2F,%11001111 + !byte $2A,%00011010 + !byte $0A,%00001010 + !byte $33,%01100110 + !byte $33,%10000111; + !byte $34,%00001000 + !byte $3E,%10111001 + !byte $58,%00100000 + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $34,%00001010 + !byte $00,%11110111 + !byte $63,%11100011 + !byte $66,%00100000 + !byte $25,%10101001 + !byte $5B,%11100011 + !byte $0F,%00000110 + !byte $2F,%00000110 + !byte $3E,%11110111 + !byte $30,%00000110 + !byte $3C,%00010110 + !byte $19,%10101001 + !byte $0E,%00000110 + !byte $65,%00000010 + !byte $02,%00010110 + !byte $5D,%01000100 + !byte $59,%00000010 + !byte $61,%01000100 + !byte $32,%00100110 + !byte $0C,%00100110 + !byte $1A,%11101001 + !byte $5C,%00100100 + !byte $34,%11100111 + !byte $3E,%11011001 + !byte $00,%11011001 + !byte $0A,%11100111 + !byte $13,%01000110 + !byte $01,%01010110 + !byte $0A,%00101010 + !byte $34,%00101010 + !byte $62,%00100100 + !byte $02,%01011010 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $2E,%00000110 + !byte $39,%10111011 + !byte $10,%00000110 + !byte $26,%01001000 + !byte $3D,%01010110 + !byte $18,%01001000 + !byte $2E,%00110010 + !byte $0C,%10111011 + !byte $2B,%01000110 + !byte $3C,%01011010 + !byte $5A,%10100011 + !byte $05,%10111011 + !byte $03,%11010101 + !byte $32,%10111011 + !byte $10,%00110010 + !byte $2A,%01100110 + !byte $2A,%10000111; + !byte $31,%00000110 + !byte $3E,%11010111 + !byte $14,%01100110 + !byte $14,%10000111; + !byte $64,%10100011 + !byte $00,%11010111 + !byte $0D,%00000110 + !byte $24,%11101001 + !byte $03,%01111010 + !byte $03,%10011011; + !byte $5E,%01100100 + !byte $5E,%10000101; + !byte $60,%01100100 + !byte $60,%10000101; + !byte $3B,%01111010 + !byte $3B,%10011011; + !byte $33,%01000110 + !byte $33,%00001100 + !byte $2C,%00100110 + !byte $0B,%01000110 + !byte $34,%11000111 + !byte $58,%01000000 + !byte $0A,%11000111 + !byte $12,%00100110 + !byte $3D,%00111010 + !byte $66,%01000000 + !byte $3B,%11010101 + !byte $2D,%00010010 + !byte $01,%00111010 + !byte $11,%00010010 + !byte $1D,%11101011 + !byte $0B,%00001100 + !byte $00,%11111001 + !byte $27,%00111010 + !byte $3E,%11111001 + !byte $17,%00111010 + !byte $0D,%00001110 + !byte $15,%10100111 + !byte $17,%00001000 + !byte $2F,%01111010 + !byte $2F,%10011011; + !byte $31,%00001110 + !byte $34,%01001010 + !byte $0A,%01001010 + !byte $33,%10110011 + !byte $0B,%10110011 + !byte $63,%00000100 + !byte $0F,%01111010 + !byte $0F,%10011011; + !byte $23,%00101010 + !byte $38,%00110100 + !byte $5B,%00000100 + !byte $11,%01011010 + !byte $0C,%10101101 + !byte $59,%00100010 + !byte $29,%10100111 + !byte $11,%00000110 + !byte $06,%00110100 + !byte $1B,%00101010 + !byte $21,%11101011 + !byte $2D,%01011010 + !byte $65,%00100010 + !byte $3E,%10110111 + !byte $04,%10111011 + !byte $27,%00001000 + !byte $00,%10110111 + !byte $0A,%10100111 + !byte $32,%10101101 + !byte $2D,%00000110 + !byte $34,%10100111 + !byte $3A,%10111011 + !byte $32,%00000110 + !byte $0C,%00000110 + !byte $10,%00110000 + !byte $39,%01010100 + !byte $37,%00010100 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $61,%01100100 + !byte $61,%10000101; + !byte $2E,%00110000 + !byte $07,%00010100 + !byte $05,%01010100 + !byte $1E,%00101100 + !byte $0E,%11100101 + !byte $30,%11100101 + !byte $3E,%00011010 + !byte $33,%00100110 + !byte $3D,%00110110 + !byte $62,%01000100 + !byte $5A,%11000011 + !byte $58,%01100000 + !byte $58,%10000001; + !byte $5C,%01000100 + !byte $01,%00110110 + !byte $0B,%00100110 + !byte $2F,%11100101 + !byte $0F,%11100101 + !byte $30,%01010010 + !byte $66,%01100000 + !byte $66,%10000001; + !byte $0E,%01101110 + !byte $0E,%10001111; + !byte $5F,%10100101 + !byte $0E,%01010010 + !byte $00,%00011010 + !byte $0A,%01101010 + !byte $0A,%10001011; + !byte $31,%10111011 + !byte $20,%00101100 + !byte $34,%01101010 + !byte $34,%10001011; + !byte $30,%01101110 + !byte $30,%10001111; + !byte $36,%11110011 + !byte $08,%11110011 + !byte $36,%11011011 + !byte $27,%01011010 + !byte $08,%11011011 + !byte $17,%01011010 + !byte $3C,%11110101 + !byte $64,%11000011 + !byte $0D,%10111011 + !byte $0D,%11100101 + !byte $31,%11100101 + !byte $3F,%01011000 + !byte $3F,%01111000 + !byte $3F,%10011001; + !byte $04,%01110100 + !byte $04,%10010101; + !byte $07,%11011011 + !byte $01,%01011010 + !byte $37,%11011011 + !byte $5E,%10100101 + !byte $60,%10100101 + !byte $02,%11110101 + !byte $3D,%01011010 + !byte $02,%01111010 + !byte $02,%10011011; + !byte $3F,%00111000 + !byte $3C,%01111010 + !byte $3C,%10011011; + !byte $34,%01100110 + !byte $34,%10000111; + !byte $13,%00111010 + !byte $09,%11011011 + !byte $0A,%01100110 + !byte $0A,%10000111; + !byte $35,%11011011 + !byte $11,%10110001 + !byte $2B,%00111010 + !byte $1F,%01001100 + !byte $2D,%10110001 + !byte $3F,%10111001 + !byte $00,%01110110 + !byte $00,%10010111; + !byte $10,%11100101 + !byte $59,%01000010 + !byte $3E,%01110110 + !byte $3E,%10010111; + !byte $28,%11000111 + !byte $3A,%01110100 + !byte $3A,%10010101; + !byte $06,%11011011 + !byte $2E,%11100101 + !byte $3F,%00011000 + !byte $38,%11011011 + !byte $65,%01000010 + !byte $16,%11000111 + !byte $0B,%00101100 + !byte $66,%10100001 + !byte $15,%00011010 + !byte $3B,%10111011 + !byte $27,%01111010 + !byte $27,%10011011; + !byte $17,%01111010 + !byte $17,%10011011; + !byte $33,%00101100 + !byte $29,%00011010 + !byte $34,%11011011 + !byte $58,%10100001 + !byte $03,%10111011 + !byte $3F,%11011001 + !byte $63,%00100100 + !byte $00,%00111010 + !byte $5B,%00100100 + !byte $0A,%11011011 + !byte $2B,%00100110 + !byte $32,%11100101 + !byte $3E,%00111010 + !byte $0C,%11100101 + !byte $33,%00000110 + !byte $0B,%00000110 + !byte $17,%10111011 + !byte $34,%01000110 + !byte $3B,%10110101 + !byte $13,%00100110 + !byte $3F,%11110111 + !byte $12,%00000110 + !byte $27,%10111011 + !byte $03,%10110101 + !byte $0A,%01000110 + !byte $2C,%00000110 + !byte $35,%11010011 + !byte $39,%11011011 + !byte $61,%10100101 + !byte $5D,%10100101 + !byte $05,%11011011 + !byte $0A,%10101011 + !byte $2A,%01000110 + !byte $17,%11011011 + !byte $34,%10101011 + !byte $5C,%01100100 + !byte $5C,%10000101; + !byte $14,%01000110 + !byte $27,%11011011 + !byte $17,%01111100 + !byte $17,%10011101; + !byte $17,%01011100 + !byte $17,%00111100 + !byte $17,%00011100 + !byte $17,%11111011 + !byte $35,%01001000 + !byte $27,%11111011 + !byte $27,%00011100 + !byte $27,%00111100 + !byte $09,%11010011 + !byte $09,%01001000 + !byte $09,%00101000 + !byte $35,%00101000 + !byte $27,%01111100 + !byte $27,%10011101; + !byte $27,%01011100 + !byte $0C,%01110010 + !byte $0C,%10010011; + !byte $32,%01110010 + !byte $32,%10010011; + !byte $5A,%11100011 + !byte $22,%01101010 + !byte $22,%10001011; + !byte $35,%01101000 + !byte $35,%10001001; + !byte $17,%10111101 + !byte $27,%10111101 + !byte $16,%00011010 + !byte $09,%01101000 + !byte $09,%10001001; + !byte $64,%11100011 + !byte $09,%00001000 + !byte $1C,%01101010 + !byte $1C,%10001011; + !byte $35,%00001000 + !byte $28,%00011010 + !byte $62,%01100100 + !byte $62,%10000101; + !byte $5F,%11000101 + !byte $25,%01101000 + !byte $25,%10001001; + !byte $01,%00010110 + !byte $3F,%11111001 + !byte $27,%11011101 + !byte $0F,%11101111 + !byte $2D,%11110001 + !byte $17,%11011101 + !byte $11,%11110001 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $59,%01100010 + !byte $59,%10000011; + !byte $09,%10101001 + !byte $0E,%11000101 + !byte $30,%11000101 + !byte $35,%10101001 + !byte $2F,%11101111 + !byte $58,%11000001 + !byte $26,%00101000 + !byte $09,%11100111 + !byte $27,%11111101 + !byte $17,%11111101 + !byte $35,%11100111 + !byte $3E,%01010110 + !byte $11,%11100101 + !byte $5E,%11000101 + !byte $00,%01010110 + !byte $60,%11000101 + !byte $0B,%11011011 + !byte $2D,%11100101 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $3F,%11010111 + !byte $33,%11011011 + !byte $0D,%11000101 + !byte $18,%00101000 + !byte $31,%11000101 + !byte $66,%11000001 + !byte $3D,%00010110 + !byte $0C,%11001101 + !byte $2F,%11000101 + !byte $31,%00101110 + !byte $01,%01111010 + !byte $01,%10011011; + !byte $0F,%11000101 + !byte $34,%00100110 + !byte $3D,%01111010 + !byte $3D,%10011011; + !byte $27,%00011110 + !byte $09,%11001001 + !byte $17,%00011110 + !byte $32,%11001101 + !byte $09,%11000111 + !byte $0A,%00100110 + !byte $35,%11001001 + !byte $2D,%11010001 + !byte $10,%01111010 + !byte $10,%10011011; + !byte $04,%11011011 + !byte $3A,%11011011 + !byte $2E,%01111010 + !byte $2E,%10011011; + !byte $3C,%10111011 + !byte $35,%11000111 + !byte $3F,%00011010 + !byte $02,%10111011 + !byte $11,%11010001 + !byte $29,%01100110 + !byte $29,%10000111; + !byte $5B,%01000100 + !byte $0E,%10111011 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $63,%01000100 + !byte $0F,%00110010 + !byte $30,%10111011 + !byte $27,%00111110 + !byte $17,%00111110 + !byte $33,%11100101 + !byte $00,%01011010 + !byte $02,%11010101 + !byte $24,%11001001 + !byte $0B,%11100101 + !byte $0D,%00101110 + !byte $3E,%01011010 + !byte $2F,%00110010 + !byte $1A,%11001001 + !byte $09,%11101001 + !byte $32,%11000101 + !byte $0C,%11000101 + !byte $35,%11101001 + !byte $0B,%01001100 + !byte $09,%10100111 + !byte $27,%11100111 + !byte $3C,%11010101 + !byte $35,%10100111 + !byte $33,%01001100 + !byte $27,%01011110 + !byte $0A,%11001011 + !byte $10,%11000101 + !byte $17,%01011110 + !byte $34,%11001011 + !byte $17,%11100111 + !byte $2E,%11000101 + !byte $64,%00000100 + !byte $61,%11000101 + !byte $5D,%11000101 + !byte $62,%10100101 + !byte $5C,%10100101 + !byte $5A,%00000100 + !byte $3F,%10110111 + !byte $66,%11100001 + !byte $59,%10100011 + !byte $65,%10100011 + !byte $2C,%01011010 + !byte $12,%01011010 + !byte $0A,%10110011 + !byte $34,%00000110 + !byte $0A,%00000110 + !byte $3B,%11011011 + !byte $58,%11100001 + !byte $17,%01111110 + !byte $17,%10011111; + !byte $34,%10110011 + !byte $5F,%11100101 + !byte $03,%11011011 + !byte $27,%01111110 + !byte $27,%10011111; + !byte $21,%11001011 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $09,%01100110 + !byte $09,%10000111; + !byte $09,%00001010 + !byte $1D,%11001011 + !byte $23,%00001010 + !byte $35,%00001010 + !byte $32,%11011011 + !byte $10,%01010000 + !byte $3F,%00111010 + !byte $1B,%00001010 + !byte $5E,%11100101 + !byte $60,%11100101 + !byte $00,%00110110 + !byte $2E,%01010000 + !byte $0E,%10101111 + !byte $0C,%11011011 + !byte $38,%00010100 + !byte $30,%10101111 + !byte $0E,%10100101 + !byte $1E,%00001100 + !byte $20,%00001100 + !byte $30,%10100101 + !byte $31,%10100101 + !byte $28,%10100111 + !byte $2B,%00000110 + !byte $39,%00110100 + !byte $3E,%00110110 + !byte $13,%00000110 + !byte $16,%10100111 + !byte $17,%10111111 + !byte $06,%00010100 + !byte $0D,%10100101 + !byte $2E,%00010010 + !byte $27,%10111111 + !byte $12,%11100101 + !byte $10,%00010010 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $07,%11111011 + !byte $05,%00110100 + !byte $3E,%01111010 + !byte $3E,%10011011; + !byte $37,%11111011 + !byte $0B,%11000101 + !byte $3A,%01010100 + !byte $35,%01000110 + !byte $00,%01111010 + !byte $00,%10011011; + !byte $33,%11000101 + !byte $3D,%10111011 + !byte $0D,%01010010 + !byte $3D,%11110101 + !byte $01,%10111011 + !byte $38,%11111011 + !byte $01,%11110101 + !byte $06,%11111011 + !byte $09,%01000110 + !byte $2C,%11100101 + !byte $58,%00000010 + !byte $08,%11111011 + !byte $2A,%00111010 + !byte $04,%01010100 + !byte $14,%00111010 + !byte $36,%11111011 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $0F,%10100101 + !byte $66,%00000010 + !byte $31,%01010010 + !byte $09,%00101010 + !byte $2F,%10100101 + !byte $35,%00101010 + !byte $3F,%01110110 + !byte $3F,%10010111; + !byte $14,%00100110 + !byte $1F,%00101100 + !byte $64,%00100100 + !byte $17,%11011111 + !byte $11,%11000101 + !byte $2D,%11000101 + !byte $3B,%01110100 + !byte $3B,%10010101; + !byte $37,%11110011 + !byte $0C,%10100101 + !byte $34,%11101011 + !byte $34,%11100101 + !byte $03,%01110100 + !byte $03,%10010101; + !byte $5A,%00100100 + !byte $32,%10100101 + !byte $27,%11011111 + !byte $05,%11111011 + !byte $07,%11110011 + !byte $65,%11000011 + !byte $0A,%11100101 + !byte $5D,%11100101 + !byte $39,%11111011 + !byte $02,%11011011 + !byte $59,%11000011 + !byte $0A,%11101011 + !byte $2A,%00100110 + !byte $09,%11111011 + !byte $61,%11100101 + !byte $3C,%11011011 + !byte $35,%11111011 + !byte $3F,%01011010 + !byte $62,%11000101 + !byte $5C,%11000101 + !byte $35,%00100110 + !byte $09,%00100110 + !byte $5F,%00000110 + !byte $27,%11111111 + !byte $0C,%11101101 + !byte $17,%11111111 + !byte $32,%11101101 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $3A,%11111011 + !byte $2F,%10111011 + !byte $04,%11111011 + !byte $2E,%10100101 + !byte $33,%01110010 + !byte $33,%10010011; + !byte $28,%00111010 + !byte $5E,%00000110 + !byte $10,%10100101 + !byte $60,%00000110 + !byte $08,%11010011 + !byte $3C,%10110101 + !byte $16,%00111010 + !byte $66,%00100010 + !byte $02,%10110101 + !byte $22,%01001010 + !byte $35,%01001010 + !byte $1C,%01001010 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $0B,%10100101 + !byte $0F,%10111011 + !byte $33,%10100101 + !byte $58,%00100010 + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $25,%01001000 + !byte $29,%01000110 + !byte $09,%01001010 + !byte $15,%01000110 + !byte $19,%01001000 + !byte $63,%10100101 + !byte $26,%00001000 + !byte $36,%11010011 + !byte $31,%11011011 + !byte $5B,%10100101 + !byte $35,%00000110 + !byte $0A,%11111011 + !byte $34,%11111011 + !byte $0F,%00010000 + !byte $0A,%11000101 + !byte $18,%00001000 + !byte $34,%11000101 + !byte $67,%00000000 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $31,%01100100 + !byte $31,%10000101; + !byte $2F,%00010000 + !byte $09,%00000110 + !byte $64,%01000100 + !byte $0D,%01001110 + !byte $3E,%00010110 + !byte $5A,%01000100 + !byte $11,%01111010 + !byte $11,%10011011; + !byte $30,%01100100 + !byte $30,%10000101; + !byte $3F,%01010110 + !byte $57,%00000000 + !byte $65,%11100011 + !byte $00,%10111011 + !byte $59,%11100011 + !byte $0D,%11011011 + !byte $0E,%01100100 + !byte $0E,%10000101; + !byte $00,%00010110 + !byte $31,%01001110 + !byte $2D,%01111010 + !byte $2D,%10011011; + !byte $3E,%10111011 + !byte $08,%00001000 + !byte $08,%11100111 + !byte $36,%11100111 + !byte $36,%00001000 + !byte $01,%11011011 + !byte $03,%11111011 + !byte $0C,%01100100 + !byte $0C,%10000101; + !byte $36,%00101000 + !byte $3D,%11011011 + !byte $08,%00101000 + !byte $32,%01100100 + !byte $32,%10000101; + !byte $3B,%11111011 + !byte $61,%00000110 + !byte $5D,%00000110 + !byte $1A,%10101001 + !byte $62,%11100101 + !byte $08,%11000111 + !byte $3F,%01111010 + !byte $3F,%10011011; + !byte $5C,%11100101 + !byte $36,%11000111 + !byte $36,%01001000 + !byte $08,%01001000 + !byte $27,%11000111 + !byte $34,%00001100 + !byte $17,%11000111 + !byte $01,%11010101 + !byte $57,%00100000 + !byte $08,%10100111 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $15,%00111010 + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $36,%10100111 + !byte $58,%01000010 + !byte $5F,%00100110 + !byte $29,%00111010 + !byte $67,%00100000 + !byte $0A,%00001100 + !byte $36,%01101000 + !byte $36,%10001001; + !byte $08,%01101000 + !byte $08,%10001001; + !byte $35,%11100101 + !byte $24,%10101001 + !byte $2C,%11000101 + !byte $09,%11100101 + !byte $66,%01000010 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $13,%11100101 + !byte $12,%11000101 + !byte $35,%01101010 + !byte $35,%10001011; + !byte $30,%00110010 + !byte $3D,%11010101 + !byte $08,%01100110 + !byte $08,%10000111; + !byte $5E,%00100110 + !byte $36,%01100110 + !byte $36,%10000111; + !byte $0E,%00110010 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $60,%00100110 + !byte $0A,%10100101 + !byte $2B,%01011010 + !byte $34,%10100101 + !byte $63,%11000101 + !byte $10,%01110000 + !byte $10,%10010001; + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $2B,%11100101 + !byte $08,%10101001 + !byte $2E,%01110000 + !byte $2E,%10010001; + !byte $5B,%11000101 + !byte $36,%10101001 + !byte $2D,%10100101 + !byte $11,%10100101 + !byte $13,%01011010 + !byte $0B,%11111011 + !byte $09,%10110011 + !byte $28,%01100110 + !byte $28,%10000111; + !byte $33,%11111011 + !byte $3C,%11111011 + !byte $65,%00000100 + !byte $57,%01000000 + !byte $59,%00000100 + !byte $02,%11111011 + !byte $16,%01100110 + !byte $16,%10000111; + !byte $5A,%01100100 + !byte $5A,%10000101; + !byte $21,%10101011 + !byte $67,%01000000 + !byte $08,%01000110 + !byte $35,%10110011 + !byte $1D,%10101011 + !byte $36,%01000110 + !byte $3F,%00110110 + !byte $64,%01100100 + !byte $64,%10000101; + !byte $2E,%11110001 + !byte $66,%01100010 + !byte $66,%10000011; + !byte $58,%01100010 + !byte $58,%10000011; + !byte $10,%11110001 + !byte $2A,%00000110 + !byte $30,%11001111 + !byte $3F,%10111011 + !byte $08,%11001001 + !byte $3E,%11011011 + !byte $35,%11000101 + !byte $0C,%01010010 + !byte $0D,%01000100 + !byte $31,%01000100 + !byte $00,%11011011 + !byte $2E,%01100100 + !byte $2E,%10000101; + !byte $36,%11001001 + !byte $09,%11000101 + !byte $14,%00000110 + !byte $23,%11101001 + !byte $3A,%00110100 + !byte $06,%00011100 + !byte $61,%00100110 + !byte $10,%01100100 + !byte $10,%10000101; + !byte $38,%00011100 + !byte $5D,%00100110 + !byte $20,%11101011 + !byte $0B,%10101101 + !byte $39,%00010100 + !byte $1E,%11101011 + !byte $39,%00011100 + !byte $62,%00000110 + !byte $04,%00110100 + !byte $1B,%11101001 + !byte $3B,%01010100 + !byte $3E,%11110101 + !byte $37,%00011100 + !byte $0C,%01000100 + !byte $16,%01011010 + !byte $07,%00011100 + !byte $00,%11110101 + !byte $05,%00011100 + !byte $03,%01010100 + !byte $05,%00010100 + !byte $32,%01000100 + !byte $33,%10101101 + !byte $5C,%00000110 + !byte $0E,%11001111 + !byte $08,%00100110 + !byte $0E,%01000100 + !byte $30,%01000100 + !byte $36,%00100110 + !byte $32,%01010010 + !byte $28,%01011010 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $57,%01100000 + !byte $57,%10000001; + !byte $1F,%00001100 + !byte $0C,%00001110 + !byte $5F,%01000110 + !byte $34,%01100100 + !byte $34,%10000101; + !byte $0A,%01100100 + !byte $0A,%10000101; + !byte $04,%00011100 + !byte $3A,%00011100 + !byte $2F,%00010010 + !byte $36,%00011100 + !byte $0F,%00010010 + !byte $32,%00001110 + !byte $09,%10101011 + !byte $08,%00011100 + !byte $01,%11111011 + !byte $36,%11101001 + !byte $60,%01000110 + !byte $5E,%01000110 + !byte $0E,%11011011 + !byte $35,%10101011 + !byte $3D,%11111011 + !byte $30,%11011011 + !byte $65,%00100100 + !byte $3C,%01110100 + !byte $3C,%10010101; + !byte $29,%00100110 + !byte $02,%01110100 + !byte $02,%10010101; + !byte $33,%01000100 + !byte $59,%00100100 + !byte $10,%10111011 + !byte $0B,%01000100 + !byte $08,%00000110 + !byte $36,%00000110 + !byte $2E,%10111011 + !byte $63,%11100101 + !byte $15,%00100110 + !byte $2F,%01000100 + !byte $38,%11110011 + !byte $08,%11101001 + !byte $0A,%00101100 + !byte $06,%11110011 + !byte $0F,%01000100 + !byte $5B,%11100101 + !byte $34,%00101100 + !byte $67,%10100001 + !byte $35,%10100101 + !byte $64,%10100101 + !byte $66,%10100011 + !byte $09,%10100101 + !byte $58,%10100011 + !byte $57,%10100001 + !byte $5A,%10100101 + !byte $0C,%11111011 + !byte $3B,%00011100 + !byte $03,%00011100 + !byte $10,%10110001 + !byte $32,%11111011 + !byte $0A,%01110010 + !byte $0A,%10010011; + !byte $2E,%10110001 + !byte $26,%11100111 + !byte $35,%00011100 + !byte $5C,%00100110 + !byte $18,%11100111 + !byte $09,%00011100 + !byte $25,%00101000 + !byte $2C,%10100101 + !byte $3D,%10110101 + !byte $61,%01000110 + !byte $19,%00101000 + !byte $5D,%01000110 + !byte $12,%10100101 + !byte $08,%11100101 + !byte $36,%11100101 + !byte $01,%10110101 + !byte $62,%00100110 + !byte $3F,%00010110 + !byte $10,%11010001 + !byte $2E,%11010001 + !byte $3F,%11011011 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $34,%01110010 + !byte $34,%10010011; + !byte $37,%11010011 + !byte $67,%11000001 + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $0D,%00100100 + !byte $08,%00001010 + !byte $31,%00100100 + !byte $0C,%00100100 + !byte $32,%00100100 + !byte $57,%11000001 + !byte $12,%01111010 + !byte $12,%10011011; + !byte $11,%01100100 + !byte $11,%10000101; + !byte $34,%01000100 + !byte $22,%00101010 + !byte $0A,%01000100 + !byte $2C,%01111010 + !byte $2C,%10011011; + !byte $36,%00001010 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $07,%11010011 + !byte $27,%10100111 + !byte $2B,%11000101 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $02,%00011100 + !byte $0F,%00110000 + !byte $3C,%00011100 + !byte $59,%01000100 + !byte $2F,%00110000 + !byte $13,%11000101 + !byte $17,%10100111 + !byte $1C,%00101010 + !byte $3E,%11111011 + !byte $35,%11001011 + !byte $00,%11111011 + !byte $16,%01111010 + !byte $16,%10011011; + !byte $09,%01100100 + !byte $09,%10000101; + !byte $60,%01100110 + !byte $60,%10000111; + !byte $65,%01000100 + !byte $63,%00000110 + !byte $5B,%00000110 + !byte $0E,%00100100 + !byte $24,%01101000 + !byte $24,%10001001; + !byte $5E,%01100110 + !byte $5E,%10000111; + !byte $30,%00100100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $28,%01111010 + !byte $28,%10011011; + !byte $2E,%01000100 + !byte $33,%00100100 + !byte $2A,%01011010 + !byte $0B,%00100100 + !byte $10,%01000100 + !byte $08,%11000101 + !byte $64,%11000101 + !byte $66,%11000011 + !byte $1A,%01101000 + !byte $1A,%10001001; + !byte $14,%01011010 + !byte $58,%11000011 + !byte $5A,%11000101 + !byte $09,%11001011 + !byte $36,%11000101 + !byte $00,%11010101 + !byte $28,%01000110 + !byte $07,%11100111 + !byte $07,%11000111 + !byte $57,%11100001 + !byte $37,%11000111 + !byte $37,%11100111 + !byte $0A,%00011100 + !byte $07,%10100111 + !byte $67,%11100001 + !byte $16,%01000110 + !byte $37,%10100111 + !byte $34,%00011100 + !byte $2A,%11100101 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $14,%11100101 + !byte $07,%00001000 + !byte $37,%00001000 + !byte $37,%01100110 + !byte $37,%10000111; + !byte $31,%00110010 + !byte $3E,%11010101 + !byte $0D,%00110010 + !byte $36,%00101010 + !byte $08,%00101010 + !byte $01,%00011100 + !byte $62,%01000110 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $0B,%11001101 + !byte $5C,%01000110 + !byte $07,%01000110 + !byte $3D,%00011100 + !byte $37,%00101000 + !byte $0F,%00100100 + !byte $37,%01000110 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $33,%11001101 + !byte $07,%00101000 + !byte $0A,%01001100 + !byte $08,%10100101 + !byte $2F,%00100100 + !byte $0A,%00100100 + !byte $09,%01000100 + !byte $34,%00100100 + !byte $36,%10100101 + !byte $34,%01001100 + !byte $21,%01101010 + !byte $21,%10001011; + !byte $35,%01000100 + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $29,%01011010 + !byte $59,%01100100 + !byte $59,%10000101; + !byte $15,%01011010 + !byte $36,%10110011 + !byte $08,%10110011 + !byte $07,%00100110 + !byte $07,%01001000 + !byte $37,%00100110 + !byte $58,%11100011 + !byte $5F,%10100111 + !byte $37,%01001000 + !byte $2F,%11011011 + !byte $05,%00111100 + !byte $3F,%11111011 + !byte $31,%11111011 + !byte $65,%01100100 + !byte $65,%10000101; + !byte $0D,%11111011 + !byte $39,%00111100 + !byte $1B,%11001001 + !byte $66,%11100011 + !byte $5A,%11100101 + !byte $0C,%00000100 + !byte $32,%00000100 + !byte $33,%01010010 + !byte $57,%00000010 + !byte $16,%10111011 + !byte $3B,%00110100 + !byte $06,%00111100 + !byte $31,%00000100 + !byte $38,%00111100 + !byte $60,%10100111 + !byte $0E,%11101111 + !byte $5E,%10100111 + !byte $0D,%00000100 + !byte $28,%10111011 + !byte $67,%00000010 + !byte $04,%00111100 + !byte $30,%11101111 + !byte $3A,%00111100 + !byte $0F,%11011011 + !byte $0B,%01010010 + !byte $63,%00100110 + !byte $3F,%11110101 + !byte $5B,%00100110 + !byte $07,%00000110 + !byte $03,%00110100 + !byte $20,%11001011 + !byte $29,%00000110 + !byte $3A,%00010100 + !byte $1E,%11001011 + !byte $37,%00000110 + !byte $64,%11100101 + !byte $0B,%00000100 + !byte $1F,%11101011 + !byte $15,%00000110 + !byte $33,%00000100 + !byte $09,%11101011 + !byte $04,%00010100 + !byte $37,%00111100 + !byte $03,%00111100 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $2C,%01100100 + !byte $2C,%10000101; + !byte $36,%01100100 + !byte $36,%10000101; + !byte $37,%01101000 + !byte $37,%10001001; + !byte $35,%11101011 + !byte $23,%11001001 + !byte $0C,%00101110 + !byte $08,%01001010 + !byte $08,%01100100 + !byte $08,%10000101; + !byte $12,%01100100 + !byte $12,%10000101; + !byte $07,%00111100 + !byte $3B,%00111100 + !byte $00,%00011100 + !byte $11,%01000100 + !byte $30,%00000100 + !byte $32,%00101110 + !byte $2D,%01000100 + !byte $36,%01001010 + !byte $3C,%01010100 + !byte $02,%01010100 + !byte $0E,%00000100 + !byte $3E,%00011100 + !byte $0B,%00011100 + !byte $01,%01110100 + !byte $01,%10010101; + !byte $05,%11110011 + !byte $11,%10111011 + !byte $07,%11100101 + !byte $33,%00011100 + !byte $67,%00100010 + !byte $57,%00100010 + !byte $37,%11100101 + !byte $2D,%10111011 + !byte $58,%00000100 + !byte $5D,%10100111 + !byte $2E,%00100100 + !byte $61,%10100111 + !byte $5C,%01100110 + !byte $5C,%10000111; + !byte $0E,%00010010 + !byte $10,%00100100 + !byte $28,%11011011 + !byte $35,%00100100 + !byte $62,%01100110 + !byte $62,%10000111; + !byte $09,%00100100 + !byte $66,%00000100 + !byte $16,%11011011 + !byte $34,%00000100 + !byte $2B,%10100101 + !byte $0A,%00000100 + !byte $30,%00010010 + !byte $3D,%01110100 + !byte $3D,%10010101; + !byte $3C,%00111100 + !byte $08,%00111100 + !byte $02,%00111100 + !byte $07,%10101001 + !byte $2F,%11110001 + !byte $36,%00111100 + !byte $59,%10100101 + !byte $13,%10100101 + !byte $0F,%11110001 + !byte $37,%10101001 + !byte $39,%11110011 + !byte $26,%11000111 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $65,%10100101 + !byte $2F,%01010000 + !byte $5F,%11000111 + !byte $07,%11000101 + !byte $37,%11000101 + !byte $5B,%01000110 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $18,%11000111 + !byte $63,%01000110 + !byte $36,%01000100 + !byte $08,%01000100 + !byte $60,%11000111 + !byte $28,%11111011 + !byte $5E,%11000111 + !byte $0F,%01010000 + !byte $64,%00000110 + !byte $25,%00001000 + !byte $5A,%00000110 + !byte $06,%11010011 + !byte $16,%11111011 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $2B,%01111010 + !byte $2B,%10011011; + !byte $13,%01111010 + !byte $13,%10011011; + !byte $19,%00001000 + !byte $57,%01000010 + !byte $2F,%00000100 + !byte $3E,%10110101 + !byte $0C,%11100011 + !byte $32,%11100011 + !byte $0F,%00000100 + !byte $00,%10110101 + !byte $0D,%10101111 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $22,%00001010 + !byte $3F,%00011100 + !byte $01,%00111100 + !byte $0B,%11100011 + !byte $1C,%00001010 + !byte $3D,%00111100 + !byte $67,%01000010 + !byte $16,%00011100 + !byte $0D,%11100011 + !byte $34,%01101100 + !byte $34,%10001101; + !byte $31,%10101111 + !byte $33,%11100011 + !byte $58,%00100100 + !byte $31,%11100011 + !byte $2A,%11000101 + !byte $36,%01101010 + !byte $36,%10001011; + !byte $66,%00100100 + !byte $14,%11000101 + !byte $28,%00011100 + !byte $07,%11001001 + !byte $07,%10100101 + !byte $37,%11001001 + !byte $37,%10100101 + !byte $09,%00000100 + !byte $28,%00100110 + !byte $16,%00111100 + !byte $16,%00100110 + !byte $28,%00111100 + !byte $35,%00000100 + !byte $08,%01101010 + !byte $08,%10001011; + !byte $38,%11010011 + !byte $35,%00111100 + !byte $16,%11111101 + !byte $16,%11011101 + !byte $16,%10111101 + !byte $16,%01011100 + !byte $28,%01111100 + !byte $28,%10011101; + !byte $28,%10111101 + !byte $5C,%10100111 + !byte $16,%00011110 + !byte $16,%01111100 + !byte $16,%10011101; + !byte $28,%01011100 + !byte $28,%11011101 + !byte $28,%11111101 + !byte $62,%10100111 + !byte $28,%00011110 + !byte $5D,%11000111 + !byte $16,%00111110 + !byte $28,%00111110 + !byte $09,%00111100 + !byte $61,%11000111 + !byte $0A,%01101100 + !byte $0A,%10001101; + !byte $16,%01011110 + !byte $09,%00001100 + !byte $3F,%11010101 + !byte $24,%01001000 + !byte $0B,%11101101 + !byte $35,%00001100 + !byte $0A,%11100011 + !byte $34,%11100011 + !byte $28,%01011110 + !byte $65,%11000101 + !byte $08,%00100100 + !byte $0E,%11111011 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $30,%11100011 + !byte $16,%01111110 + !byte $16,%10011111; + !byte $36,%00100100 + !byte $33,%11101101 + !byte $30,%11111011 + !byte $28,%01111110 + !byte $28,%10011111; + !byte $59,%11000101 + !byte $0E,%11100011 + !byte $1A,%01001000 + !byte $32,%00011100 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $32,%00110010 + !byte $64,%00100110 + !byte $5F,%11100111 + !byte $0C,%00110010 + !byte $3E,%00111100 + !byte $07,%01100100 + !byte $07,%10000101; + !byte $5A,%00100110 + !byte $16,%10111111 + !byte $28,%10111111 + !byte $00,%00111100 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $2D,%00100100 + !byte $63,%01100110 + !byte $63,%10000111; + !byte $0C,%00011100 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $07,%11101001 + !byte $60,%11100111 + !byte $11,%00100100 + !byte $5E,%11100111 + !byte $16,%11011111 + !byte $58,%01000100 + !byte $06,%01100110 + !byte $06,%10000111; + !byte $12,%01000100 + !byte $38,%01100110 + !byte $38,%10000111; + !byte $37,%11101001 + !byte $28,%11011111 + !byte $06,%10100111 + !byte $06,%01000110 + !byte $2E,%00000100 + !byte $29,%11100101 + !byte $38,%01000110 + !byte $38,%10100111 + !byte $66,%01000100 + !byte $06,%11000111 + !byte $10,%00000100 + !byte $15,%01111010 + !byte $15,%10011011; + !byte $37,%10110011 + !byte $15,%11100101 + !byte $38,%11000111 + !byte $10,%11011011 + !byte $04,%01011100 + !byte $06,%00100110 + !byte $21,%01001010 + !byte $2E,%11011011 + !byte $29,%01111010 + !byte $29,%10011011; + !byte $2C,%01000100 + !byte $38,%00100110 + !byte $3A,%01011100 + !byte $05,%01011100 + !byte $07,%10110011 + !byte $39,%01011100 + !byte $1D,%01001010 + !byte $16,%11111111 + !byte $35,%11100011 + !byte $28,%11111111 + !byte $03,%01011100 + !byte $0A,%01010010 + !byte $06,%11100111 + !byte $09,%11100011 + !byte $0C,%11000011 + !byte $32,%11000011 + !byte $38,%11100111 + !byte $3B,%01011100 + !byte $06,%00000110 + !byte $33,%11000011 + !byte $0B,%11000011 + !byte $36,%00000100 + !byte $1E,%10101011 + !byte $38,%00000110 + !byte $0C,%01001110 + !byte $08,%00000100 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $57,%10100011 + !byte $08,%10101011 + !byte $07,%01000100 + !byte $0E,%00010000 + !byte $1F,%11001011 + !byte $02,%00110100 + !byte $32,%01001110 + !byte $62,%11000111 + !byte $56,%00000000 + !byte $0A,%00111100 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $37,%01000100 + !byte $36,%10101011 + !byte $38,%01011100 + !byte $65,%11100101 + !byte $23,%10101001 + !byte $59,%11100101 + !byte $13,%01100100 + !byte $13,%10000101; + !byte $34,%00111100 + !byte $68,%00000000 + !byte $5C,%11000111 + !byte $34,%01010010 + !byte $30,%00010000 + !byte $67,%10100011 + !byte $5D,%11100111 + !byte $0F,%11010001 + !byte $06,%01011100 + !byte $06,%00001000 + !byte $0D,%11000011 + !byte $20,%10101011 + !byte $38,%00001000 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $2F,%11010001 + !byte $61,%11100111 + !byte $3B,%00010100 + !byte $06,%11100101 + !byte $0F,%11100011 + !byte $1B,%10101001 + !byte $2F,%11100011 + !byte $31,%11000011 + !byte $38,%11100101 + !byte $14,%01111010 + !byte $14,%10011011; + !byte $02,%01011100 + !byte $3F,%00111100 + !byte $3C,%01011100 + !byte $3D,%01010100 + !byte $2A,%01111010 + !byte $2A,%10011011; + !byte $34,%11000011 + !byte $03,%00010100 + !byte $0A,%11000011 + !byte $01,%01010100 + !byte $5A,%01000110 + !byte $07,%00001010 + !byte $68,%00100000 + !byte $63,%10100111 + !byte $37,%00001010 + !byte $12,%10111011 + !byte $2C,%10111011 + !byte $66,%01100100 + !byte $66,%10000101; + !byte $5B,%10100111 + !byte $56,%00100000 + !byte $3C,%00110100 + !byte $38,%00101000 + !byte $06,%11000101 + !byte $64,%01000110 + !byte $58,%01100100 + !byte $58,%10000101; + !byte $3A,%11110011 + !byte $38,%11000101 + !byte $07,%01011100 + !byte $06,%00101000 + !byte $3E,%01110100 + !byte $3E,%10010101; + !byte $04,%11110011 + !byte $67,%11000011 + !byte $37,%01011100 + !byte $57,%11000011 + !byte $07,%00100100 + !byte $37,%00100100 + !byte $3D,%01011100 + !byte $01,%01011100 + !byte $00,%01110100 + !byte $00,%10010101; + !byte $17,%01000110 + !byte $56,%01000000 + !byte $68,%01000000 + !byte $26,%10100111 + !byte $30,%11000011 + !byte $35,%11000011 + !byte $2F,%10110001 + !byte $35,%00101100 + !byte $0F,%10110001 + !byte $08,%11100011 + !byte $09,%11000011 + !byte $0E,%11000011 + !byte $2A,%10100101 + !byte $65,%00000110 + !byte $06,%10100101 + !byte $36,%11100011 + !byte $0A,%10101101 + !byte $38,%10100101 + !byte $38,%01001000 + !byte $34,%10101101 + !byte $59,%00000110 + !byte $14,%10100101 + !byte $18,%10100111 + !byte $31,%00010010 + !byte $0D,%00010010 + !byte $27,%01000110 + !byte $36,%01110010 + !byte $36,%10010011; + !byte $06,%01001000 + !byte $56,%01100000 + !byte $56,%10000001; + !byte $09,%00101100 + !byte $62,%11100111 + !byte $33,%10100011 + !byte $5C,%11100111 + !byte $0D,%00011100 + !byte $08,%01110010 + !byte $08,%10010011; + !byte $0B,%10100011 + !byte $25,%11100111 + !byte $68,%01100000 + !byte $68,%10000001; + !byte $28,%00000110 + !byte $00,%01011100 + !byte $19,%11100111 + !byte $31,%00011100 + !byte $3E,%01011100 + !byte $32,%10100011 + !byte $16,%00000110 + !byte $0C,%10100011 + !byte $08,%01011100 + !byte $2D,%00000100 + !byte $66,%10100101 + !byte $1C,%11101001 + !byte $36,%01011100 + !byte $37,%00000100 + !byte $06,%01100100 + !byte $06,%10000101; + !byte $37,%00101010 + !byte $58,%10100101 + !byte $07,%00101010 + !byte $11,%00000100 + !byte $38,%01100100 + !byte $38,%10000101; + !byte $39,%11010011 + !byte $3F,%10110101 + !byte $34,%10100011 + !byte $07,%00000100 + !byte $0A,%10100011 + !byte $10,%11100011 + !byte $67,%11100011 + !byte $64,%01100110 + !byte $64,%10000111; + !byte $05,%11010011 + !byte $2C,%00100100 + !byte $5A,%01100110 + !byte $5A,%10000111; + !byte $0B,%00001110 + !byte $0B,%00111100 + !byte $56,%10100001 + !byte $08,%11001011 + !byte $12,%00100100 + !byte $63,%11000111 + !byte $06,%01101000 + !byte $06,%10001001; + !byte $36,%11001011 + !byte $68,%10100001 + !byte $5B,%11000111 + !byte $57,%11100011 + !byte $33,%00111100 + !byte $0E,%11110001 + !byte $30,%11110001 + !byte $2E,%11100011 + !byte $0F,%11111011 + !byte $33,%00001110 + !byte $2F,%11111011 + !byte $38,%01101000 + !byte $38,%10001001; + !byte $31,%10100011 + !byte $0D,%11001111 + !byte $22,%11101001 + !byte $0D,%10100011 + !byte $36,%11000011 + !byte $31,%11001111 + !byte $08,%11000011 + !byte $0B,%00110010 + !byte $2F,%11000011 + !byte $65,%00100110 + !byte $0F,%11000011 + !byte $15,%10111011 + !byte $59,%00100110 + !byte $06,%01000100 + !byte $29,%11000101 + !byte $29,%10111011 + !byte $38,%01000100 + !byte $09,%10100011 + !byte $3F,%01011100 + !byte $56,%11000001 + !byte $24,%00101000 + !byte $35,%10100011 + !byte $15,%11000101 + !byte $68,%11000001 + !byte $1A,%00101000 + !byte $33,%00110010 + !byte $2B,%01000100 + !byte $37,%11100011 + !byte $07,%11100011 + !byte $57,%00000100 + !byte $58,%11000101 + !byte $13,%01000100 + !byte $66,%11000101 + !byte $06,%10101001 + !byte $38,%10101001 + !byte $67,%00000100 + !byte $38,%10110011 + !byte $5A,%10100111 + !byte $11,%11011011 + !byte $3B,%01111100 + !byte $3B,%10011101; + !byte $03,%01111100 + !byte $03,%10011101; + !byte $35,%01011100 + !byte $64,%10100111 + !byte $04,%01111100 + !byte $04,%10011101; + !byte $06,%00100100 + !byte $3A,%01111100 + !byte $3A,%10011101; + !byte $2D,%11011011 + !byte $0E,%10100011 + !byte $38,%00100100 + !byte $06,%10110011 + !byte $30,%10100011 + !byte $30,%00110000 + !byte $3C,%01111100 + !byte $3C,%10011101; + !byte $56,%11100001 + !byte $02,%01111100 + !byte $02,%10011101; + !byte $09,%01011100 + !byte $5B,%11100111 + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $1D,%00101010 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $37,%01001010 + !byte $68,%11100001 + !byte $20,%01101010 + !byte $20,%10001011; + !byte $05,%01111100 + !byte $05,%10011101; + !byte $05,%00100110 + !byte $0A,%01100010 + !byte $0A,%10000011; + !byte $1F,%10101011 + !byte $39,%00100110 + !byte $39,%01000110 + !byte $13,%10111011 + !byte $05,%01000110 + !byte $34,%01100010 + !byte $34,%10000011; + !byte $39,%01111100 + !byte $39,%10011101; + !byte $0E,%00110000 + !byte $05,%00000110 + !byte $0C,%01100010 + !byte $0C,%10000011; + !byte $2B,%10111011 + !byte $1E,%01101010 + !byte $1E,%10001011; + !byte $32,%01100010 + !byte $32,%10000011; + !byte $63,%11100111 + !byte $39,%00000110 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $35,%01001100 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $08,%10100011 + !byte $07,%01001010 + !byte $36,%10100011 + !byte $05,%11100101 + !byte $3D,%01111100 + !byte $3D,%10011101; + !byte $01,%01111100 + !byte $01,%10011101; + !byte $0C,%01101110 + !byte $0C,%10001111; + !byte $35,%01010010 + !byte $39,%11100101 + !byte $32,%01101110 + !byte $32,%10001111; + !byte $57,%00100100 + !byte $21,%00101010 + !byte $09,%01010010 + !byte $05,%10100111 + !byte $67,%00100100 + !byte $39,%10100111 + !byte $37,%11000011 + !byte $3C,%00010100 + !byte $59,%01000110 + !byte $00,%01010100 + !byte $05,%11000101 + !byte $07,%11000011 + !byte $65,%01000110 + !byte $09,%01001100 + !byte $38,%00000100 + !byte $68,%00000010 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $38,%01111100 + !byte $38,%10011101; + !byte $02,%00010100 + !byte $06,%00000100 + !byte $56,%00000010 + !byte $06,%01111100 + !byte $06,%10011101; + !byte $35,%01100010 + !byte $35,%10000011; + !byte $39,%11000101 + !byte $2A,%01100100 + !byte $2A,%10000101; + !byte $3D,%00110100 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $05,%11000111 + !byte $14,%01100100 + !byte $14,%10000101; + !byte $58,%11100101 + !byte $18,%01100110 + !byte $18,%10000111; + !byte $06,%11001001 + !byte $39,%11000111 + !byte $01,%00110100 + !byte $27,%00100110 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $38,%11001001 + !byte $66,%11100101 + !byte $08,%11101011 + !byte $11,%11100011 + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $17,%00100110 + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $2D,%11100011 + !byte $10,%11000011 + !byte $3E,%01111100 + !byte $3E,%10011101; + !byte $05,%10100101 + !byte $00,%01111100 + !byte $00,%10011101; + !byte $36,%11101011 + !byte $39,%10100101 + !byte $3E,%01010100 + !byte $32,%00111100 + !byte $0A,%11001101 + !byte $3B,%11110011 + !byte $34,%11001101 + !byte $2E,%11000011 + !byte $03,%11110011 + !byte $0C,%00111100 + !byte $39,%11100111 + !byte $68,%00100010 + !byte $3F,%01110100 + !byte $3F,%10010101; + !byte $56,%00100010 + !byte $12,%00000100 + !byte $64,%11000111 + !byte $2F,%10100011 + !byte $05,%11100111 + !byte $5A,%11000111 + !byte $25,%11000111 + !byte $26,%01100110 + !byte $26,%10000111; + !byte $29,%11011011 + !byte $0C,%00010010 + !byte $05,%01100100 + !byte $05,%10000101; + !byte $15,%11011011 + !byte $0F,%10100011 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $14,%10111011 + !byte $0E,%00011100 + !byte $2A,%10111011 + !byte $19,%11000111 + !byte $67,%01000100 + !byte $57,%01000100 + !byte $30,%00011100 + !byte $06,%11100011 + !byte $28,%11100101 + !byte $38,%11100011 + !byte $2C,%00000100 + !byte $0A,%01011100 + !byte $37,%01111100 + !byte $37,%10011101; + !byte $08,%01100010 + !byte $08,%10000011; + !byte $32,%00010010 + !byte $34,%01011100 + !byte $07,%01111100 + !byte $07,%10011101; + !byte $16,%11100101 + !byte $36,%01100010 + !byte $36,%10000011; + !byte $07,%10100011 + !byte $37,%10100011 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $3F,%01111100 + !byte $3F,%10011101; + !byte $0B,%01000010 + !byte $0A,%01000010 + !byte $33,%01000010 + !byte $34,%01000010 + !byte $05,%00001000 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $39,%00001000 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $59,%01100110 + !byte $59,%10000111; + !byte $56,%01000010 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $05,%01000100 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $68,%01000010 + !byte $58,%00000110 + !byte $39,%01000100 + !byte $30,%11010001 + !byte $04,%11010011 + !byte $0E,%01100010 + !byte $0E,%10000011; + !byte $30,%01100010 + !byte $30,%10000011; + !byte $0E,%11010001 + !byte $06,%11101001 + !byte $66,%00000110 + !byte $0C,%01000010 + !byte $32,%01000010 + !byte $33,%00101110 + !byte $38,%11101001 + !byte $09,%01000010 + !byte $35,%01000010 + !byte $0D,%11101111 + !byte $31,%11101111 + !byte $2B,%00100100 + !byte $29,%10100101 + !byte $2E,%11111011 + !byte $10,%11111011 + !byte $13,%00100100 + !byte $38,%11000011 + !byte $06,%11000011 + !byte $15,%10100101 + !byte $22,%11001001 + !byte $3A,%11010011 + !byte $64,%11100111 + !byte $1C,%11001001 + !byte $0E,%01010000 + !byte $24,%00001000 + !byte $05,%00100100 + !byte $39,%00101000 + !byte $30,%01010000 + !byte $34,%00110010 + !byte $5A,%11100111 + !byte $0B,%00101110 + !byte $39,%00100100 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $0A,%00110010 + !byte $05,%00101000 + !byte $1A,%00001000 + !byte $57,%01100100 + !byte $57,%10000101; + !byte $56,%01100010 + !byte $56,%10000011; + !byte $0D,%11110001 + !byte $68,%01100010 + !byte $68,%10000011; + !byte $31,%01000010 + !byte $0D,%01000010 + !byte $08,%01000010 + !byte $36,%01000010 + !byte $08,%01111100 + !byte $08,%10011101; + !byte $37,%01100010 + !byte $37,%10000011; + !byte $31,%11110001 + !byte $07,%01100010 + !byte $07,%10000011; + !byte $36,%01111100 + !byte $36,%10011101; + !byte $65,%10100111 + !byte $12,%11011011 + !byte $36,%00001100 + !byte $2C,%11011011 + !byte $29,%11111011 + !byte $59,%10100111 + !byte $15,%11111011 + !byte $3C,%10111101 + !byte $05,%00000100 + !byte $39,%00000100 + !byte $02,%10111101 + !byte $03,%10111101 + !byte $05,%10110011 + !byte $3B,%10111101 + !byte $58,%00100110 + !byte $01,%10111101 + !byte $10,%10100011 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $39,%01001000 + !byte $05,%01001000 + !byte $3D,%10111101 + !byte $08,%00001100 + !byte $3A,%10111101 + !byte $04,%10111101 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $06,%10100011 + !byte $68,%10100011 + !byte $2D,%11000011 + !byte $0A,%00100010 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $34,%00100010 + !byte $06,%00001010 + !byte $66,%00100110 + !byte $11,%11000011 + !byte $38,%00001010 + !byte $38,%10100011 + !byte $0B,%00100010 + !byte $33,%00100010 + !byte $36,%01010010 + !byte $1D,%00001010 + !byte $56,%10100011 + !byte $2E,%10100011 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $07,%10101011 + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $39,%10110011 + !byte $2A,%01000100 + !byte $08,%01010010 + !byte $09,%00100010 + !byte $20,%01001010 + !byte $37,%10101011 + !byte $3E,%10111101 + !byte $1E,%01001010 + !byte $35,%00100010 + !byte $00,%10111101 + !byte $67,%10100101 + !byte $30,%10110001 + !byte $14,%01000100 + !byte $0B,%01011100 + !byte $33,%01011100 + !byte $39,%11100011 + !byte $57,%10100101 + !byte $0E,%10110001 + !byte $05,%10111101 + !byte $05,%11100011 + !byte $2C,%11100011 + !byte $39,%10111101 + !byte $30,%01110000 + !byte $30,%10010001; + !byte $32,%00100010 + !byte $12,%11100011 + !byte $0E,%01110000 + !byte $0E,%10010001; + !byte $0C,%00100010 + !byte $21,%00001010 + !byte $34,%11101101 + !byte $07,%01000010 + !byte $37,%01000010 + !byte $0C,%10101111 + !byte $0D,%00111100 + !byte $3A,%00000110 + !byte $04,%00000110 + !byte $23,%01001000 + !byte $30,%01000010 + !byte $3A,%11100101 + !byte $3D,%00010100 + !byte $31,%00111100 + !byte $04,%11100101 + !byte $32,%10101111 + !byte $3A,%11000101 + !byte $3A,%00100110 + !byte $15,%00011100 + !byte $01,%00010100 + !byte $04,%00100110 + !byte $04,%11000101 + !byte $0E,%01000010 + !byte $27,%00000110 + !byte $3E,%00110100 + !byte $26,%01000110 + !byte $56,%11000011 + !byte $00,%00110100 + !byte $17,%00000110 + !byte $1B,%01001000 + !byte $29,%00011100 + !byte $59,%11000111 + !byte $3F,%01010100 + !byte $3F,%10111101 + !byte $36,%00100010 + !byte $68,%11000011 + !byte $0A,%11101101 + !byte $08,%00100010 + !byte $05,%01101000 + !byte $05,%10001001; + !byte $3A,%10100101 + !byte $3A,%01000110 + !byte $04,%01000110 + !byte $18,%01000110 + !byte $38,%01100010 + !byte $38,%10000011; + !byte $39,%01101000 + !byte $39,%10001001; + !byte $04,%10100101 + !byte $06,%01100010 + !byte $06,%10000011; + !byte $65,%11000111 + !byte $35,%01111100 + !byte $35,%10011101; + !byte $09,%01111100 + !byte $09,%10011101; + !byte $58,%01000110 + !byte $39,%11000011 + !byte $05,%11000011 + !byte $66,%01000110 + !byte $04,%01100100 + !byte $04,%10000101; + !byte $04,%01100110 + !byte $04,%10000111; + !byte $3A,%01100100 + !byte $3A,%10000101; + !byte $3A,%01100110 + !byte $3A,%10000111; + !byte $0F,%00011100 + !byte $3C,%11110011 + !byte $06,%10111101 + !byte $2F,%00011100 + !byte $28,%11000101 + !byte $57,%11000101 + !byte $16,%11000101 + !byte $38,%10111101 + !byte $67,%11000101 + !byte $31,%00100010 + !byte $02,%11110011 + !byte $0D,%00100010 + !byte $3A,%01000100 + !byte $04,%01000100 + !byte $06,%00101010 + !byte $25,%10100111 + !byte $68,%11100011 + !byte $0B,%00010010 + !byte $14,%11011011 + !byte $3A,%10100111 + !byte $38,%00101010 + !byte $2A,%11011011 + !byte $15,%00111100 + !byte $0A,%00000010 + !byte $19,%10100111 + !byte $34,%00000010 + !byte $2B,%00000100 + !byte $04,%10100111 + !byte $13,%00000100 + !byte $56,%11100011 + !byte $33,%00010010 + !byte $29,%00111100 + !byte $38,%01110010 + !byte $38,%10010011; + !byte $2B,%11011011 + !byte $13,%11011011 + !byte $09,%00000010 + !byte $07,%00100010 + !byte $35,%00000010 + !byte $0B,%00000010 + !byte $37,%00100010 + !byte $06,%01110010 + !byte $06,%10010011; + !byte $33,%00000010 + !byte $04,%00100100 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $3A,%00100100 + !byte $39,%10100011 + !byte $06,%01000010 + !byte $0D,%00010000 + !byte $3B,%11010011 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $38,%01000010 + !byte $05,%10100011 + !byte $05,%10101001 + !byte $36,%00101100 + !byte $31,%00010000 + !byte $11,%11111011 + !byte $65,%11100111 + !byte $04,%11000111 + !byte $15,%01011100 + !byte $39,%10101001 + !byte $29,%01011100 + !byte $66,%01100110 + !byte $66,%10000111; + !byte $2E,%01100010 + !byte $2E,%10000011; + !byte $03,%11010011 + !byte $59,%11100111 + !byte $10,%01100010 + !byte $10,%10000011; + !byte $3A,%11000111 + !byte $2D,%11111011 + !byte $58,%01100110 + !byte $58,%10000111; + !byte $08,%00000010 + !byte $0B,%01001110 + !byte $36,%00000010 + !byte $22,%10101001 + !byte $07,%10111101 + !byte $0C,%00000010 + !byte $33,%01001110 + !byte $2F,%01000010 + !byte $57,%11100101 + !byte $08,%00101100 + !byte $07,%11001011 + !byte $32,%00000010 + !byte $37,%10111101 + !byte $56,%00000100 + !byte $04,%00000100 + !byte $67,%11100101 + !byte $0F,%01000010 + !byte $35,%00110010 + !byte $3A,%00000100 + !byte $2D,%10100011 + !byte $37,%11001011 + !byte $09,%00110010 + !byte $1C,%10101001 + !byte $15,%01111100 + !byte $15,%10011101; + !byte $35,%10101101 + !byte $68,%00000100 + !byte $11,%10100011 + !byte $29,%01111100 + !byte $29,%10011101; + !byte $04,%11100111 + !byte $14,%00100100 + !byte $15,%10111101 + !byte $3A,%11100111 + !byte $05,%01100010 + !byte $05,%10000011; + !byte $29,%10111101 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $15,%11011101 + !byte $0E,%00100010 + !byte $29,%11011101 + !byte $15,%01111110 + !byte $15,%10011111; + !byte $15,%01011110 + !byte $15,%00111110 + !byte $29,%00111110 + !byte $29,%01011110 + !byte $29,%01111110 + !byte $29,%10011111; + !byte $24,%11100111 + !byte $30,%00100010 + !byte $15,%00011110 + !byte $15,%11111101 + !byte $02,%11011101 + !byte $3D,%11011101 + !byte $29,%11111101 + !byte $15,%10111111 + !byte $01,%11011101 + !byte $04,%11100011 + !byte $3A,%11100011 + !byte $29,%00011110 + !byte $29,%10111111 + !byte $3C,%11011101 + !byte $1A,%11100111 + !byte $15,%11011111 + !byte $29,%11011111 + !byte $0D,%11010001 + !byte $29,%11111111 + !byte $09,%10101101 + !byte $32,%11110001 + !byte $15,%11111111 + !byte $03,%11011101 + !byte $3B,%11011101 + !byte $3E,%11011101 + !byte $2C,%11000011 + !byte $0C,%01011100 + !byte $00,%11011101 + !byte $06,%01001010 + !byte $07,%00000010 + !byte $68,%00100100 + !byte $0C,%11110001 + !byte $31,%11010001 + !byte $32,%01011100 + !byte $06,%00100010 + !byte $0A,%01111100 + !byte $0A,%10011101; + !byte $2A,%00100100 + !byte $55,%00000000 + !byte $38,%00100010 + !byte $12,%11000011 + !byte $37,%00000010 + !byte $38,%01001010 + !byte $34,%01111100 + !byte $34,%10011101; + !byte $69,%00000000 + !byte $39,%11001001 + !byte $1F,%01001010 + !byte $56,%00100100 + !byte $66,%10100111 + !byte $34,%11100001 + !byte $0A,%11100001 + !byte $09,%11100001 + !byte $35,%11100001 + !byte $58,%10100111 + !byte $20,%00101010 + !byte $57,%00000110 + !byte $55,%00100000 + !byte $1E,%00101010 + !byte $05,%11001001 + !byte $69,%00100000 + !byte $31,%00000010 + !byte $3F,%11011101 + !byte $0D,%00000010 + !byte $67,%00000110 + !byte $04,%11011101 + !byte $21,%11101001 + !byte $0E,%00111100 + !byte $04,%00001000 + !byte $3A,%11000011 + !byte $04,%11000011 + !byte $3A,%00001000 + !byte $55,%01000000 + !byte $1D,%11101001 + !byte $3A,%10110011 + !byte $3A,%11011101 + !byte $04,%10110011 + !byte $69,%01000000 + !byte $0B,%11100001 + !byte $33,%11100001 + !byte $30,%00111100 + !byte $08,%11100001 + !byte $36,%11100001 + !byte $37,%01010010 + !byte $05,%01000010 + !byte $08,%10111101 + !byte $39,%01000010 + !byte $07,%01010010 + !byte $34,%00001110 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $69,%01100000 + !byte $69,%10000001; + !byte $36,%10111101 + !byte $0C,%11001111 + !byte $1B,%00101000 + !byte $28,%10100101 + !byte $32,%11001111 + !byte $13,%11100011 + !byte $16,%10100101 + !byte $3F,%00110100 + !byte $27,%11100101 + !byte $3E,%00010100 + !byte $3A,%10100011 + !byte $04,%10100011 + !byte $68,%01000100 + !byte $00,%00010100 + !byte $17,%11100101 + !byte $0A,%00001110 + !byte $38,%00000010 + !byte $55,%10100001 + !byte $56,%01000100 + !byte $69,%10100001 + !byte $39,%11011101 + !byte $04,%00101000 + !byte $32,%11100001 + !byte $0C,%11100001 + !byte $3A,%00101000 + !byte $06,%00000010 + !byte $26,%00100110 + !byte $66,%11000111 + !byte $57,%00100110 + !byte $58,%11000111 + !byte $18,%00100110 + !byte $37,%11100001 + !byte $05,%11011101 + !byte $2B,%11100011 + !byte $14,%11111011 + !byte $10,%00011100 + !byte $03,%11000101 + !byte $07,%11100001 + !byte $3B,%11000101 + !byte $2E,%00011100 + !byte $2A,%11111011 + !byte $3B,%10100101 + !byte $03,%11100101 + !byte $03,%10100101 + !byte $3B,%11100101 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $03,%01100100 + !byte $03,%10000101; + !byte $15,%01000100 + !byte $2E,%01000010 + !byte $67,%00100110 + !byte $55,%11000001 + !byte $0D,%00110000 + !byte $23,%00101000 + !byte $39,%11101001 + !byte $10,%01000010 + !byte $39,%00100010 + !byte $31,%00110000 + !byte $69,%11000001 + !byte $03,%00000110 + !byte $05,%00100010 + !byte $3B,%00000110 + !byte $2F,%00100010 + !byte $0F,%00100010 + !byte $3B,%01000100 + !byte $12,%11111011 + !byte $03,%01000100 + !byte $34,%00010010 + !byte $07,%11101011 + !byte $2C,%11111011 + !byte $05,%11101001 + !byte $3D,%11110011 + !byte $0A,%00010010 + !byte $03,%00100110 + !byte $3B,%00100110 + !byte $37,%11101011 + !byte $09,%11000001 + !byte $35,%11000001 + !byte $3A,%01100010 + !byte $3A,%10000011; + !byte $56,%01100100 + !byte $56,%10000101; + !byte $55,%11100001 + !byte $03,%00100100 + !byte $08,%01001100 + !byte $29,%01000100 + !byte $30,%00000010 + !byte $0A,%11000001 + !byte $34,%11000001 + !byte $69,%11100001 + !byte $01,%11110011 + !byte $0E,%00000010 + !byte $04,%01100010 + !byte $04,%10000011; + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $3B,%00100100 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $68,%01100100 + !byte $68,%10000101; + !byte $39,%01110010 + !byte $39,%10010011; + !byte $36,%01001100 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $36,%11000001 + !byte $08,%11000001 + !byte $3B,%01000110 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $03,%00000100 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $06,%01101010 + !byte $06,%10001011; + !byte $3B,%00000100 + !byte $06,%11100001 + !byte $38,%01101010 + !byte $38,%10001011; + !byte $06,%11011101 + !byte $03,%01000110 + !byte $55,%00000010 + !byte $38,%11011101 + !byte $04,%01001000 + !byte $38,%11100001 + !byte $33,%11000001 + !byte $3A,%01001000 + !byte $69,%00000010 + !byte $0B,%11000001 + !byte $0B,%01111100 + !byte $0B,%10011101; + !byte $0D,%11100001 + !byte $31,%10110001 + !byte $33,%01111100 + !byte $33,%10011101; + !byte $57,%01000110 + !byte $31,%11100001 + !byte $58,%11100111 + !byte $2A,%00000100 + !byte $67,%01000110 + !byte $33,%01101110 + !byte $33,%10001111; + !byte $0D,%10110001 + !byte $08,%00110010 + !byte $04,%01000010 + !byte $05,%00000010 + !byte $3A,%01000010 + !byte $39,%00000010 + !byte $14,%00000100 + !byte $37,%11000001 + !byte $36,%00110010 + !byte $22,%01101000 + !byte $22,%10001001; + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $3C,%11010011 + !byte $56,%10100101 + !byte $03,%11100011 + !byte $07,%11000001 + !byte $2C,%10100011 + !byte $3B,%11100011 + !byte $12,%10100011 + !byte $1C,%01101000 + !byte $1C,%10001001; + !byte $66,%11100111 + !byte $09,%11001101 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $09,%10111101 + !byte $35,%11001101 + !byte $02,%11010011 + !byte $68,%10100101 + !byte $55,%00100010 + !byte $35,%10111101 + !byte $69,%00100010 + !byte $24,%11000111 + !byte $0D,%01011100 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $01,%11111101 + !byte $3D,%11111101 + !byte $00,%11111101 + !byte $3E,%11111101 + !byte $31,%01011100 + !byte $13,%11111011 + !byte $2B,%11111011 + !byte $03,%11000011 + !byte $1A,%11000111 + !byte $3B,%11000011 + !byte $0D,%01010000 + !byte $32,%11000001 + !byte $02,%11111101 + !byte $31,%01010000 + !byte $3C,%11111101 + !byte $0C,%11000001 + !byte $3F,%11111101 + !byte $03,%10100111 + !byte $1F,%00101010 + !byte $3B,%10100111 + !byte $05,%00001010 + !byte $69,%01000010 + !byte $55,%01000010 + !byte $39,%00001010 + !byte $3A,%01101000 + !byte $3A,%10001001; + !byte $09,%10100001 + !byte $04,%00100010 + !byte $35,%10100001 + !byte $3B,%10110011 + !byte $3B,%11111101 + !byte $06,%11000001 + !byte $3A,%00100010 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $67,%01100110 + !byte $67,%10000111; + !byte $06,%01010010 + !byte $38,%11000001 + !byte $36,%10100001 + !byte $3B,%10100011 + !byte $68,%11000101 + !byte $03,%11111101 + !byte $04,%01101000 + !byte $04,%10001001; + !byte $08,%10100001 + !byte $03,%10100011 + !byte $0A,%10100001 + !byte $33,%11110001 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $05,%11100001 + !byte $20,%00001010 + !byte $56,%11000101 + !byte $03,%10110011 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $0B,%11110001 + !byte $2B,%11000011 + !byte $34,%10100001 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $0F,%00111100 + !byte $2A,%00011100 + !byte $13,%11000011 + !byte $38,%01010010 + !byte $07,%11011101 + !byte $1E,%00001010 + !byte $39,%11100001 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $37,%11011101 + !byte $14,%00011100 + !byte $2F,%00111100 + !byte $21,%11001001 + !byte $17,%11000101 + !byte $03,%11000111 + !byte $2E,%00100010 + !byte $3B,%11000111 + !byte $1D,%11001001 + !byte $2F,%00000010 + !byte $0E,%11100001 + !byte $0F,%00000010 + !byte $32,%11101111 + !byte $10,%00100010 + !byte $37,%00001100 + !byte $37,%10100001 + !byte $0C,%11010001 + !byte $07,%10100001 + !byte $32,%11010001 + !byte $28,%01100100 + !byte $28,%10000101; + !byte $06,%10101011 + !byte $30,%11100001 + !byte $16,%01100100 + !byte $16,%10000101; + !byte $26,%00000110 + !byte $0B,%10100001 + !byte $3A,%11111101 + !byte $03,%01100010 + !byte $03,%10000011; + !byte $33,%10100001 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $18,%00000110 + !byte $38,%10101011 + !byte $0C,%11101111 + !byte $69,%10100011 + !byte $55,%10100011 + !byte $04,%11111101 + !byte $07,%00001100 + !byte $3A,%00000010 + !byte $27,%11000101 + !byte $2D,%00011100 + !byte $04,%00000010 + !byte $0A,%00101110 + !byte $34,%00101110 + !byte $29,%00100100 + !byte $2D,%01000010 + !byte $31,%11000001 + !byte $11,%00011100 + !byte $15,%00100100 + !byte $0D,%11000001 + !byte $67,%10100111 + !byte $11,%01000010 + !byte $68,%11100101 + !byte $57,%10100111 + !byte $08,%01101100 + !byte $08,%10001101; + !byte $04,%10101001 + !byte $3B,%11100111 + !byte $23,%00001000 + !byte $56,%11100101 + !byte $3A,%10101001 + !byte $38,%10100001 + !byte $05,%11000001 + !byte $06,%10100001 + !byte $39,%11000001 + !byte $36,%01101100 + !byte $36,%10001101; + !byte $03,%11100111 + !byte $3B,%01000010 + !byte $1B,%00001000 + !byte $03,%01000010 + !byte $55,%11000011 + !byte $09,%00010010 + !byte $69,%11000011 + !byte $32,%01111100 + !byte $32,%10011101; + !byte $35,%01100000 + !byte $35,%10000001; + !byte $09,%01100000 + !byte $09,%10000001; + !byte $0A,%10111101 + !byte $05,%00101010 + !byte $25,%01000110 + !byte $36,%01100000 + !byte $36,%10000001; + !byte $3F,%00010100 + !byte $08,%01100000 + !byte $08,%10000001; + !byte $0C,%10100001 + !byte $39,%00101010 + !byte $34,%10111101 + !byte $02,%01100100 + !byte $02,%10000101; + !byte $02,%01000100 + !byte $3C,%01000100 + !byte $3C,%01100100 + !byte $3C,%10000101; + !byte $32,%10100001 + !byte $02,%10100101 + !byte $19,%01000110 + !byte $3A,%11100001 + !byte $3C,%10100101 + !byte $04,%11100001 + !byte $3A,%01110010 + !byte $3A,%10010011; + !byte $35,%00010010 + !byte $3E,%11110011 + !byte $3C,%00100100 + !byte $05,%11111101 + !byte $02,%00100100 + !byte $3C,%11000101 + !byte $04,%01110010 + !byte $04,%10010011; + !byte $02,%11000101 + !byte $39,%11111101 + !byte $0C,%01111100 + !byte $0C,%10011101; + !byte $2C,%01100010 + !byte $2C,%10000011; + !byte $34,%01100000 + !byte $34,%10000001; + !byte $0A,%01100000 + !byte $0A,%10000001; + !byte $07,%01100000 + !byte $07,%10000001; + !byte $3C,%00000100 + !byte $00,%11110011 + !byte $12,%01100010 + !byte $12,%10000011; + !byte $08,%11011101 + !byte $02,%00000100 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $2A,%11100011 + !byte $03,%00100010 + !byte $36,%11011101 + !byte $3C,%11100101 + !byte $69,%11100011 + !byte $67,%11000111 + !byte $3B,%00100010 + !byte $02,%11100101 + !byte $2A,%00111100 + !byte $14,%11100011 + !byte $56,%00000110 + !byte $57,%11000111 + !byte $14,%00111100 + !byte $68,%00000110 + !byte $03,%00001000 + !byte $3C,%11100011 + !byte $55,%11100011 + !byte $01,%11010011 + !byte $02,%11100011 + !byte $3B,%00001000 + !byte $3C,%00000110 + !byte $39,%10100001 + !byte $0B,%10101111 + !byte $02,%00000110 + !byte $30,%01011100 + !byte $05,%10100001 + !byte $0E,%01011100 + !byte $07,%00110010 + !byte $3C,%11000011 + !byte $02,%11000011 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $0F,%11100001 + !byte $22,%01001000 + !byte $33,%10101111 + !byte $1C,%01001000 + !byte $3E,%00011110 + !byte $00,%00011110 + !byte $06,%01100000 + !byte $06,%10000001; + !byte $0E,%11000001 + !byte $1A,%10100111 + !byte $33,%01100000 + !byte $33,%10000001; + !byte $3F,%00011110 + !byte $09,%11101101 + !byte $35,%11101101 + !byte $38,%01100000 + !byte $38,%10000001; + !byte $04,%11000001 + !byte $55,%00000100 + !byte $04,%11001001 + !byte $37,%00110010 + !byte $01,%00011110 + !byte $3D,%11010011 + !byte $3C,%00100110 + !byte $3D,%00011110 + !byte $2F,%11100001 + !byte $3A,%11001001 + !byte $69,%00000100 + !byte $3A,%11000001 + !byte $02,%00100110 + !byte $30,%11000001 + !byte $2E,%00000010 + !byte $03,%00000010 + !byte $06,%11111101 + !byte $02,%10100011 + !byte $1F,%00001010 + !byte $3B,%00000010 + !byte $2C,%00011100 + !byte $10,%00000010 + !byte $3C,%10100011 + !byte $0D,%10100001 + !byte $56,%00100110 + !byte $38,%11111101 + !byte $2B,%10100011 + !byte $12,%00011100 + !byte $67,%11100111 + !byte $3C,%00011110 + !byte $68,%00100110 + !byte $13,%10100011 + !byte $37,%00101100 + !byte $02,%00011110 + !byte $3B,%00101000 + !byte $31,%10100001 + !byte $36,%01000000 + !byte $13,%00011100 + !byte $2B,%00011100 + !byte $57,%11100111 + !byte $06,%11001011 + !byte $08,%01000000 + !byte $24,%10100111 + !byte $09,%01000000 + !byte $20,%11101001 + !byte $38,%11001011 + !byte $0C,%00010000 + !byte $35,%01000000 + !byte $3C,%01100010 + !byte $3C,%10000011; + !byte $32,%00010000 + !byte $1E,%11101001 + !byte $11,%00100010 + !byte $39,%01010010 + !byte $02,%01000110 + !byte $02,%01100010 + !byte $02,%10000011; + !byte $03,%00101000 + !byte $07,%01000000 + !byte $37,%01000000 + !byte $3C,%01000110 + !byte $05,%01001010 + !byte $69,%00100100 + !byte $02,%10110011 + !byte $10,%00111100 + !byte $14,%01011100 + !byte $39,%01100000 + !byte $39,%10000001; + !byte $2E,%00111100 + !byte $05,%01010010 + !byte $39,%01001010 + !byte $2A,%01011100 + !byte $07,%00101100 + !byte $55,%00100100 + !byte $34,%11110001 + !byte $0A,%01000000 + !byte $0A,%11110001 + !byte $05,%01100000 + !byte $05,%10000001; + !byte $34,%01000000 + !byte $2D,%00100010 + !byte $27,%10100101 + !byte $32,%01100000 + !byte $32,%10000001; + !byte $3B,%11100001 + !byte $03,%11100001 + !byte $0C,%01100000 + !byte $0C,%10000001; + !byte $3B,%00011110 + !byte $21,%10101001 + !byte $0C,%10110001 + !byte $32,%10110001 + !byte $04,%10100001 + !byte $1D,%10101001 + !byte $17,%10100101 + !byte $03,%00011110 + !byte $28,%01000100 + !byte $3C,%10110011 + !byte $3A,%10100001 + !byte $56,%01000110 + !byte $3C,%01000010 + !byte $35,%11011101 + !byte $02,%01100110 + !byte $02,%10000111; + !byte $02,%01000010 + !byte $06,%01000000 + !byte $16,%01000100 + !byte $38,%01000000 + !byte $3C,%01100110 + !byte $3C,%10000111; + !byte $08,%10101101 + !byte $55,%01000100 + !byte $68,%01000110 + !byte $29,%00000100 + !byte $36,%10101101 + !byte $69,%01000100 + !byte $26,%11100101 + !byte $0B,%10111101 + !byte $15,%00000100 + !byte $0A,%01001110 + !byte $12,%01000010 + !byte $18,%11100101 + !byte $34,%01001110 + !byte $33,%10111101 + !byte $09,%11011101 + !byte $04,%11101001 + !byte $0B,%01000000 + !byte $3B,%11000001 + !byte $3C,%00100010 + !byte $3A,%11101001 + !byte $03,%01001000 + !byte $3B,%01001000 + !byte $02,%00100010 + !byte $03,%11000001 + !byte $23,%11100111 + !byte $14,%11000011 + !byte $08,%00010010 + !byte $33,%01000000 + !byte $1B,%11100111 + !byte $0B,%11010001 + !byte $33,%11010001 + !byte $3A,%00011110 + !byte $07,%11111101 + !byte $14,%01111100 + !byte $14,%10011101; + !byte $2C,%01000010 + !byte $02,%10100111 + !byte $31,%01111100 + !byte $31,%10011101; + !byte $36,%00010010 + !byte $2A,%01111100 + !byte $2A,%10011101; + !byte $3C,%10100111 + !byte $37,%11111101 + !byte $56,%01100110 + !byte $56,%10000111; + !byte $04,%00011110 + !byte $05,%01000000 + !byte $19,%00100110 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $08,%00100000 + !byte $2F,%11000001 + !byte $36,%00100000 + !byte $39,%01000000 + !byte $30,%10100001 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $0F,%11000001 + !byte $04,%01100000 + !byte $04,%10000001; + !byte $07,%00100000 + !byte $3A,%01100000 + !byte $3A,%10000001; + !byte $37,%00100000 + !byte $09,%00100000 + !byte $35,%00100000 + !byte $0D,%01111100 + !byte $0D,%10011101; + !byte $0E,%10100001 + !byte $68,%01100110 + !byte $68,%10000111; + !byte $55,%01100100 + !byte $55,%10000101; + !byte $32,%00110000 + !byte $03,%01110010 + !byte $03,%10010011; + !byte $2A,%11000011 + !byte $02,%00000010 + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $31,%01100000 + !byte $31,%10000001; + !byte $3C,%00000010 + !byte $10,%11100001 + !byte $0C,%00110000 + !byte $3F,%11110011 + !byte $25,%00100110 + !byte $03,%10100001 + !byte $06,%11101011 + !byte $01,%01000100 + !byte $01,%00100100 + !byte $38,%00100000 + !byte $01,%00000100 + !byte $3D,%00000100 + !byte $3D,%00100100 + !byte $06,%00100000 + !byte $3D,%01000100 + !byte $14,%10111101 + !byte $05,%01101010 + !byte $05,%10001011; + !byte $2E,%11100001 + !byte $3B,%10100001 + !byte $38,%11101011 + !byte $2A,%10111101 + !byte $34,%00100000 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $0A,%00100000 + !byte $3C,%11000111 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $01,%11100011 + !byte $3D,%11100011 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $13,%01100010 + !byte $13,%10000011; + !byte $0C,%01110000 + !byte $0C,%10010001; + !byte $32,%01110000 + !byte $32,%10010001; + !byte $3E,%11010011 + !byte $55,%10100101 + !byte $0B,%11001111 + !byte $3D,%11000011 + !byte $3F,%00111110 + !byte $0F,%01011100 + !byte $01,%11000011 + !byte $38,%00110010 + !byte $35,%00001110 + !byte $01,%10100101 + !byte $2F,%01011100 + !byte $33,%11001111 + !byte $32,%01000000 + !byte $06,%00110010 + !byte $3E,%00111110 + !byte $69,%10100101 + !byte $56,%10100111 + !byte $02,%11000111 + !byte $0C,%01000000 + !byte $3D,%10100101 + !byte $00,%00111110 + !byte $00,%11010011 + !byte $3C,%11100001 + !byte $22,%00101000 + !byte $02,%11100001 + !byte $2D,%00000010 + !byte $68,%10100111 + !byte $39,%00011110 + !byte $14,%11011101 + !byte $11,%00000010 + !byte $2A,%11011101 + !byte $05,%00011110 + !byte $03,%01101000 + !byte $03,%10001001; + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $3D,%10100011 + !byte $3D,%11000101 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $11,%00111100 + !byte $01,%10100011 + !byte $1C,%00101000 + !byte $37,%01001100 + !byte $04,%01000000 + !byte $3A,%01000000 + !byte $01,%11000101 + !byte $2D,%00111100 + !byte $05,%00100000 + !byte $39,%00100000 + !byte $09,%00001110 + !byte $0C,%01010000 + !byte $1F,%11101001 + !byte $32,%01010000 + !byte $01,%00111110 + !byte $3D,%00111110 + !byte $04,%00001010 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $13,%00111100 + !byte $69,%11000101 + !byte $55,%11000101 + !byte $3A,%00001010 + !byte $2B,%00111100 + !byte $2A,%11111101 + !byte $33,%00100000 + !byte $14,%11111101 + !byte $24,%01100110 + !byte $24,%10000111; + !byte $3D,%11100101 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $36,%00000000 + !byte $0B,%00100000 + !byte $08,%00000000 + !byte $07,%01001100 + !byte $01,%11100101 + !byte $07,%00000000 + !byte $37,%00000000 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $0A,%11011101 + !byte $3C,%11000001 + !byte $1A,%01100110 + !byte $1A,%10000111; + !byte $14,%00011110 + !byte $17,%01100100 + !byte $17,%10000101; + !byte $02,%11000001 + !byte $28,%00100100 + !byte $34,%11011101 + !byte $2A,%00011110 + !byte $20,%11001001 + !byte $08,%11111101 + !byte $16,%00100100 + !byte $35,%00000000 + !byte $2A,%11011111 + !byte $2A,%11111111 + !byte $54,%00000000 + !byte $14,%00111110 + !byte $1E,%11001001 + !byte $2A,%00111110 + !byte $6A,%00000000 + !byte $14,%11111111 + !byte $14,%11011111 + !byte $02,%11100111 + !byte $36,%11111101 + !byte $56,%11000111 + !byte $01,%01000010 + !byte $3C,%11100111 + !byte $2A,%01011110 + !byte $2A,%01111110 + !byte $2A,%10011111; + !byte $2A,%10111111 + !byte $54,%00100000 + !byte $14,%01111110 + !byte $14,%10011111; + !byte $14,%01011110 + !byte $6A,%00100000 + !byte $14,%10111111 + !byte $09,%00000000 + !byte $3D,%01000010 + !byte $3A,%01010010 + !byte $3C,%00111110 + !byte $35,%11110001 + !byte $06,%00000000 + !byte $15,%11100011 + !byte $54,%01000000 + !byte $38,%00000000 + !byte $3D,%10110011 + !byte $02,%00111110 + !byte $04,%01010010 + !byte $6A,%01000000 + !byte $3D,%00000110 + !byte $54,%01100000 + !byte $54,%10000001; + !byte $6A,%01100000 + !byte $6A,%10000001; + !byte $01,%00000110 + !byte $09,%11110001 + !byte $32,%10111101 + !byte $68,%11000111 + !byte $2C,%00100010 + !byte $01,%10110011 + !byte $6A,%10100001 + !byte $54,%10100001 + !byte $12,%00100010 + !byte $3D,%00100010 + !byte $01,%00100010 + !byte $3A,%00100000 + !byte $69,%11100101 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $27,%01100100 + !byte $27,%10000101; + !byte $04,%00100000 + !byte $26,%11000101 + !byte $30,%01100000 + !byte $30,%10000001; + !byte $55,%11100101 + !byte $0E,%01100000 + !byte $0E,%10000001; + !byte $6A,%11000001 + !byte $54,%11000001 + !byte $18,%11000101 + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $2F,%10100001 + !byte $31,%01000000 + !byte $3C,%10100001 + !byte $0C,%10111101 + !byte $02,%10100001 + !byte $29,%11100011 + !byte $34,%00000000 + !byte $39,%00000000 + !byte $0F,%10100001 + !byte $0A,%01101110 + !byte $0A,%10001111; + !byte $05,%00000000 + !byte $0A,%00000000 + !byte $0D,%01000000 + !byte $34,%01101110 + !byte $34,%10001111; + !byte $54,%11100001 + !byte $12,%00111100 + !byte $2C,%00111100 + !byte $6A,%11100001 + !byte $03,%01000000 + !byte $38,%00011110 + !byte $3B,%01000000 + !byte $2A,%10100011 + !byte $01,%00100110 + !byte $3B,%00111110 + !byte $06,%00011110 + !byte $08,%11001101 + !byte $01,%00000010 + !byte $03,%10101001 + !byte $2E,%11000001 + !byte $54,%00000010 + !byte $3D,%00000010 + !byte $36,%11001101 + !byte $0C,%00100000 + !byte $3D,%00100110 + !byte $6A,%00000010 + !byte $02,%00001000 + !byte $10,%11000001 + !byte $14,%10100011 + !byte $3B,%10101001 + !byte $56,%11100111 + !byte $3C,%00001000 + !byte $07,%00010010 + !byte $03,%00111110 + !byte $23,%11000111 + !byte $32,%00100000 + !byte $6A,%00100010 + !byte $54,%00100010 + !byte $0E,%01111100 + !byte $0E,%10011101; + !byte $37,%00010010 + !byte $68,%11100111 + !byte $1B,%11000111 + !byte $0B,%10110001 + !byte $0A,%11010001 + !byte $30,%01111100 + !byte $30,%10011101; + !byte $3C,%01110010 + !byte $3C,%10010011; + !byte $55,%00000110 + !byte $05,%10101011 + !byte $69,%00000110 + !byte $06,%00001100 + !byte $02,%01100000 + !byte $02,%10000001; + !byte $04,%00101010 + !byte $54,%01000010 + !byte $02,%01110010 + !byte $02,%10010011; + !byte $39,%10101011 + !byte $33,%10110001 + !byte $34,%11010001 + !byte $3D,%11100001 + !byte $01,%01000110 + !byte $38,%00001100 + !byte $3A,%00101010 + !byte $6A,%01000010 + !byte $3C,%01100000 + !byte $3C,%10000001; + !byte $3A,%00000000 + !byte $01,%11100001 + !byte $3D,%01000110 + !byte $33,%00000000 + !byte $0B,%11101111 + !byte $2B,%01000010 + !byte $33,%11101111 + !byte $04,%00000000 + !byte $0B,%00000000 + !byte $25,%00000110 + !byte $19,%00000110 + !byte $13,%01000010 + !byte $03,%00100000 + !byte $3B,%00100000 + !byte $54,%01100010 + !byte $54,%10000011; + !byte $2D,%11100001 + !byte $6A,%01100010 + !byte $6A,%10000011; + !byte $11,%11100001 + !byte $10,%01011100 + !byte $05,%00110010 + !byte $3D,%11000001 + !byte $2E,%01011100 + !byte $55,%00100110 + !byte $01,%11000001 + !byte $2B,%01011100 + !byte $04,%00111110 + !byte $13,%01011100 + !byte $3F,%01011110 + !byte $3A,%00111110 + !byte $69,%00100110 + !byte $03,%11001001 + !byte $54,%10100011 + !byte $37,%01101100 + !byte $37,%10001101; + !byte $01,%01100110 + !byte $01,%10000111; + !byte $6A,%10100011 + !byte $35,%00101110 + !byte $3B,%11001001 + !byte $02,%01000000 + !byte $00,%00000100 + !byte $00,%11100011 + !byte $39,%00110010 + !byte $00,%11000011 + !byte $3E,%11000011 + !byte $3E,%11100011 + !byte $3E,%00000100 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $09,%11111101 + !byte $3C,%01000000 + !byte $02,%00101000 + !byte $22,%00001000 + !byte $00,%01011110 + !byte $3E,%00100100 + !byte $35,%11111101 + !byte $00,%00100100 + !byte $1F,%11001001 + !byte $3E,%01011110 + !byte $3F,%11010011 + !byte $00,%10100011 + !byte $3E,%10100011 + !byte $37,%00011110 + !byte $3C,%00101000 + !byte $1C,%00001000 + !byte $33,%11011101 + !byte $3E,%01000100 + !byte $00,%01000100 + !byte $3E,%01100010 + !byte $3E,%10000011; + !byte $01,%10100001 + !byte $00,%01100010 + !byte $00,%10000011; + !byte $07,%01101100 + !byte $07,%10001101; + !byte $54,%11000011 + !byte $55,%01000110 + !byte $3D,%10100001 + !byte $6A,%11000011 + !byte $09,%00101110 + !byte $24,%01000110 + !byte $07,%00011110 + !byte $31,%00100000 + !byte $03,%00000000 + !byte $30,%01000000 + !byte $0D,%00100000 + !byte $69,%01000110 + !byte $3B,%00000000 + !byte $3E,%01100100 + !byte $3E,%10000101; + !byte $0E,%01000000 + !byte $20,%10101001 + !byte $0B,%11011101 + !byte $00,%01100100 + !byte $00,%10000101; + !byte $3E,%01000010 + !byte $1A,%01000110 + !byte $1E,%10101001 + !byte $00,%01000010 + !byte $32,%00000000 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $3D,%01011110 + !byte $01,%01011110 + !byte $0C,%00000000 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $01,%10100111 + !byte $2C,%00000010 + !byte $08,%11110001 + !byte $28,%00000100 + !byte $29,%11000011 + !byte $3E,%10100101 + !byte $3B,%01010010 + !byte $00,%00100010 + !byte $12,%00000010 + !byte $3E,%00100010 + !byte $3D,%10100111 + !byte $54,%11100011 + !byte $00,%10110011 + !byte $6A,%11100011 + !byte $27,%01000100 + !byte $00,%10100101 + !byte $02,%00100000 + !byte $3C,%00100000 + !byte $0D,%10111101 + !byte $15,%11000011 + !byte $16,%00000100 + !byte $03,%01010010 + !byte $17,%01000100 + !byte $31,%10111101 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $2E,%10100001 + !byte $05,%00111110 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $36,%11110001 + !byte $14,%01100010 + !byte $14,%10000011; + !byte $10,%10100001 + !byte $3A,%01001010 + !byte $6A,%00000100 + !byte $39,%00111110 + !byte $05,%11001011 + !byte $02,%01001000 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $00,%00000010 + !byte $0B,%00010000 + !byte $54,%00000100 + !byte $39,%11001011 + !byte $3E,%00000010 + !byte $3C,%01001000 + !byte $3E,%11000101 + !byte $02,%01011110 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $55,%01100110 + !byte $55,%10000111; + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $33,%00010000 + !byte $00,%11000101 + !byte $3C,%01011110 + !byte $3E,%10110011 + !byte $21,%01001000 + !byte $08,%11101101 + !byte $1D,%01001000 + !byte $36,%11101101 + !byte $2A,%01100010 + !byte $2A,%10000011; + !byte $11,%01011100 + !byte $2D,%01011100 + !byte $26,%10100101 + !byte $0A,%10101111 + !byte $04,%01001010 + !byte $3E,%11100001 + !byte $2B,%01111100 + !byte $2B,%10011101; + !byte $18,%10100101 + !byte $03,%11101001 + !byte $00,%11100001 + !byte $34,%10101111 + !byte $54,%00100100 + !byte $13,%01111100 + !byte $13,%10011101; + !byte $11,%11000001 + !byte $3E,%11100101 + !byte $3B,%11101001 + !byte $3D,%11000111 + !byte $6A,%00100100 + !byte $06,%00010010 + !byte $01,%01000000 + !byte $02,%00000000 + !byte $3C,%00000000 + !byte $0F,%01111100 + !byte $0F,%10011101; + !byte $23,%10100111 + !byte $3D,%01000000 + !byte $2F,%01111100 + !byte $2F,%10011101; + !byte $00,%11100101 + !byte $06,%00101100 + !byte $12,%01011100 + !byte $2C,%01011100 + !byte $01,%11000111 + !byte $1B,%10100111 + !byte $3E,%11000001 + !byte $38,%00101100 + !byte $69,%10100111 + !byte $00,%11000001 + !byte $55,%10100111 + !byte $2D,%11000001 + !byte $2B,%00100010 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $25,%11100101 + !byte $38,%00010010 + !byte $36,%00011110 + !byte $6A,%01000100 + !byte $13,%00100010 + !byte $09,%11010001 + !byte $3B,%01011110 + !byte $3E,%00000110 + !byte $54,%01000100 + !byte $0D,%00000000 + !byte $30,%00100000 + !byte $0E,%00100000 + !byte $19,%11100101 + !byte $35,%11010001 + !byte $08,%00011110 + !byte $00,%00000110 + !byte $03,%01011110 + !byte $33,%00110000 + !byte $0B,%00110000 + !byte $00,%10100001 + !byte $31,%00000000 + !byte $0B,%01010000 + !byte $0A,%11111101 + !byte $3D,%00100000 + !byte $33,%01010000 + !byte $3A,%00110010 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $01,%00100000 + !byte $34,%11111101 + !byte $2F,%01000000 + !byte $54,%01100100 + !byte $54,%10000101; + !byte $0F,%01000000 + !byte $3E,%10100001 + !byte $04,%00110010 + !byte $6A,%01100100 + !byte $6A,%10000101; + !byte $02,%01101000 + !byte $02,%10001001; + !byte $06,%00111110 + !byte $34,%10110001 + !byte $3C,%01101000 + !byte $3C,%10001001; + !byte $69,%11000111 + !byte $0A,%10110001 + !byte $38,%00111110 + !byte $3F,%01111110 + !byte $3F,%10011111; + !byte $2C,%11100001 + !byte $01,%11100111 + !byte $12,%11100001 + !byte $1F,%10101001 + !byte $3E,%00100110 + !byte $55,%11000111 + !byte $3D,%11100111 + !byte $35,%01001110 + !byte $0C,%11011101 + !byte $07,%10101101 + !byte $00,%00100110 + !byte $10,%01100000 + !byte $10,%10000001; + !byte $32,%11011101 + !byte $13,%10111101 + !byte $00,%01100000 + !byte $00,%10000001; + !byte $37,%10101101 + !byte $22,%11100111 + !byte $3E,%01100000 + !byte $3E,%10000001; + !byte $2B,%10111101 + !byte $3D,%00000000 + !byte $6A,%10100101 + !byte $15,%10100011 + !byte $1C,%11100111 + !byte $3F,%11000011 + !byte $00,%01111110 + !byte $00,%10011111; + !byte $01,%00000000 + !byte $3E,%01111110 + !byte $3E,%10011111; + !byte $54,%10100101 + !byte $09,%01001110 + !byte $24,%00100110 + !byte $28,%11100011 + !byte $3F,%10100011 + !byte $16,%11100011 + !byte $1A,%00100110 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $3F,%11100011 + !byte $03,%00001010 + !byte $27,%00100100 + !byte $2E,%01100000 + !byte $2E,%10000001; + !byte $3B,%00001010 + !byte $3F,%01000010 + !byte $3A,%01011110 + !byte $17,%00100100 + !byte $3F,%00000100 + !byte $20,%01101000 + !byte $20,%10001001; + !byte $04,%01101010 + !byte $04,%10001011; + !byte $1E,%01101000 + !byte $1E,%10001001; + !byte $3A,%01101010 + !byte $3A,%10001011; + !byte $3F,%00100010 + !byte $04,%01011110 + !byte $37,%11110001 + !byte $69,%11100111 + !byte $3E,%01000000 + !byte $54,%11000101 + !byte $2A,%01000010 + !byte $3C,%01010010 + !byte $3E,%01000110 + !byte $07,%11110001 + !byte $00,%01000000 + !byte $3F,%00100100 + !byte $05,%11101011 + !byte $29,%10100011 + !byte $6A,%11000101 + !byte $55,%11100111 + !byte $14,%01000010 + !byte $34,%11001111 + !byte $3F,%00000010 + !byte $3D,%01111110 + !byte $3D,%10011111; + !byte $02,%01010010 + !byte $00,%01000110 + !byte $39,%11101011 + !byte $3F,%10110011 + !byte $0E,%10111101 + !byte $01,%00001000 + !byte $21,%00101000 + !byte $1D,%00101000 + !byte $3D,%00001000 + !byte $30,%10111101 + !byte $01,%01111110 + !byte $01,%10011111; + !byte $3F,%01000100 + !byte $3F,%11100001 + !byte $2D,%10100001 + !byte $0A,%11001111 + !byte $10,%01111100 + !byte $10,%10011101; + !byte $26,%01100100 + !byte $26,%10000101; + !byte $2E,%01111100 + !byte $2E,%10011101; + !byte $13,%11011101 + !byte $2B,%11011101 + !byte $11,%10100001 + !byte $3E,%00100000 + !byte $6A,%11100101 + !byte $2B,%00000010 + !byte $00,%00100000 + !byte $18,%01100100 + !byte $18,%10000101; + !byte $02,%10101001 + !byte $37,%00111110 + !byte $3C,%10101001 + !byte $54,%11100101 + !byte $13,%00000010 + !byte $08,%00001110 + !byte $30,%00000000 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $09,%00011110 + !byte $35,%00011110 + !byte $0E,%00000000 + !byte $3F,%11000001 + !byte $36,%00001110 + !byte $06,%01001100 + !byte $07,%00111110 + !byte $39,%00010010 + !byte $00,%01100110 + !byte $00,%10000111; + !byte $23,%01100110 + !byte $23,%10000111; + !byte $38,%01001100 + !byte $2C,%01111100 + !byte $2C,%10011101; + !byte $3E,%01100110 + !byte $3E,%10000111; + !byte $12,%01111100 + !byte $12,%10011101; + !byte $02,%01111110 + !byte $02,%10011111; + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $3C,%01111110 + !byte $3C,%10011111; + !byte $3F,%10100101 + !byte $2F,%00100000 + !byte $05,%00010010 + !byte $3F,%10100001 + !byte $00,%00000000 + !byte $25,%11000101 + !byte $0F,%00100000 + !byte $3E,%00000000 + !byte $54,%00000110 + !byte $05,%01011110 + !byte $19,%11000101 + !byte $39,%01011110 + !byte $6A,%00000110 + !byte $0B,%11111101 + !byte $2B,%11111101 + !byte $33,%11111101 + !byte $13,%11111101 + !byte $3E,%01110010 + !byte $3E,%10010011; + !byte $08,%11010001 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $00,%01110010 + !byte $00,%10010011; + !byte $0A,%01110000 + !byte $0A,%10010001; + !byte $03,%00101010 + !byte $3F,%11000101 + !byte $11,%01111100 + !byte $11,%10011101; + !byte $54,%00100110 + !byte $2E,%01000000 + !byte $2D,%01111100 + !byte $2D,%10011101; + !byte $10,%01000000 + !byte $01,%00101000 + !byte $3B,%00101010 + !byte $34,%01110000 + !byte $34,%10010001; + !byte $2C,%11000001 + !byte $3D,%00101000 + !byte $6A,%00100110 + !byte $3B,%00110010 + !byte $04,%10101011 + !byte $12,%11000001 + !byte $36,%11010001 + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $3A,%10101011 + !byte $00,%10100111 + !byte $3E,%10100111 + !byte $03,%00110010 + !byte $3C,%11001001 + !byte $3F,%01000000 + !byte $07,%11001101 + !byte $13,%00011110 + !byte $2B,%00011110 + !byte $0A,%11101111 + !byte $0D,%11011101 + !byte $31,%11011101 + !byte $37,%11001101 + !byte $34,%11101111 + !byte $16,%11000011 + !byte $03,%01111110 + !byte $03,%10011111; + !byte $3F,%10111111 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $3B,%01111110 + !byte $3B,%10011111; + !byte $35,%01101110 + !byte $35,%10001111; + !byte $39,%00001100 + !byte $3F,%11100101 + !byte $09,%10110001 + !byte $22,%11000111 + !byte $6A,%01000110 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $20,%01001000 + !byte $02,%11001001 + !byte $1E,%01001000 + !byte $24,%00000110 + !byte $14,%00100010 + !byte $35,%10110001 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $13,%00111110 + !byte $15,%01100010 + !byte $15,%10000011; + !byte $3F,%00100000 + !byte $2B,%00111110 + !byte $1A,%00000110 + !byte $1C,%11000111 + !byte $54,%01000110 + !byte $28,%11000011 + !byte $0F,%10111101 + !byte $3D,%01010010 + !byte $2F,%10111101 + !byte $38,%11110001 + !byte $3E,%10111111 + !byte $05,%00001100 + !byte $01,%01010010 + !byte $2A,%00100010 + !byte $27,%00000100 + !byte $2B,%01011110 + !byte $13,%01011110 + !byte $00,%10111111 + !byte $06,%11110001 + !byte $01,%01001000 + !byte $00,%11000111 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $3E,%11000111 + !byte $3D,%01001000 + !byte $17,%00000100 + !byte $08,%00111110 + !byte $2F,%00000000 + !byte $3F,%00000110 + !byte $2B,%01111110 + !byte $2B,%10011111; + !byte $13,%01111110 + !byte $13,%10011111; + !byte $36,%00111110 + !byte $06,%01011110 + !byte $0F,%00000000 + !byte $26,%01000100 + !byte $54,%01100110 + !byte $54,%10000111; + !byte $3F,%00000000 + !byte $38,%01011110 + !byte $21,%00001000 + !byte $13,%10111111 + !byte $1D,%00001000 + !byte $18,%01000100 + !byte $2B,%10111111 + !byte $6A,%01100110 + !byte $6A,%10000111; + !byte $53,%01000000 + !byte $53,%00100000 + !byte $53,%00000000 + !byte $13,%11111111 + !byte $13,%11011111 + !byte $6B,%01000000 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $6B,%10100001 + !byte $53,%11000001 + !byte $6B,%11000001 + !byte $53,%10100001 + !byte $53,%01100000 + !byte $53,%10000001; + !byte $2B,%11011111 + !byte $2B,%11111111 + !byte $6B,%00000000 + !byte $6B,%00100000 + !byte $0A,%00011110 + !byte $6B,%11100001 + !byte $2B,%11100001 + !byte $12,%10111101 + !byte $53,%11100001 + !byte $34,%00011110 + !byte $2C,%10111101 + !byte $34,%01010000 + !byte $53,%00000010 + !byte $0A,%01010000 + !byte $13,%11100001 + !byte $6B,%00000010 + !byte $34,%00010000 + !byte $53,%00100010 + !byte $0A,%00010000 + !byte $3A,%00010010 + !byte $04,%00010010 + !byte $3A,%01111110 + !byte $3A,%10011111; + !byte $6B,%00100010 + !byte $01,%10111111 + !byte $06,%01101100 + !byte $06,%10001101; + !byte $53,%01000010 + !byte $6B,%01000010 + !byte $3D,%10111111 + !byte $38,%01101100 + !byte $38,%10001101; + !byte $3B,%01001010 + !byte $54,%10100111 + !byte $08,%00101110 + !byte $10,%00100000 + !byte $6A,%10100111 + !byte $53,%01100010 + !byte $53,%10000011; + !byte $04,%01111110 + !byte $04,%10011111; + !byte $02,%11101001 + !byte $2C,%10100001 + !byte $36,%00101110 + !byte $3F,%00100110 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $23,%01000110 + !byte $12,%10100001 + !byte $3C,%11101001 + !byte $53,%10100011 + !byte $32,%11111101 + !byte $04,%11001011 + !byte $6B,%10100011 + !byte $1B,%01000110 + !byte $0A,%00110000 + !byte $34,%00110000 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $19,%10100101 + !byte $2E,%00100000 + !byte $03,%01001010 + !byte $3A,%11001011 + !byte $53,%11000011 + !byte $0C,%11111101 + !byte $6B,%11000011 + !byte $54,%11000111 + !byte $6A,%11000111 + !byte $00,%11100111 + !byte $3E,%11100111 + !byte $2E,%10111101 + !byte $53,%11100011 + !byte $25,%10100101 + !byte $10,%10111101 + !byte $1F,%01001000 + !byte $6B,%11100011 + !byte $37,%11010001 + !byte $09,%10101111 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $35,%10101111 + !byte $3C,%10111111 + !byte $02,%10111111 + !byte $07,%11010001 + !byte $3F,%01000110 + !byte $3C,%00110010 + !byte $30,%11011101 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $53,%00000100 + !byte $29,%01000010 + !byte $02,%00110010 + !byte $15,%01000010 + !byte $6B,%00000100 + !byte $0E,%11011101 + !byte $6A,%11100111 + !byte $05,%00101100 + !byte $2D,%01000000 + !byte $54,%11100111 + !byte $11,%10111101 + !byte $2D,%10111101 + !byte $11,%01000000 + !byte $28,%10100011 + !byte $39,%00101100 + !byte $1E,%00101000 + !byte $2A,%00000010 + !byte $07,%01011110 + !byte $09,%00111110 + !byte $16,%10100011 + !byte $53,%00100100 + !byte $6B,%00100100 + !byte $07,%11101101 + !byte $37,%01011110 + !byte $35,%00111110 + !byte $1A,%11100101 + !byte $14,%00000010 + !byte $20,%00101000 + !byte $22,%10100111 + !byte $37,%11101101 + !byte $05,%01111110 + !byte $05,%10011111; + !byte $39,%01111110 + !byte $39,%10011111; + !byte $12,%11011101 + !byte $2C,%11011101 + !byte $6B,%01000100 + !byte $3F,%11011111 + !byte $27,%11100011 + !byte $39,%11110001 + !byte $1C,%10100111 + !byte $3E,%01010010 + !byte $53,%01000100 + !byte $08,%10110001 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $09,%01110000 + !byte $09,%10010001; + !byte $2B,%11000001 + !byte $17,%11100011 + !byte $00,%01010010 + !byte $00,%00001000 + !byte $36,%10110001 + !byte $05,%11110001 + !byte $13,%11000001 + !byte $3E,%00001000 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $02,%00001010 + !byte $53,%01100100 + !byte $53,%10000101; + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $24,%11100101 + !byte $0B,%00011110 + !byte $3C,%00001010 + !byte $18,%00100100 + !byte $33,%00011110 + !byte $03,%10111111 + !byte $3B,%10111111 + !byte $00,%11011111 + !byte $21,%11100111 + !byte $3E,%11011111 + !byte $2E,%00000000 + !byte $3D,%10101001 + !byte $10,%00000000 + !byte $1D,%11100111 + !byte $03,%01101010 + !byte $03,%10001011; + !byte $6B,%10100101 + !byte $53,%10100101 + !byte $06,%10101101 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $26,%00100100 + !byte $38,%10101101 + !byte $08,%01001110 + !byte $01,%10101001 + !byte $3B,%00010010 + !byte $2C,%01100000 + !byte $2C,%10000001; + !byte $53,%11000101 + !byte $36,%01001110 + !byte $6B,%11000101 + !byte $35,%11001111 + !byte $12,%01100000 + !byte $12,%10000001; + !byte $03,%00010010 + !byte $23,%00100110 + !byte $04,%11101011 + !byte $09,%11001111 + !byte $3A,%11101011 + !byte $1B,%00100110 + !byte $0D,%11111101 + !byte $12,%11111101 + !byte $3E,%00101000 + !byte $2F,%11011101 + !byte $31,%11111101 + !byte $2C,%11111101 + !byte $0F,%11011101 + !byte $3F,%10100111 + !byte $38,%01111110 + !byte $38,%10011111; + !byte $11,%00100000 + !byte $53,%11100101 + !byte $6B,%11100101 + !byte $01,%11011111 + !byte $1F,%00101000 + !byte $3D,%11011111 + !byte $01,%00110010 + !byte $00,%00101000 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $06,%01111110 + !byte $06,%10011111; + !byte $15,%00100010 + !byte $08,%01011110 + !byte $06,%11010001 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $36,%01011110 + !byte $2A,%11100001 + !byte $04,%10111111 + !byte $53,%00000110 + !byte $6B,%00000110 + !byte $28,%01100010 + !byte $28,%10000011; + !byte $38,%11010001 + !byte $14,%11100001 + !byte $2D,%00100000 + !byte $3D,%00110010 + !byte $3A,%10111111 + !byte $35,%01010000 + !byte $09,%01010000 + !byte $16,%01100010 + !byte $16,%10000011; + !byte $29,%00100010 + !byte $0A,%00111110 + !byte $05,%01001100 + !byte $07,%00001110 + !byte $11,%11011101 + !byte $34,%00111110 + !byte $20,%00001000 + !byte $39,%01001100 + !byte $02,%00101010 + !byte $13,%10100001 + !byte $3C,%00101010 + !byte $1E,%00001000 + !byte $37,%00001110 + !byte $2D,%11011101 + !byte $27,%11000011 + !byte $01,%11001001 + !byte $6B,%00100110 + !byte $3D,%11001001 + !byte $17,%11000011 + !byte $53,%00100110 + !byte $04,%11110001 + !byte $09,%11101111 + !byte $1A,%11000101 + !byte $35,%11101111 + !byte $2E,%11011101 + !byte $12,%00011110 + !byte $3F,%11000111 + !byte $2C,%00011110 + !byte $10,%11011101 + !byte $22,%01100110 + !byte $22,%10000111; + !byte $3A,%11110001 + !byte $2B,%10100001 + !byte $1C,%01100110 + !byte $1C,%10000111; + !byte $03,%10101011 + !byte $02,%11011111 + !byte $3F,%01010010 + !byte $3C,%11011111 + !byte $53,%01000110 + !byte $3B,%10101011 + !byte $21,%11000111 + !byte $3F,%11111111 + !byte $6B,%01000110 + !byte $00,%01001000 + !byte $24,%11000101 + !byte $2C,%01000000 + !byte $3E,%01001000 + !byte $07,%10110001 + !byte $1D,%11000111 + !byte $0C,%00011110 + !byte $37,%10110001 + !byte $08,%01110000 + !byte $08,%10010001; + !byte $12,%01000000 + !byte $35,%00110000 + !byte $09,%00110000 + !byte $36,%01110000 + !byte $36,%10010001; + !byte $32,%00011110 + !byte $02,%00010010 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $08,%01101110 + !byte $08,%10001111; + !byte $26,%00000100 + !byte $09,%00010000 + !byte $35,%00010000 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $36,%01101110 + !byte $36,%10001111; + !byte $06,%11001101 + !byte $18,%00000100 + !byte $3A,%00001100 + !byte $0E,%11111101 + !byte $3C,%00010010 + !byte $38,%11001101 + !byte $30,%11111101 + !byte $37,%01111110 + !byte $37,%10011111; + !byte $12,%00111110 + !byte $2C,%00111110 + !byte $05,%10111111 + !byte $3F,%11100111 + !byte $07,%01111110 + !byte $07,%10011111; + !byte $39,%10111111 + !byte $00,%11111111 + !byte $04,%00001100 + !byte $6B,%10100111 + !byte $2D,%00000000 + !byte $23,%00000110 + !byte $3E,%11111111 + !byte $53,%10100111 + !byte $1B,%00000110 + !byte $11,%00000000 + !byte $35,%01011110 + !byte $1F,%00001000 + !byte $03,%11011111 + !byte $3B,%11011111 + !byte $05,%11010001 + !byte $09,%01011110 + !byte $01,%11101001 + !byte $25,%01000100 + !byte $3D,%11101001 + !byte $02,%01001010 + !byte $19,%01000100 + !byte $00,%00110010 + !byte $16,%01000010 + !byte $39,%11010001 + !byte $53,%11000111 + !byte $12,%01011110 + !byte $29,%00000010 + !byte $3C,%01001010 + !byte $2C,%01011110 + !byte $3E,%01101000 + !byte $3E,%10001001; + !byte $6B,%11000111 + !byte $3E,%00110010 + !byte $15,%00000010 + !byte $2A,%11000001 + !byte $2D,%11111101 + !byte $11,%11111101 + !byte $20,%11100111 + !byte $33,%00111110 + !byte $00,%01101000 + !byte $00,%10001001; + !byte $14,%11000001 + !byte $1E,%11100111 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $05,%01101100 + !byte $05,%10001101; + !byte $01,%11111111 + !byte $53,%11100111 + !byte $17,%10100011 + !byte $3D,%11111111 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $28,%01000010 + !byte $6B,%11100111 + !byte $07,%00101110 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $03,%11001011 + !byte $0B,%00111110 + !byte $1C,%01000110 + !byte $3B,%11001011 + !byte $37,%00101110 + !byte $2C,%01111110 + !byte $2C,%10011111; + !byte $12,%01111110 + !byte $12,%10011111; + !byte $3F,%00001000 + !byte $12,%00100000 + !byte $0F,%11111101 + !byte $2F,%11111101 + !byte $08,%10101111 + !byte $36,%10101111 + !byte $03,%11110001 + !byte $22,%01000110 + !byte $3B,%11110001 + !byte $12,%10111111 + !byte $2C,%10111111 + !byte $27,%10100011 + !byte $0D,%00011110 + !byte $31,%00011110 + !byte $36,%01010000 + !byte $08,%01010000 + !byte $38,%10111111 + !byte $2C,%00100000 + !byte $24,%10100101 + !byte $21,%10100111 + !byte $38,%10110001 + !byte $2C,%11011111 + !byte $04,%11011111 + !byte $3D,%00010010 + !byte $12,%11011111 + !byte $1A,%10100101 + !byte $1D,%10100111 + !byte $3A,%11011111 + !byte $06,%10111111 + !byte $06,%10110001 + !byte $2E,%11111101 + !byte $10,%11111101 + !byte $26,%11100011 + !byte $18,%11100011 + !byte $2C,%11111111 + !byte $01,%00010010 + !byte $12,%11111111 + !byte $08,%01111110 + !byte $08,%10011111; + !byte $36,%01111110 + !byte $36,%10011111; + !byte $6C,%00000000 + !byte $52,%00000000 + !byte $7F,%00000000 + !byte $04,%00101100 + !byte $52,%00000010 + !byte $52,%11100001 + !byte $6C,%00100000 + !byte $6C,%01000000 + !byte $6C,%00100010 + !byte $52,%11000001 + !byte $52,%10100001 + !byte $6C,%10100001 + !byte $6C,%11000001 + !byte $52,%00100010 + !byte $52,%01000000 + !byte $52,%00100000 + !byte $6C,%11100001 + !byte $6C,%00000010 + !byte $3A,%00101100 + !byte $6C,%01100000 + !byte $6C,%10000001; + !byte $52,%01000010 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $6C,%01000010 + !byte $52,%01100000 + !byte $52,%10000001; + !byte $02,%11111111 + !byte $52,%01100010 + !byte $52,%10000011; + !byte $07,%01110000 + !byte $07,%10010001; + !byte $6C,%01100010 + !byte $6C,%10000011; + !byte $00,%10101001 + !byte $3E,%10101001 + !byte $3C,%11111111 + !byte $01,%00001010 + !byte $6C,%10100011 + !byte $52,%10100011 + !byte $6C,%11000011 + !byte $52,%11000011 + !byte $3D,%00001010 + !byte $06,%11101101 + !byte $34,%01011110 + !byte $52,%11100011 + !byte $6C,%11100011 + !byte $38,%11101101 + !byte $1F,%11100111 + !byte $3C,%01101010 + !byte $3C,%10001011; + !byte $23,%11100101 + !byte $6C,%00000100 + !byte $2D,%00011110 + !byte $52,%00000100 + !byte $11,%00011110 + !byte $29,%11100001 + !byte $08,%11001111 + !byte $2A,%10100001 + !byte $04,%11010001 + !byte $3F,%00101000 + !byte $6C,%00100100 + !byte $1B,%11100101 + !byte $0A,%01011110 + !byte $36,%11001111 + !byte $25,%00100100 + !byte $52,%00100100 + !byte $15,%11100001 + !byte $14,%10100001 + !byte $2B,%01000000 + !byte $3A,%11010001 + !byte $52,%01000100 + !byte $13,%01000000 + !byte $02,%01101010 + !byte $02,%10001011; + !byte $19,%00100100 + !byte $6C,%01000100 + !byte $3F,%00110010 + !byte $40,%00000000 + !byte $7E,%00000000 + !byte $36,%00110000 + !byte $52,%01100100 + !byte $52,%10000101; + !byte $08,%00110000 + !byte $0C,%00111110 + !byte $6C,%01100100 + !byte $6C,%10000101; + !byte $28,%00100010 + !byte $32,%00111110 + !byte $20,%11000111 + !byte $07,%01001110 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $1E,%11000111 + !byte $30,%00011110 + !byte $16,%00100010 + !byte $37,%01001110 + !byte $39,%11011111 + !byte $05,%10101101 + !byte $52,%10100101 + !byte $6C,%10100101 + !byte $0E,%00011110 + !byte $39,%10101101 + !byte $2C,%00000000 + !byte $22,%00100110 + !byte $03,%11111111 + !byte $3C,%11110001 + !byte $03,%11101011 + !byte $3B,%11111111 + !byte $6C,%11000101 + !byte $1C,%00100110 + !byte $37,%10111111 + !byte $05,%11011111 + !byte $02,%11110001 + !byte $52,%11000101 + !byte $36,%11101111 + !byte $12,%00000000 + !byte $3B,%11101011 + !byte $08,%11101111 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $1A,%01100100 + !byte $1A,%10000101; + !byte $08,%00010000 + !byte $07,%10111111 + !byte $36,%00010000 + !byte $52,%11100101 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $6C,%11100101 + !byte $00,%11001001 + !byte $3F,%01001000 + !byte $35,%01111110 + !byte $35,%10011111; + !byte $24,%01100100 + !byte $24,%10000101; + !byte $3E,%11001001 + !byte $6C,%00000110 + !byte $05,%10110001 + !byte $2D,%00111110 + !byte $26,%11000011 + !byte $11,%00111110 + !byte $01,%00101010 + !byte $21,%01100110 + !byte $21,%10000111; + !byte $7D,%00000000 + !byte $41,%00000000 + !byte $52,%00000110 + !byte $3E,%00010010 + !byte $3D,%00101010 + !byte $18,%11000011 + !byte $09,%01111110 + !byte $09,%10011111; + !byte $2E,%00011110 + !byte $10,%00011110 + !byte $39,%10110001 + !byte $52,%00100110 + !byte $00,%00010010 + !byte $0F,%00011110 + !byte $2F,%00011110 + !byte $6C,%00100110 + !byte $06,%00001110 + !byte $04,%01001100 + !byte $38,%00001110 + !byte $3A,%01001100 + !byte $1F,%11000111 + !byte $29,%11000001 + !byte $2A,%01100000 + !byte $2A,%10000001; + !byte $37,%01010000 + !byte $6C,%01000110 + !byte $07,%01010000 + !byte $06,%01110000 + !byte $06,%10010001; + !byte $14,%01100000 + !byte $14,%10000001; + !byte $15,%11000001 + !byte $52,%01000110 + !byte $13,%00100000 + !byte $02,%10101011 + !byte $0B,%01011110 + !byte $38,%01110000 + !byte $38,%10010001; + !byte $37,%01101110 + !byte $37,%10001111; + !byte $33,%01011110 + !byte $03,%11010001 + !byte $3C,%10101011 + !byte $23,%11000101 + !byte $7F,%00100000 + !byte $52,%01100110 + !byte $52,%10000111; + !byte $25,%00000100 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $3B,%11010001 + !byte $1B,%11000101 + !byte $6C,%01100110 + !byte $6C,%10000111; + !byte $0D,%00111110 + !byte $31,%00111110 + !byte $06,%11011111 + !byte $19,%00000100 + !byte $28,%00000010 + !byte $38,%11011111 + !byte $2B,%00100000 + !byte $04,%11111111 + !byte $2D,%01011110 + !byte $3A,%11111111 + !byte $20,%10100111 + !byte $6C,%10100111 + !byte $16,%00000010 + !byte $1E,%10100111 + !byte $11,%01011110 + !byte $52,%10100111 + !byte $42,%00000000 + !byte $03,%00001100 + !byte $7C,%00000000 + !byte $3B,%00001100 + !byte $05,%11001101 + !byte $39,%11001101 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $08,%10111111 + !byte $00,%11101001 + !byte $27,%01000010 + !byte $01,%11110001 + !byte $36,%10111111 + !byte $52,%11000111 + !byte $22,%00000110 + !byte $17,%01000010 + !byte $3E,%11101001 + !byte $6C,%11000111 + !byte $3D,%11110001 + !byte $1C,%00000110 + !byte $1A,%01000100 + !byte $01,%01001010 + !byte $40,%00100000 + !byte $3D,%01001010 + !byte $52,%11100111 + !byte $6C,%11100111 + !byte $7E,%00100000 + !byte $21,%01000110 + !byte $1D,%01000110 + !byte $2D,%01111110 + !byte $2D,%10011111; + !byte $34,%01111110 + !byte $34,%10011111; + !byte $04,%10110001 + !byte $11,%01111110 + !byte $11,%10011111; + !byte $26,%10100011 + !byte $07,%00110000 + !byte $37,%00110000 + !byte $37,%10101111 + !byte $24,%01000100 + !byte $18,%10100011 + !byte $3A,%10110001 + !byte $2E,%00111110 + !byte $0A,%01111110 + !byte $0A,%10011111; + !byte $07,%10101111 + !byte $10,%00111110 + !byte $3F,%00010010 + !byte $38,%00101110 + !byte $0E,%00111110 + !byte $30,%00111110 + !byte $06,%00101110 + !byte $1F,%10100111 + !byte $0C,%01011110 + !byte $14,%01000000 + !byte $02,%11001011 + !byte $32,%01011110 + !byte $05,%11111111 + !byte $15,%10100001 + !byte $39,%11111111 + !byte $04,%01101100 + !byte $04,%10001101; + !byte $3C,%11001011 + !byte $43,%00000000 + !byte $3A,%01101100 + !byte $3A,%10001101; + !byte $7B,%00000000 + !byte $11,%10111111 + !byte $2D,%10111111 + !byte $07,%11011111 + !byte $41,%00100000 + !byte $2B,%00000000 + !byte $2A,%01000000 + !byte $7D,%00100000 + !byte $37,%11011111 + !byte $13,%00000000 + !byte $29,%10100001 + !byte $0F,%00111110 + !byte $2F,%00111110 + !byte $3E,%00001010 + !byte $28,%11100001 + !byte $02,%11010001 + !byte $25,%11100011 + !byte $20,%01100110 + !byte $20,%10000111; + !byte $23,%10100101 + !byte $37,%11001111 + !byte $16,%11100001 + !byte $19,%11100011 + !byte $1E,%01100110 + !byte $1E,%10000111; + !byte $39,%01110000 + !byte $39,%10010001; + !byte $05,%01110000 + !byte $05,%10010001; + !byte $07,%11001111 + !byte $1B,%10100101 + !byte $3C,%11010001 + !byte $37,%00010000 + !byte $3F,%10101001 + !byte $07,%00010000 + !byte $06,%01010000 + !byte $38,%01010000 + !byte $2D,%11011111 + !byte $11,%11011111 + !byte $3E,%11110001 + !byte $00,%00001010 + !byte $35,%10111111 + !byte $00,%11110001 + !byte $05,%11101101 + !byte $39,%11101101 + !byte $07,%11101111 + !byte $37,%11101111 + !byte $7F,%01000000 + !byte $03,%00101100 + !byte $27,%00100010 + !byte $09,%10111111 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $17,%00100010 + !byte $3B,%00101100 + !byte $11,%11111111 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $2D,%11111111 + !byte $22,%11100101 + !byte $1D,%00100110 + !byte $1C,%11100101 + !byte $1A,%00100100 + !byte $2E,%01011110 + !byte $10,%01011110 + !byte $06,%01001110 + !byte $38,%01001110 + !byte $44,%00000000 + !byte $51,%00000000 + !byte $0D,%01011110 + !byte $6D,%00000000 + !byte $0B,%01111110 + !byte $0B,%10011111; + !byte $21,%00100110 + !byte $3B,%10110001 + !byte $7A,%00000000 + !byte $33,%01111110 + !byte $33,%10011111; + !byte $31,%01011110 + !byte $26,%01100010 + !byte $26,%10000011; + !byte $42,%00100000 + !byte $18,%01100010 + !byte $18,%10000011; + !byte $7C,%00100000 + !byte $03,%10110001 + !byte $24,%00100100 + !byte $51,%00100000 + !byte $6D,%00100000 + !byte $06,%11111111 + !byte $14,%00100000 + !byte $02,%11101011 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $3C,%11101011 + !byte $3F,%11001001 + !byte $38,%11111111 + !byte $3A,%10101101 + !byte $51,%01000000 + !byte $6D,%01000000 + !byte $51,%01100000 + !byte $51,%10000001; + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $40,%01000000 + !byte $51,%10100011 + !byte $6D,%01000010 + !byte $6D,%11000011 + !byte $51,%01100010 + !byte $51,%10000011; + !byte $51,%10100001 + !byte $7E,%01000000 + !byte $6D,%10100001 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $51,%11000011 + !byte $51,%01000010 + !byte $2A,%00100000 + !byte $6D,%10100011 + !byte $51,%00100010 + !byte $6D,%00100010 + !byte $51,%00000010 + !byte $51,%11100001 + !byte $51,%11100011 + !byte $51,%11000001 + !byte $6D,%11000001 + !byte $6D,%11100011 + !byte $00,%00101010 + !byte $6D,%11100001 + !byte $6D,%00000010 + !byte $51,%00000100 + !byte $04,%10101101 + !byte $6D,%00000100 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $3E,%00101010 + !byte $6D,%00100100 + !byte $51,%00100100 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $3D,%11010001 + !byte $51,%01000100 + !byte $6D,%01000100 + !byte $28,%11000001 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $08,%11011111 + !byte $38,%00110000 + !byte $51,%01100100 + !byte $51,%10000101; + !byte $06,%00110000 + !byte $1E,%01000110 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $36,%11011111 + !byte $01,%11010001 + !byte $16,%11000001 + !byte $04,%01110000 + !byte $04,%10010001; + !byte $6D,%10100101 + !byte $51,%10100101 + !byte $25,%11000011 + !byte $20,%01000110 + !byte $3A,%01110000 + !byte $3A,%10010001; + !byte $0E,%01011110 + !byte $0F,%01011110 + !byte $30,%01011110 + !byte $2F,%01011110 + !byte $23,%01100100 + !byte $23,%10000101; + !byte $51,%11000101 + !byte $19,%11000011 + !byte $6D,%11000101 + !byte $2E,%01111110 + !byte $2E,%10011111; + !byte $6D,%11100101 + !byte $10,%01111110 + !byte $10,%10011111; + !byte $34,%10111111 + !byte $51,%11100101 + !byte $3B,%01001100 + !byte $06,%01101110 + !byte $06,%10001111; + !byte $3F,%11110001 + !byte $38,%01101110 + !byte $38,%10001111; + !byte $01,%10101011 + !byte $51,%00000110 + !byte $6D,%00000110 + !byte $27,%00000010 + !byte $05,%00001110 + !byte $39,%01010000 + !byte $43,%00100000 + !byte $05,%01010000 + !byte $3D,%10101011 + !byte $0A,%10111111 + !byte $1C,%11000101 + !byte $39,%00001110 + !byte $7B,%00100000 + !byte $0C,%01111110 + !byte $0C,%10011111; + !byte $17,%00000010 + !byte $51,%00100110 + !byte $32,%01111110 + !byte $32,%10011111; + !byte $6D,%00100110 + !byte $03,%01001100 + !byte $51,%01000110 + !byte $6D,%01000110 + !byte $45,%00000000 + !byte $79,%00000000 + !byte $24,%00000100 + !byte $41,%01000000 + !byte $21,%00000110 + !byte $1A,%00000100 + !byte $7D,%01000000 + !byte $1D,%00000110 + !byte $22,%11000101 + !byte $3C,%10110001 + !byte $26,%01000010 + !byte $51,%01100110 + !byte $51,%10000111; + !byte $02,%10110001 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $06,%00010000 + !byte $3F,%11101001 + !byte $38,%00010000 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $07,%11111111 + !byte $37,%11111111 + !byte $18,%01000010 + !byte $51,%10100111 + !byte $1F,%01000110 + !byte $6D,%10100111 + !byte $06,%10101111 + !byte $2E,%10111111 + !byte $10,%10111111 + !byte $2A,%00000000 + !byte $38,%10101111 + !byte $00,%01001010 + !byte $14,%00000000 + !byte $51,%11000111 + !byte $29,%01000000 + !byte $3E,%01001010 + !byte $6D,%11000111 + !byte $02,%00001100 + !byte $00,%11010001 + !byte $04,%11001101 + !byte $15,%01000000 + !byte $09,%11011111 + !byte $3C,%00001100 + !byte $35,%11011111 + !byte $51,%11100111 + !byte $28,%10100001 + !byte $3A,%11001101 + !byte $6D,%11100111 + !byte $06,%11101111 + !byte $23,%01000100 + !byte $16,%10100001 + !byte $38,%11101111 + !byte $3E,%11010001 + !byte $1B,%01000100 + !byte $20,%00100110 + !byte $1E,%00100110 + !byte $06,%11001111 + !byte $38,%11001111 + !byte $0D,%01111110 + !byte $0D,%10011111; + !byte $31,%01111110 + !byte $31,%10011111; + !byte $7C,%01000000 + !byte $0F,%01111110 + !byte $0F,%10011111; + !byte $05,%00101110 + !byte $25,%10100011 + !byte $2F,%01111110 + !byte $2F,%10011111; + !byte $39,%00101110 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $19,%10100011 + !byte $42,%01000000 + !byte $0B,%10111111 + !byte $44,%00100000 + !byte $40,%01100000 + !byte $40,%10000001; + !byte $03,%01110000 + !byte $03,%10010001; + !byte $01,%11001011 + !byte $33,%10111111 + !byte $3D,%11001011 + !byte $7E,%01100000 + !byte $7E,%10000001; + !byte $7A,%00100000 + !byte $27,%11100001 + !byte $03,%01101100 + !byte $03,%10001101; + !byte $10,%11011111 + !byte $78,%00000000 + !byte $39,%00110000 + !byte $2E,%11011111 + !byte $05,%00110000 + !byte $17,%11100001 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $0E,%01111110 + !byte $0E,%10011111; + !byte $30,%01111110 + !byte $30,%10011111; + !byte $46,%00000000 + !byte $3A,%01010000 + !byte $22,%10100101 + !byte $04,%01010000 + !byte $1D,%11100101 + !byte $1C,%10100101 + !byte $24,%11100011 + !byte $01,%10110001 + !byte $21,%11100101 + !byte $1A,%11100011 + !byte $36,%11111111 + !byte $3F,%00001010 + !byte $26,%00100010 + !byte $1F,%00100110 + !byte $18,%00100010 + !byte $10,%11111111 + !byte $3D,%10110001 + !byte $08,%11111111 + !byte $2E,%11111111 + !byte $00,%01101010 + !byte $00,%10001011; + !byte $39,%01001110 + !byte $3E,%01101010 + !byte $3E,%10001011; + !byte $02,%00101100 + !byte $29,%00100000 + !byte $3C,%00101100 + !byte $04,%11101101 + !byte $0A,%11011111 + !byte $15,%00100000 + !byte $34,%11011111 + !byte $3A,%11101101 + !byte $3F,%11010001 + !byte $05,%01001110 + !byte $28,%01100000 + !byte $28,%10000001; + !byte $41,%01100000 + !byte $41,%10000001; + !byte $0C,%10111111 + !byte $32,%10111111 + !byte $43,%01000000 + !byte $16,%01100000 + !byte $16,%10000001; + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $7B,%01000000 + !byte $20,%00000110 + !byte $1E,%00000110 + !byte $0F,%10111111 + !byte $45,%00100000 + !byte $79,%00100000 + !byte $2F,%10111111 + !byte $23,%00100100 + !byte $6E,%00000000 + !byte $50,%00000000 + !byte $1B,%00100100 + !byte $39,%00010000 + !byte $7F,%10100001 + !byte $05,%00010000 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $3C,%01110000 + !byte $3C,%10010001; + !byte $19,%01100010 + !byte $19,%10000011; + !byte $02,%01110000 + !byte $02,%10010001; + !byte $27,%11000001 + !byte $50,%00100000 + !byte $17,%11000001 + !byte $6E,%00100000 + !byte $03,%10101101 + !byte $47,%00000000 + !byte $77,%00000000 + !byte $01,%11101011 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $05,%01101110 + !byte $05,%10001111; + !byte $3B,%10101101 + !byte $0D,%10111111 + !byte $3D,%11101011 + !byte $31,%10111111 + !byte $21,%11000101 + !byte $22,%01100100 + !byte $22,%10000101; + !byte $1D,%11000101 + !byte $1C,%01100100 + !byte $1C,%10000101; + !byte $3F,%00101010 + !byte $0E,%10111111 + !byte $50,%01000000 + !byte $6E,%01000000 + !byte $30,%10111111 + !byte $3A,%00110000 + !byte $1F,%00000110 + !byte $04,%00110000 + !byte $09,%11111111 + !byte $03,%01010000 + !byte $24,%11000011 + !byte $35,%11111111 + !byte $3B,%01010000 + !byte $39,%11101111 + !byte $05,%11101111 + !byte $26,%00000010 + !byte $3E,%10110001 + !byte $7E,%10100001 + !byte $42,%01100000 + !byte $42,%10000001; + !byte $04,%00001110 + !byte $1A,%11000011 + !byte $18,%00000010 + !byte $3A,%00001110 + !byte $7C,%01100000 + !byte $7C,%10000001; + !byte $50,%01100000 + !byte $50,%10000001; + !byte $6E,%01100000 + !byte $6E,%10000001; + !byte $00,%10110001 + !byte $33,%11011111 + !byte $44,%01000000 + !byte $29,%00000000 + !byte $2F,%11011111 + !byte $39,%10101111 + !byte $3E,%10101011 + !byte $0F,%11011111 + !byte $40,%10100001 + !byte $05,%10101111 + !byte $7A,%01000000 + !byte $15,%00000000 + !byte $0B,%11011111 + !byte $50,%10100001 + !byte $6E,%10100001 + !byte $05,%11001111 + !byte $39,%11001111 + !byte $50,%11000001 + !byte $6E,%11000001 + !byte $20,%11100101 + !byte $02,%01001100 + !byte $1E,%11100101 + !byte $28,%01000000 + !byte $3C,%01001100 + !byte $16,%01000000 + !byte $6E,%11100001 + !byte $00,%10101011 + !byte $50,%11100001 + !byte $46,%00100000 + !byte $50,%00000010 + !byte $78,%00100000 + !byte $6E,%00000010 + !byte $6E,%11100011 + !byte $50,%00100100 + !byte $6E,%00000100 + !byte $50,%00000100 + !byte $50,%11100011 + !byte $6E,%00100100 + !byte $50,%01000100 + !byte $50,%11000011 + !byte $50,%00100010 + !byte $6E,%01000010 + !byte $6E,%01100010 + !byte $6E,%10000011; + !byte $6E,%01000100 + !byte $50,%10100011 + !byte $6E,%10100011 + !byte $6E,%01100100 + !byte $6E,%10000101; + !byte $50,%01100010 + !byte $50,%10000011; + !byte $50,%01000010 + !byte $6E,%00100010 + !byte $6E,%11000011 + !byte $50,%10100101 + !byte $50,%01100100 + !byte $50,%10000101; + !byte $6E,%10100101 + !byte $6E,%11000101 + !byte $50,%11000101 + !byte $50,%11100101 + !byte $6E,%11100101 + !byte $23,%00000100 + !byte $50,%00000110 + !byte $1B,%00000100 + !byte $6E,%00100110 + !byte $6E,%00000110 + !byte $50,%00100110 + !byte $25,%01000010 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $50,%01000110 + !byte $3F,%01001010 + !byte $6E,%01000110 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $48,%00000000 + !byte $27,%10100001 + !byte $76,%00000000 + !byte $19,%01000010 + !byte $50,%01100110 + !byte $50,%10000111; + !byte $03,%11001101 + !byte $6E,%01100110 + !byte $6E,%10000111; + !byte $3B,%11001101 + !byte $01,%00001100 + !byte $22,%01000100 + !byte $17,%10100001 + !byte $41,%10100001 + !byte $50,%10100111 + !byte $3D,%00001100 + !byte $0F,%11111111 + !byte $04,%00101110 + !byte $32,%11011111 + !byte $1C,%01000100 + !byte $1D,%10100101 + !byte $0C,%11011111 + !byte $7D,%10100001 + !byte $6E,%10100111 + !byte $3A,%00101110 + !byte $2F,%11111111 + !byte $43,%01100000 + !byte $43,%10000001; + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $6E,%11000111 + !byte $50,%11000111 + !byte $3A,%00010000 + !byte $0A,%11111111 + !byte $04,%00010000 + !byte $1F,%11100101 + !byte $3F,%10110001 + !byte $7F,%11000001 + !byte $21,%10100101 + !byte $34,%11111111 + !byte $50,%11100111 + !byte $30,%11011111 + !byte $0E,%11011111 + !byte $6E,%11100111 + !byte $02,%01010000 + !byte $3C,%01010000 + !byte $24,%10100011 + !byte $26,%11100001 + !byte $45,%01000000 + !byte $03,%00110000 + !byte $1A,%10100011 + !byte $18,%11100001 + !byte $3E,%11001011 + !byte $0D,%11011111 + !byte $31,%11011111 + !byte $79,%01000000 + !byte $3B,%00110000 + !byte $3C,%01101100 + !byte $3C,%10001101; + !byte $1E,%11000101 + !byte $28,%00100000 + !byte $20,%11000101 + !byte $00,%11001011 + !byte $16,%00100000 + !byte $47,%00100000 + !byte $77,%00100000 + !byte $04,%01001110 + !byte $6F,%00000000 + !byte $02,%01101100 + !byte $02,%10001101; + !byte $4F,%00000000 + !byte $3A,%01001110 + !byte $1B,%11100011 + !byte $04,%11101111 + !byte $7E,%11000001 + !byte $42,%10100001 + !byte $3A,%11101111 + !byte $3E,%01110000 + !byte $3E,%10010001; + !byte $7C,%10100001 + !byte $23,%11100011 + !byte $03,%11101101 + !byte $40,%11000001 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $3B,%11101101 + !byte $0B,%11111111 + !byte $33,%11111111 + !byte $00,%01110000 + !byte $00,%10010001; + !byte $49,%00000000 + !byte $25,%00100010 + !byte $01,%00101100 + !byte $75,%00000000 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $7A,%01100000 + !byte $7A,%10000001; + !byte $3D,%00101100 + !byte $19,%00100010 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $21,%01100100 + !byte $21,%10000101; + !byte $44,%01100000 + !byte $44,%10000001; + !byte $04,%01101110 + !byte $04,%10001111; + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $1F,%11000101 + !byte $22,%00100100 + !byte $30,%11111111 + !byte $4F,%00100000 + !byte $0E,%11111111 + !byte $3A,%01101110 + !byte $3A,%10001111; + !byte $1C,%00100100 + !byte $6F,%00100000 + !byte $3A,%11001111 + !byte $04,%11001111 + !byte $1A,%01100010 + !byte $1A,%10000011; + !byte $3A,%10101111 + !byte $3D,%01010000 + !byte $04,%10101111 + !byte $01,%01010000 + !byte $46,%01000000 + !byte $26,%11000001 + !byte $78,%01000000 + !byte $24,%01100010 + !byte $24,%10000011; + !byte $18,%11000001 + !byte $3B,%00010000 + !byte $02,%10101101 + !byte $0C,%11111111 + !byte $03,%00010000 + !byte $32,%11111111 + !byte $4F,%01000000 + !byte $3C,%10101101 + !byte $6F,%01000000 + !byte $20,%10100101 + !byte $28,%00000000 + !byte $1E,%10100101 + !byte $76,%00100000 + !byte $16,%00000000 + !byte $00,%11101011 + !byte $7D,%11000001 + !byte $0D,%11111111 + !byte $3E,%11101011 + !byte $31,%11111111 + !byte $3C,%00110000 + !byte $7F,%11100001 + !byte $48,%00100000 + !byte $02,%00110000 + !byte $03,%00001110 + !byte $3B,%00001110 + !byte $74,%00000000 + !byte $41,%11000001 + !byte $7B,%10100001 + !byte $23,%11000011 + !byte $19,%00000010 + !byte $1B,%11000011 + !byte $4A,%00000000 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $43,%10100001 + !byte $3F,%10101011 + !byte $45,%01100000 + !byte $45,%10000001; + !byte $4E,%00000000 + !byte $70,%00000000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $1C,%00000100 + !byte $21,%01000100 + !byte $27,%01000000 + !byte $1D,%01000100 + !byte $25,%00000010 + !byte $17,%01000000 + !byte $1F,%10100101 + !byte $4F,%10100001 + !byte $6F,%10100001 + !byte $01,%01001100 + !byte $3D,%01001100 + !byte $22,%00000100 + !byte $03,%11101111 + !byte $4F,%11000001 + !byte $1A,%01000010 + !byte $6F,%11000001 + !byte $03,%00101110 + !byte $3B,%11101111 + !byte $3B,%00101110 + !byte $47,%01000000 + !byte $3E,%01010000 + !byte $77,%01000000 + !byte $00,%01010000 + !byte $7C,%11000001 + !byte $40,%11100001 + !byte $02,%11001101 + !byte $7E,%11100001 + !byte $73,%00000000 + !byte $4B,%00000000 + !byte $20,%01100100 + !byte $20,%10000101; + !byte $4F,%11100001 + !byte $6F,%11100001 + !byte $1E,%01100100 + !byte $1E,%10000101; + !byte $26,%10100001 + !byte $3C,%11001101 + !byte $49,%00100000 + !byte $18,%10100001 + !byte $75,%00100000 + !byte $00,%00001100 + !byte $24,%01000010 + !byte $42,%11000001 + !byte $4F,%00000010 + !byte $6F,%00000010 + !byte $3E,%00001100 + !byte $4E,%00100000 + !byte $71,%00000000 + !byte $70,%00100000 + !byte $4F,%00100010 + !byte $4D,%00000000 + !byte $6F,%00100010 + !byte $02,%00010000 + !byte $01,%00110000 + !byte $3C,%00010000 + !byte $44,%10100001 + !byte $4F,%01000010 + !byte $7A,%10100001 + !byte $6F,%01000010 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $4C,%00000000 + !byte $3D,%00110000 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $03,%01001110 + !byte $72,%00000000 + !byte $6F,%10100101 + !byte $3B,%01001110 + !byte $3B,%11001111 + !byte $4F,%10100101 + !byte $4F,%11100101 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $4F,%00000100 + !byte $6F,%10100011 + !byte $6F,%00100100 + !byte $4F,%11000101 + !byte $4F,%01000100 + !byte $4F,%11100011 + !byte $4F,%11000011 + !byte $03,%11001111 + !byte $6F,%11000011 + !byte $6F,%11100011 + !byte $6F,%01000100 + !byte $6F,%11000101 + !byte $4F,%00100100 + !byte $4F,%10100011 + !byte $6F,%00000100 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $6F,%11100101 + !byte $6F,%00000110 + !byte $4F,%00000110 + !byte $25,%11100001 + !byte $23,%10100011 + !byte $4F,%00100110 + !byte $6F,%00100110 + !byte $19,%11100001 + !byte $6F,%01000110 + !byte $4F,%01000110 + !byte $1B,%10100011 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $6F,%10100111 + !byte $3F,%11001011 + !byte $4F,%10100111 + !byte $46,%01100000 + !byte $46,%10000001; + !byte $01,%01101100 + !byte $01,%10001101; + !byte $4F,%11000111 + !byte $6F,%11000111 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $78,%01100000 + !byte $78,%10000001; + !byte $27,%00100000 + !byte $6F,%11100111 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $03,%10101111 + !byte $3B,%10101111 + !byte $21,%00100100 + !byte $22,%11100011 + !byte $4F,%11100111 + !byte $1D,%00100100 + !byte $17,%00100000 + !byte $1C,%11100011 + !byte $7F,%00000010 + !byte $48,%01000000 + !byte $41,%11100001 + !byte $4A,%00100000 + !byte $02,%11101101 + !byte $76,%01000000 + !byte $70,%01000000 + !byte $3C,%11101101 + !byte $74,%00100000 + !byte $7D,%11100001 + !byte $4E,%01000000 + !byte $24,%00100010 + !byte $3F,%01010000 + !byte $20,%01000100 + !byte $1E,%01000100 + !byte $1A,%00100010 + !byte $43,%11000001 + !byte $7B,%11000001 + !byte $00,%00101100 + !byte $26,%01100000 + !byte $26,%10000001; + !byte $3E,%00101100 + !byte $18,%01100000 + !byte $18,%10000001; + !byte $4D,%00100000 + !byte $79,%10100001 + !byte $71,%00100000 + !byte $02,%11101111 + !byte $3C,%11101111 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $45,%10100001 + !byte $00,%00110000 + !byte $3E,%00110000 + !byte $4B,%00100000 + !byte $73,%00100000 + !byte $70,%01100000 + !byte $70,%10000001; + !byte $4E,%01100000 + !byte $4E,%10000001; + !byte $25,%11000001 + !byte $47,%01100000 + !byte $47,%10000001; + !byte $01,%10101101 + !byte $02,%00001110 + !byte $1F,%01000100 + !byte $40,%00000010 + !byte $23,%01100010 + !byte $23,%10000011; + !byte $77,%01100000 + !byte $77,%10000001; + !byte $3F,%11101011 + !byte $3D,%00010000 + !byte $3D,%10101101 + !byte $3C,%00001110 + !byte $19,%11000001 + !byte $7E,%00000010 + !byte $72,%00100000 + !byte $4C,%00100000 + !byte $21,%00000100 + !byte $01,%00010000 + !byte $1C,%11000011 + !byte $1D,%00000100 + !byte $27,%00000000 + !byte $49,%01000000 + !byte $75,%01000000 + !byte $42,%11100001 + !byte $17,%00000000 + !byte $22,%11000011 + !byte $7C,%11100001 + !byte $4E,%10100001 + !byte $3C,%11001111 + !byte $70,%10100001 + !byte $02,%11001111 + !byte $44,%11000001 + !byte $1E,%00100100 + !byte $7A,%11000001 + !byte $18,%01000000 + !byte $3C,%00101110 + !byte $20,%00100100 + !byte $24,%00000010 + !byte $71,%01000000 + !byte $02,%00101110 + !byte $4D,%01000000 + !byte $1A,%00000010 + !byte $46,%10100001 + !byte $26,%01000000 + !byte $00,%01001100 + !byte $78,%10100001 + !byte $4E,%11000001 + !byte $3E,%01001100 + !byte $70,%11000001 + !byte $7F,%00100010 + !byte $3C,%10101111 + !byte $02,%10101111 + !byte $74,%01000000 + !byte $3C,%01001110 + !byte $4A,%01000000 + !byte $48,%01100000 + !byte $48,%10000001; + !byte $02,%01001110 + !byte $23,%01000010 + !byte $76,%01100000 + !byte $76,%10000001; + !byte $01,%11001101 + !byte $1B,%01000010 + !byte $3F,%00110000 + !byte $41,%00000010 + !byte $3D,%11001101 + !byte $7D,%00000010 + !byte $1F,%00100100 + !byte $3C,%01101110 + !byte $3C,%10001111; + !byte $02,%01101110 + !byte $02,%10001111; + !byte $21,%11100011 + !byte $3D,%11101111 + !byte $01,%11101111 + !byte $1D,%11100011 + !byte $70,%11100001 + !byte $4E,%11100001 + !byte $25,%10100001 + !byte $00,%00010000 + !byte $19,%10100001 + !byte $43,%11100001 + !byte $72,%01000000 + !byte $22,%10100011 + !byte $4C,%01000000 + !byte $7B,%11100001 + !byte $3E,%00010000 + !byte $1C,%10100011 + !byte $4B,%01000000 + !byte $73,%01000000 + !byte $3F,%00001100 + !byte $70,%00000010 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $4E,%00000010 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $1A,%11100001 + !byte $20,%00000100 + !byte $45,%11000001 + !byte $1E,%00000100 + !byte $4E,%00100010 + !byte $26,%00100000 + !byte $79,%11000001 + !byte $70,%00100010 + !byte $18,%00100000 + !byte $00,%01101100 + !byte $00,%10001101; + !byte $3D,%11101101 + !byte $3E,%01101100 + !byte $3E,%10001101; + !byte $47,%10100001 + !byte $40,%00100010 + !byte $77,%10100001 + !byte $4E,%01000010 + !byte $7E,%00100010 + !byte $70,%01000010 + !byte $01,%11101101 + !byte $24,%11100001 + !byte $49,%01100000 + !byte $49,%10000001; + !byte $75,%01100000 + !byte $75,%10000001; + !byte $70,%01100010 + !byte $70,%10000011; + !byte $4E,%01100010 + !byte $4E,%10000011; + !byte $3D,%11001111 + !byte $01,%11001111 + !byte $42,%00000010 + !byte $4E,%10100011 + !byte $70,%10100011 + !byte $7C,%00000010 + !byte $70,%11000011 + !byte $1F,%00000100 + !byte $4E,%11000011 + !byte $70,%11100011 + !byte $4E,%11100011 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $4E,%00000100 + !byte $70,%00000100 + !byte $23,%00100010 + !byte $71,%10100001 + !byte $4E,%01100110 + !byte $4E,%10000111; + !byte $4E,%11000101 + !byte $4E,%00100100 + !byte $70,%11100101 + !byte $70,%00100110 + !byte $4E,%01000110 + !byte $4E,%10100101 + !byte $70,%10100101 + !byte $70,%01000110 + !byte $4E,%00100110 + !byte $4E,%11100101 + !byte $70,%00100100 + !byte $70,%11000101 + !byte $70,%00000110 + !byte $4E,%00000110 + !byte $44,%11100001 + !byte $4E,%01000100 + !byte $70,%01000100 + !byte $70,%01100100 + !byte $70,%10000101; + !byte $4E,%10100111 + !byte $4E,%01100100 + !byte $4E,%10000101; + !byte $70,%01100110 + !byte $70,%10000111; + !byte $4D,%10100001 + !byte $70,%10100111 + !byte $4E,%11000111 + !byte $70,%11000111 + !byte $7A,%11100001 + !byte $1B,%00100010 + !byte $21,%11000011 + !byte $70,%11100111 + !byte $4E,%11100111 + !byte $1C,%01100010 + !byte $1C,%10000011; + !byte $1D,%11000011 + !byte $01,%00001110 + !byte $3D,%00001110 + !byte $4C,%01100000 + !byte $4C,%10000001; + !byte $3F,%00101100 + !byte $72,%01100000 + !byte $72,%10000001; + !byte $25,%01100000 + !byte $25,%10000001; + !byte $4A,%01100000 + !byte $4A,%10000001; + !byte $74,%01100000 + !byte $74,%10000001; + !byte $3F,%00010000 + !byte $00,%11101111 + !byte $22,%01100010 + !byte $22,%10000011; + !byte $78,%11000001 + !byte $3D,%10101111 + !byte $7F,%01000010 + !byte $3E,%11101111 + !byte $20,%11100011 + !byte $01,%10101111 + !byte $1E,%11100011 + !byte $46,%11000001 + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $73,%01100000 + !byte $73,%10000001; + !byte $00,%10101101 + !byte $24,%11000001 + !byte $3E,%10101101 + !byte $1A,%11000001 + !byte $48,%10100001 + !byte $76,%10100001 + !byte $41,%00100010 + !byte $01,%00101110 + !byte $26,%00000000 + !byte $3D,%00101110 + !byte $18,%00000000 + !byte $7D,%00100010 + !byte $71,%11000001 + !byte $4D,%11000001 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $3D,%01001110 + !byte $43,%00000010 + !byte $01,%01001110 + !byte $7B,%00000010 + !byte $23,%00000010 + !byte $1F,%11100011 + !byte $1B,%00000010 + !byte $21,%10100011 + !byte $25,%01000000 + !byte $1D,%10100011 + !byte $19,%01000000 + !byte $3F,%01001100 + !byte $4C,%10100001 + !byte $45,%11100001 + !byte $72,%10100001 + !byte $79,%11100001 + !byte $4D,%11100001 + !byte $71,%11100001 + !byte $00,%11001101 + !byte $49,%10100001 + !byte $3E,%11001101 + !byte $75,%10100001 + !byte $00,%11001111 + !byte $22,%01000010 + !byte $1C,%01000010 + !byte $40,%01000010 + !byte $3E,%11001111 + !byte $7E,%01000010 + !byte $47,%11000001 + !byte $20,%11000011 + !byte $1E,%11000011 + !byte $77,%11000001 + !byte $3F,%11101111 + !byte $42,%00100010 + !byte $71,%00000010 + !byte $7C,%00100010 + !byte $4D,%00000010 + !byte $4A,%10100001 + !byte $73,%10100001 + !byte $74,%10100001 + !byte $4B,%10100001 + !byte $24,%10100001 + !byte $1A,%10100001 + !byte $7A,%00000010 + !byte $00,%11101101 + !byte $1F,%11000011 + !byte $3E,%11101101 + !byte $71,%00100010 + !byte $4C,%11000001 + !byte $44,%00000010 + !byte $4D,%00100010 + !byte $00,%10101111 + !byte $72,%11000001 + !byte $3E,%10101111 + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $23,%11100001 + !byte $48,%11000001 + !byte $46,%11100001 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $1B,%11100001 + !byte $78,%11100001 + !byte $76,%11000001 + !byte $22,%00100010 + !byte $1C,%00100010 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $25,%00100000 + !byte $4D,%01000010 + !byte $71,%01000010 + !byte $41,%01000010 + !byte $3E,%00001110 + !byte $19,%00100000 + !byte $20,%10100011 + !byte $7D,%01000010 + !byte $1E,%10100011 + !byte $00,%00001110 + !byte $00,%01101110 + !byte $00,%10001111; + !byte $3E,%01101110 + !byte $3E,%10001111; + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $71,%01100010 + !byte $71,%10000011; + !byte $43,%00100010 + !byte $7B,%00100010 + !byte $3F,%11001111 + !byte $00,%00101110 + !byte $1A,%01100000 + !byte $1A,%10000001; + !byte $3E,%00101110 + !byte $00,%01001110 + !byte $4C,%11100001 + !byte $75,%11000001 + !byte $3E,%01001110 + !byte $71,%10100011 + !byte $73,%11000001 + !byte $4D,%10100011 + !byte $72,%11100001 + !byte $4B,%11000001 + !byte $49,%11000001 + !byte $45,%00000010 + !byte $79,%00000010 + !byte $24,%01100000 + !byte $24,%10000001; + !byte $3F,%10101101 + !byte $4D,%11000011 + !byte $1F,%10100011 + !byte $71,%11000011 + !byte $4A,%11000001 + !byte $74,%11000001 + !byte $47,%11100001 + !byte $4D,%11100011 + !byte $23,%11000001 + !byte $77,%11100001 + !byte $71,%11100011 + !byte $40,%01100010 + !byte $40,%10000011; + !byte $1B,%11000001 + !byte $7E,%01100010 + !byte $7E,%10000011; + !byte $4D,%00000100 + !byte $71,%00000100 + !byte $21,%01000010 + !byte $1D,%01000010 + !byte $71,%00100100 + !byte $4D,%00100100 + !byte $4D,%01000100 + !byte $71,%01000100 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $71,%01100100 + !byte $71,%10000101; + !byte $4D,%11000111 + !byte $4D,%01000110 + !byte $4D,%10100101 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $4D,%11100111 + !byte $4D,%10100111 + !byte $71,%10100111 + !byte $71,%11100111 + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $71,%10100101 + !byte $71,%01000110 + !byte $4D,%00000110 + !byte $71,%11000101 + !byte $4D,%11100101 + !byte $71,%11100101 + !byte $71,%00100110 + !byte $4D,%00100110 + !byte $4D,%11000101 + !byte $42,%01000010 + !byte $71,%00000110 + !byte $22,%00000010 + !byte $71,%11000111 + !byte $1E,%01100010 + !byte $1E,%10000011; + !byte $4C,%00000010 + !byte $7C,%01000010 + !byte $1C,%00000010 + !byte $25,%00000000 + !byte $72,%00000010 + !byte $20,%01100010 + !byte $20,%10000011; + !byte $3F,%10101111 + !byte $19,%00000000 + !byte $3F,%11001101 + !byte $7A,%00100010 + !byte $48,%11100001 + !byte $44,%00100010 + !byte $76,%11100001 + !byte $73,%11100001 + !byte $4B,%11100001 + !byte $24,%01000000 + !byte $46,%00000010 + !byte $7F,%10100011 + !byte $1A,%01000000 + !byte $78,%00000010 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $4C,%00100010 + !byte $72,%00100010 + !byte $41,%01100010 + !byte $41,%10000011; + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $3F,%11101101 + !byte $75,%11100001 + !byte $21,%00100010 + !byte $1D,%00100010 + !byte $49,%11100001 + !byte $4A,%11100001 + !byte $74,%11100001 + !byte $23,%10100001 + !byte $1B,%10100001 + !byte $22,%11100001 + !byte $43,%01000010 + !byte $7B,%01000010 + !byte $1C,%11100001 + !byte $1E,%01000010 + !byte $20,%01000010 + !byte $72,%01000010 + !byte $3F,%00001110 + !byte $3F,%01001110 + !byte $4C,%01000010 + !byte $45,%00100010 + !byte $79,%00100010 + !byte $73,%00000010 + !byte $47,%00000010 + !byte $3F,%00101110 + !byte $77,%00000010 + !byte $4B,%00000010 + !byte $7E,%10100011 + !byte $1A,%00100000 + !byte $40,%10100011 + !byte $4C,%01100010 + !byte $4C,%10000011; + !byte $72,%01100010 + !byte $72,%10000011; + !byte $1F,%01000010 + !byte $24,%00100000 + !byte $42,%01100010 + !byte $42,%10000011; + !byte $21,%00000010 + !byte $1D,%00000010 + !byte $7C,%01100010 + !byte $7C,%10000011; + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $48,%00000010 + !byte $76,%00000010 + !byte $4C,%10100011 + !byte $7A,%01000010 + !byte $72,%10100011 + !byte $74,%00000010 + !byte $4A,%00000010 + !byte $73,%00100010 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $44,%01000010 + !byte $20,%00100010 + !byte $1E,%00100010 + !byte $4B,%00100010 + !byte $46,%00100010 + !byte $22,%11000001 + !byte $78,%00100010 + !byte $49,%00000010 + !byte $75,%00000010 + !byte $1C,%11000001 + !byte $72,%11000011 + !byte $7F,%11000011 + !byte $4C,%11000011 + !byte $7D,%10100011 + !byte $4C,%11100011 + !byte $72,%11100011 + !byte $41,%10100011 + !byte $24,%00000000 + !byte $1F,%00100010 + !byte $1A,%00000000 + !byte $72,%00000100 + !byte $4C,%00000100 + !byte $43,%01100010 + !byte $43,%10000011; + !byte $73,%01000010 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $4B,%01000010 + !byte $47,%00100010 + !byte $77,%00100010 + !byte $4C,%00100100 + !byte $72,%00100100 + !byte $21,%11100001 + !byte $45,%01000010 + !byte $79,%01000010 + !byte $1D,%11100001 + !byte $4C,%01000100 + !byte $74,%00100010 + !byte $4A,%00100010 + !byte $72,%01000100 + !byte $23,%01000000 + !byte $22,%10100001 + !byte $72,%01100100 + !byte $72,%10000101; + !byte $1B,%01000000 + !byte $20,%00000010 + !byte $1E,%00000010 + !byte $7E,%11000011 + !byte $4C,%01100100 + !byte $4C,%10000101; + !byte $1C,%10100001 + !byte $72,%10100101 + !byte $4C,%10100101 + !byte $4C,%11000101 + !byte $72,%11000101 + !byte $4C,%11100101 + !byte $72,%11100101 + !byte $72,%00000110 + !byte $48,%00100010 + !byte $72,%11100111 + !byte $4C,%00000110 + !byte $40,%11000011 + !byte $4C,%01000110 + !byte $72,%01100110 + !byte $72,%10000111; + !byte $72,%11000111 + !byte $4C,%11100111 + !byte $4C,%00100110 + !byte $76,%00100010 + !byte $72,%00100110 + !byte $4C,%11000111 + !byte $4C,%01100110 + !byte $4C,%10000111; + !byte $72,%01000110 + !byte $72,%10100111 + !byte $4C,%10100111 + !byte $75,%00100010 + !byte $49,%00100010 + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $7C,%10100011 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $42,%10100011 + !byte $1F,%00000010 + !byte $44,%01100010 + !byte $44,%10000011; + !byte $7A,%01100010 + !byte $7A,%10000011; + !byte $46,%01000010 + !byte $78,%01000010 + !byte $7F,%11100011 + !byte $74,%01000010 + !byte $21,%11000001 + !byte $4A,%01000010 + !byte $1D,%11000001 + !byte $23,%00100000 + !byte $1B,%00100000 + !byte $4B,%10100011 + !byte $73,%10100011 + !byte $20,%11100001 + !byte $1E,%11100001 + !byte $1C,%01100000 + !byte $1C,%10000001; + !byte $41,%11000011 + !byte $7D,%11000011 + !byte $22,%01100000 + !byte $22,%10000001; + !byte $47,%01000010 + !byte $77,%01000010 + !byte $73,%11000011 + !byte $4B,%11000011 + !byte $43,%10100011 + !byte $7B,%10100011 + !byte $49,%01000010 + !byte $75,%01000010 + !byte $1F,%11100001 + !byte $45,%01100010 + !byte $45,%10000011; + !byte $79,%01100010 + !byte $79,%10000011; + !byte $48,%01000010 + !byte $76,%01000010 + !byte $4A,%01100010 + !byte $4A,%10000011; + !byte $74,%01100010 + !byte $74,%10000011; + !byte $40,%11100011 + !byte $21,%10100001 + !byte $4B,%11100011 + !byte $7E,%11100011 + !byte $73,%11100011 + !byte $1D,%10100001 + !byte $20,%11000001 + !byte $1E,%11000001 + !byte $23,%00000000 + !byte $7C,%11000011 + !byte $73,%00000100 + !byte $1B,%00000000 + !byte $4B,%00000100 + !byte $22,%01000000 + !byte $1C,%01000000 + !byte $46,%01100010 + !byte $46,%10000011; + !byte $42,%11000011 + !byte $78,%01100010 + !byte $78,%10000011; + !byte $44,%10100011 + !byte $7A,%10100011 + !byte $4B,%00100100 + !byte $4A,%10100011 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $73,%00100100 + !byte $1F,%11000001 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $74,%10100011 + !byte $7F,%00000100 + !byte $4B,%01000100 + !byte $73,%01000100 + !byte $47,%01100010 + !byte $47,%10000011; + !byte $77,%01100010 + !byte $77,%10000011; + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $76,%01100010 + !byte $76,%10000011; + !byte $48,%01100010 + !byte $48,%10000011; + !byte $41,%11100011 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $7D,%11100011 + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $21,%01100000 + !byte $21,%10000001; + !byte $1E,%10100001 + !byte $4B,%10100101 + !byte $7B,%11000011 + !byte $20,%10100001 + !byte $73,%10100101 + !byte $22,%00100000 + !byte $74,%11000011 + !byte $45,%10100011 + !byte $4A,%11000011 + !byte $1C,%00100000 + !byte $79,%10100011 + !byte $43,%11000011 + !byte $4B,%11000101 + !byte $73,%11000101 + !byte $73,%11100101 + !byte $4B,%11100101 + !byte $4B,%00000110 + !byte $73,%00000110 + !byte $4B,%00100110 + !byte $73,%00100110 + !byte $49,%10100011 + !byte $73,%01000110 + !byte $4B,%01000110 + !byte $1F,%10100001 + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $73,%01100110 + !byte $73,%10000111; + !byte $4B,%10100111 + !byte $73,%11000111 + !byte $4B,%11000111 + !byte $75,%10100011 + !byte $73,%10100111 + !byte $4B,%11100111 + !byte $73,%11100111 + !byte $40,%00000100 + !byte $7E,%00000100 + !byte $4A,%11100011 + !byte $74,%11100011 + !byte $46,%10100011 + !byte $78,%10100011 + !byte $42,%11100011 + !byte $7C,%11100011 + !byte $21,%01000000 + !byte $1D,%01000000 + !byte $44,%11000011 + !byte $7A,%11000011 + !byte $1E,%01100000 + !byte $1E,%10000001; + !byte $76,%10100011 + !byte $48,%10100011 + !byte $20,%01100000 + !byte $20,%10000001; + !byte $47,%10100011 + !byte $77,%10100011 + !byte $1C,%00000000 + !byte $74,%00000100 + !byte $22,%00000000 + !byte $4A,%00000100 + !byte $7F,%00100100 + !byte $75,%11000011 + !byte $49,%11000011 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $41,%00000100 + !byte $4A,%00100100 + !byte $7D,%00000100 + !byte $74,%00100100 + !byte $45,%11000011 + !byte $43,%11100011 + !byte $79,%11000011 + !byte $7B,%11100011 + !byte $21,%00100000 + !byte $1D,%00100000 + !byte $20,%01000000 + !byte $76,%11000011 + !byte $74,%01000100 + !byte $48,%11000011 + !byte $1E,%01000000 + !byte $75,%11100011 + !byte $46,%11000011 + !byte $4A,%01000100 + !byte $49,%11100011 + !byte $78,%11000011 + !byte $47,%11000011 + !byte $77,%11000011 + !byte $40,%00100100 + !byte $4A,%01100100 + !byte $4A,%10000101; + !byte $7E,%00100100 + !byte $1F,%01000000 + !byte $74,%01100100 + !byte $74,%10000101; + !byte $42,%00000100 + !byte $44,%11100011 + !byte $7C,%00000100 + !byte $7A,%11100011 + !byte $4A,%10100101 + !byte $74,%10100101 + !byte $21,%00000000 + !byte $49,%00000100 + !byte $75,%00000100 + !byte $1D,%00000000 + !byte $74,%11000101 + !byte $7F,%01000100 + !byte $4A,%11000101 + !byte $20,%00100000 + !byte $1E,%00100000 + !byte $48,%11100011 + !byte $76,%11100011 + !byte $74,%11100101 + !byte $45,%11100011 + !byte $4A,%11100101 + !byte $79,%11100011 + !byte $7D,%00100100 + !byte $4A,%00000110 + !byte $74,%00000110 + !byte $43,%00000100 + !byte $41,%00100100 + !byte $7B,%00000100 + !byte $1F,%00100000 + !byte $4A,%00100110 + !byte $74,%00100110 + !byte $75,%00100100 + !byte $46,%11100011 + !byte $49,%00100100 + !byte $47,%11100011 + !byte $77,%11100011 + !byte $78,%11100011 + !byte $74,%01000110 + !byte $4A,%01000110 + !byte $4A,%01100110 + !byte $4A,%10000111; + !byte $74,%01100110 + !byte $74,%10000111; + !byte $4A,%10100111 + !byte $74,%10100111 + !byte $74,%11000111 + !byte $4A,%11000111 + !byte $4A,%11100111 + !byte $74,%11100111 + !byte $76,%00000100 + !byte $48,%00000100 + !byte $40,%01000100 + !byte $20,%00000000 + !byte $1E,%00000000 + !byte $49,%01000100 + !byte $7E,%01000100 + !byte $75,%01000100 + !byte $7A,%00000100 + !byte $7C,%00100100 + !byte $44,%00000100 + !byte $42,%00100100 + !byte $1F,%00000000 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $49,%01100100 + !byte $49,%10000101; + !byte $77,%00000100 + !byte $45,%00000100 + !byte $47,%00000100 + !byte $79,%00000100 + !byte $48,%00100100 + !byte $76,%00100100 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $46,%00000100 + !byte $78,%00000100 + !byte $41,%01000100 + !byte $7D,%01000100 + !byte $49,%10100101 + !byte $75,%10100101 + !byte $43,%00100100 + !byte $7B,%00100100 + !byte $49,%11000101 + !byte $75,%11000101 + !byte $76,%01000100 + !byte $48,%01000100 + !byte $44,%00100100 + !byte $47,%00100100 + !byte $7A,%00100100 + !byte $49,%11100101 + !byte $75,%11100101 + !byte $77,%00100100 + !byte $40,%01100100 + !byte $40,%10000101; + !byte $42,%01000100 + !byte $7E,%01100100 + !byte $7E,%10000101; + !byte $7C,%01000100 + !byte $75,%00000110 + !byte $49,%00000110 + !byte $45,%00100100 + !byte $79,%00100100 + !byte $46,%00100100 + !byte $78,%00100100 + !byte $48,%01100100 + !byte $48,%10000101; + !byte $75,%00100110 + !byte $49,%00100110 + !byte $76,%01100100 + !byte $76,%10000101; + !byte $75,%01000110 + !byte $49,%01000110 + !byte $7F,%10100101 + !byte $43,%01000100 + !byte $7B,%01000100 + !byte $77,%01000100 + !byte $49,%01100110 + !byte $49,%10000111; + !byte $47,%01000100 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $49,%10100111 + !byte $41,%01100100 + !byte $41,%10000101; + !byte $75,%10100111 + !byte $76,%10100101 + !byte $75,%11000111 + !byte $49,%11000111 + !byte $48,%10100101 + !byte $49,%11100111 + !byte $75,%11100111 + !byte $44,%01000100 + !byte $7A,%01000100 + !byte $46,%01000100 + !byte $78,%01000100 + !byte $45,%01000100 + !byte $79,%01000100 + !byte $40,%10100101 + !byte $7E,%10100101 + !byte $48,%11000101 + !byte $47,%01100100 + !byte $47,%10000101; + !byte $76,%11000101 + !byte $42,%01100100 + !byte $42,%10000101; + !byte $77,%01100100 + !byte $77,%10000101; + !byte $7C,%01100100 + !byte $7C,%10000101; + !byte $48,%11100101 + !byte $76,%11100101 + !byte $43,%01100100 + !byte $43,%10000101; + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $46,%01100100 + !byte $46,%10000101; + !byte $77,%10100101 + !byte $48,%00000110 + !byte $78,%01100100 + !byte $78,%10000101; + !byte $47,%10100101 + !byte $7F,%11000101 + !byte $76,%00000110 + !byte $41,%10100101 + !byte $7D,%10100101 + !byte $7A,%01100100 + !byte $7A,%10000101; + !byte $44,%01100100 + !byte $44,%10000101; + !byte $45,%01100100 + !byte $45,%10000101; + !byte $79,%01100100 + !byte $79,%10000101; + !byte $76,%00100110 + !byte $48,%00100110 + !byte $76,%01000110 + !byte $77,%11000101 + !byte $42,%10100101 + !byte $48,%01000110 + !byte $47,%11000101 + !byte $7C,%10100101 + !byte $40,%11000101 + !byte $78,%10100101 + !byte $7E,%11000101 + !byte $46,%10100101 + !byte $48,%01100110 + !byte $48,%10000111; + !byte $76,%01100110 + !byte $76,%10000111; + !byte $48,%10100111 + !byte $7B,%10100101 + !byte $76,%10100111 + !byte $47,%11100101 + !byte $43,%10100101 + !byte $77,%11100101 + !byte $48,%11000111 + !byte $76,%11000111 + !byte $79,%10100101 + !byte $45,%10100101 + !byte $7A,%10100101 + !byte $44,%10100101 + !byte $48,%11100111 + !byte $76,%11100111 + !byte $7F,%11100101 + !byte $41,%11000101 + !byte $7D,%11000101 + !byte $46,%11000101 + !byte $78,%11000101 + !byte $77,%00000110 + !byte $47,%00000110 + !byte $42,%11000101 + !byte $7C,%11000101 + !byte $77,%00100110 + !byte $40,%11100101 + !byte $7E,%11100101 + !byte $45,%11000101 + !byte $79,%11000101 + !byte $47,%00100110 + !byte $46,%11100101 + !byte $78,%11100101 + !byte $43,%11000101 + !byte $7B,%11000101 + !byte $7A,%11000101 + !byte $44,%11000101 + !byte $77,%01000110 + !byte $47,%01000110 + !byte $41,%11100101 + !byte $7D,%11100101 + !byte $47,%01100110 + !byte $47,%10000111; + !byte $7F,%00000110 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $78,%00000110 + !byte $46,%00000110 + !byte $79,%11100101 + !byte $45,%11100101 + !byte $47,%10100111 + !byte $77,%10100111 + !byte $7C,%11100101 + !byte $42,%11100101 + !byte $47,%11000111 + !byte $44,%11100101 + !byte $7A,%11100101 + !byte $77,%11000111 + !byte $43,%11100101 + !byte $7B,%11100101 + !byte $46,%00100110 + !byte $78,%00100110 + !byte $40,%00000110 + !byte $7E,%00000110 + !byte $47,%11100111 + !byte $77,%11100111 + !byte $45,%00000110 + !byte $79,%00000110 + !byte $7D,%00000110 + !byte $46,%01000110 + !byte $78,%01000110 + !byte $41,%00000110 + !byte $7F,%00100110 + !byte $7A,%00000110 + !byte $44,%00000110 + !byte $7C,%00000110 + !byte $42,%00000110 + !byte $46,%01100110 + !byte $46,%10000111; + !byte $45,%00100110 + !byte $78,%01100110 + !byte $78,%10000111; + !byte $43,%00000110 + !byte $7B,%00000110 + !byte $79,%00100110 + !byte $40,%00100110 + !byte $7E,%00100110 + !byte $46,%10100111 + !byte $78,%10100111 + !byte $79,%01000110 + !byte $45,%01000110 + !byte $7A,%00100110 + !byte $44,%00100110 + !byte $78,%11000111 + !byte $46,%11000111 + !byte $41,%00100110 + !byte $7D,%00100110 + !byte $7B,%00100110 + !byte $43,%00100110 + !byte $42,%00100110 + !byte $7C,%00100110 + !byte $78,%11100111 + !byte $46,%11100111 + !byte $7F,%01000110 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $45,%01100110 + !byte $45,%10000111; + !byte $44,%01000110 + !byte $7A,%01000110 + !byte $7E,%01000110 + !byte $40,%01000110 + !byte $79,%10100111 + !byte $45,%10100111 + !byte $43,%01000110 + !byte $41,%01000110 + !byte $7B,%01000110 + !byte $7D,%01000110 + !byte $42,%01000110 + !byte $7C,%01000110 + !byte $44,%01100110 + !byte $44,%10000111; + !byte $7A,%01100110 + !byte $7A,%10000111; + !byte $45,%11000111 + !byte $79,%11000111 + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $45,%11100111 + !byte $7E,%01100110 + !byte $7E,%10000111; + !byte $79,%11100111 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $43,%01100110 + !byte $43,%10000111; + !byte $40,%01100110 + !byte $40,%10000111; + !byte $7A,%10100111 + !byte $44,%10100111 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $42,%01100110 + !byte $42,%10000111; + !byte $7C,%01100110 + !byte $7C,%10000111; + !byte $7A,%11000111 + !byte $44,%11000111 + !byte $7F,%10100111 + !byte $43,%10100111 + !byte $7B,%10100111 + !byte $40,%10100111 + !byte $7E,%10100111 + !byte $7C,%10100111 + !byte $42,%10100111 + !byte $7A,%11100111 + !byte $44,%11100111 + !byte $41,%10100111 + !byte $7D,%10100111 + !byte $43,%11000111 + !byte $7B,%11000111 + !byte $7F,%11000111 + !byte $42,%11000111 + !byte $7C,%11000111 + !byte $43,%11100111 + !byte $7B,%11100111 + !byte $40,%11000111 + !byte $7E,%11000111 + !byte $41,%11000111 + !byte $7D,%11000111 + !byte $42,%11100111 + !byte $7C,%11100111 + !byte $7F,%11100111 + !byte $7D,%11100111 + !byte $41,%11100111 + !byte $7E,%11100111 + !byte $40,%11100111 diff --git a/src/fx/fx.hgr.flower.in.a b/src/fx/fx.hgr.flower.in.a new file mode 100644 index 0000000..a72cc1e --- /dev/null +++ b/src/fx/fx.hgr.flower.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_REVERSE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 14 + !text "FX/FLOWER.DATA" diff --git a/src/fx/fx.hgr.flower.radial.a b/src/fx/fx.hgr.flower.radial.a new file mode 100644 index 0000000..7e59568 --- /dev/null +++ b/src/fx/fx.hgr.flower.radial.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER.RAD",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/FLOWER.RAD.DATA" diff --git a/src/fx/fx.hgr.flower.radial.data.a b/src/fx/fx.hgr.flower.radial.data.a new file mode 100644 index 0000000..d935fef --- /dev/null +++ b/src/fx/fx.hgr.flower.radial.data.a @@ -0,0 +1,10243 @@ +!cpu 6502 +!to "build/FX/FLOWER.RAD.DATA",plain +*=$6B00 + !byte $1F,%00010100 + !byte $1F,%00110100 + !byte $1F,%11110011 + !byte $1E,%00010100 + !byte $1F,%01010100 + !byte $20,%00110100 + !byte $20,%00010100 + !byte $1E,%00110100 + !byte $20,%11110011 + !byte $20,%11010011 + !byte $1E,%11010011 + !byte $1F,%01110100 + !byte $1F,%10010101; + !byte $1F,%11010011 + !byte $1E,%11110011 + !byte $1E,%10110011 + !byte $1D,%00110100 + !byte $1D,%00010100 + !byte $20,%10110011 + !byte $20,%01010100 + !byte $21,%00110100 + !byte $1F,%10110101 + !byte $21,%01010100 + !byte $1E,%01110010 + !byte $1E,%10010011; + !byte $1F,%10110011 + !byte $21,%10110011 + !byte $21,%11010011 + !byte $1E,%01110100 + !byte $1E,%10010101; + !byte $1E,%10110101 + !byte $1F,%11010101 + !byte $1E,%01010100 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $21,%01110100 + !byte $21,%10010101; + !byte $1C,%00110100 + !byte $1E,%01010010 + !byte $1C,%00010100 + !byte $1E,%11010101 + !byte $1D,%11110011 + !byte $1D,%01010100 + !byte $22,%01010100 + !byte $21,%00010100 + !byte $20,%01110010 + !byte $20,%10010011; + !byte $22,%01110100 + !byte $22,%10010101; + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $21,%11110011 + !byte $1E,%11110101 + !byte $20,%01110100 + !byte $20,%10010101; + !byte $1F,%11110101 + !byte $1C,%01010100 + !byte $1E,%00110010 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $1D,%01010010 + !byte $1C,%11110011 + !byte $21,%01010010 + !byte $22,%01110010 + !byte $22,%10010011; + !byte $22,%10110101 + !byte $22,%10110011 + !byte $21,%10110101 + !byte $1D,%00110010 + !byte $1E,%00010110 + !byte $22,%00110100 + !byte $1B,%00110100 + !byte $22,%01010010 + !byte $1B,%00010100 + !byte $1F,%01010010 + !byte $1E,%00010010 + !byte $1D,%00010010 + !byte $22,%11010011 + !byte $1F,%00010110 + !byte $1D,%10110011 + !byte $1B,%11110011 + !byte $1B,%01010100 + !byte $23,%10110101 + !byte $1E,%00110110 + !byte $22,%11010101 + !byte $23,%01110100 + !byte $23,%10010101; + !byte $1D,%11010011 + !byte $1F,%00110010 + !byte $22,%00110010 + !byte $1E,%11110001 + !byte $23,%11010101 + !byte $1D,%11110001 + !byte $1D,%11110101 + !byte $1D,%11010101 + !byte $23,%01010010 + !byte $21,%11010101 + !byte $1D,%00010110 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $20,%10110101 + !byte $1C,%11010011 + !byte $1A,%00010100 + !byte $1A,%00110100 + !byte $1D,%10110101 + !byte $1D,%00110110 + !byte $23,%00110010 + !byte $1E,%01010110 + !byte $23,%10110011 + !byte $1A,%11110011 + !byte $1F,%00010010 + !byte $22,%11110101 + !byte $23,%11110101 + !byte $1D,%11010001 + !byte $22,%11110011 + !byte $1B,%11010011 + !byte $1E,%11010001 + !byte $1D,%01010110 + !byte $1D,%01110100 + !byte $1D,%10010101; + !byte $1F,%00110110 + !byte $23,%01010100 + !byte $1A,%01010100 + !byte $21,%00110010 + !byte $1F,%11110001 + !byte $23,%11010011 + !byte $1D,%01110110 + !byte $1D,%10010111; + !byte $1A,%11010011 + !byte $1D,%10110001 + !byte $1E,%01110110 + !byte $1E,%10010111; + !byte $23,%00010010 + !byte $1E,%10110001 + !byte $24,%11010101 + !byte $24,%01010010 + !byte $23,%00010110 + !byte $21,%11110101 + !byte $19,%00010100 + !byte $24,%00110010 + !byte $24,%11110101 + !byte $19,%11110011 + !byte $24,%01110010 + !byte $24,%10010011; + !byte $22,%00010110 + !byte $19,%00110100 + !byte $20,%11010101 + !byte $24,%10110101 + !byte $24,%00010110 + !byte $24,%00010010 + !byte $1F,%11010001 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $1C,%10110011 + !byte $22,%00010010 + !byte $1B,%10110011 + !byte $1E,%01110000 + !byte $1E,%10010001; + !byte $1D,%10110111 + !byte $1C,%00110110 + !byte $19,%11010011 + !byte $24,%10110011 + !byte $22,%00010100 + !byte $1C,%01010110 + !byte $1C,%00010110 + !byte $20,%01010010 + !byte $23,%00110110 + !byte $1C,%01110110 + !byte $1C,%10010111; + !byte $1A,%10110011 + !byte $1C,%11110101 + !byte $24,%00110110 + !byte $23,%11110011 + !byte $1F,%10110001 + !byte $1E,%10110111 + !byte $22,%00110110 + !byte $1C,%10110111 + !byte $1D,%01010000 + !byte $25,%00110010 + !byte $1E,%01010000 + !byte $21,%00010110 + !byte $25,%01010010 + !byte $18,%11110011 + !byte $18,%00010100 + !byte $1C,%11010101 + !byte $19,%10110011 + !byte $20,%00110010 + !byte $25,%00010010 + !byte $1D,%11010111 + !byte $24,%11010011 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $18,%11010011 + !byte $24,%01010110 + !byte $23,%01010110 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $1C,%11010111 + !byte $24,%11110001 + !byte $20,%11110101 + !byte $19,%01010100 + !byte $20,%00010010 + !byte $1E,%00110000 + !byte $1D,%00110000 + !byte $1C,%01110100 + !byte $1C,%10010101; + !byte $1C,%10110101 + !byte $18,%00110100 + !byte $25,%00010110 + !byte $25,%00110110 + !byte $18,%10110011 + !byte $1A,%01110010 + !byte $1A,%10010011; + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $25,%10110011 + !byte $25,%11110001 + !byte $1F,%01010000 + !byte $22,%01010110 + !byte $20,%11110001 + !byte $1C,%01110010 + !byte $1C,%10010011; + !byte $24,%01110110 + !byte $24,%10010111; + !byte $25,%01010110 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $1B,%01110110 + !byte $1B,%10010111; + !byte $1C,%11110111 + !byte $1B,%01010110 + !byte $21,%00110110 + !byte $23,%01110110 + !byte $23,%10010111; + !byte $1B,%10110111 + !byte $26,%00110010 + !byte $23,%00010100 + !byte $1B,%00110110 + !byte $1E,%00010000 + !byte $26,%00010010 + !byte $26,%01010010 + !byte $25,%11110101 + !byte $1D,%11110111 + !byte $24,%11110011 + !byte $20,%11010001 + !byte $17,%11110011 + !byte $1B,%11010111 + !byte $17,%11010011 + !byte $1D,%00010000 + !byte $1F,%00110000 + !byte $25,%01110110 + !byte $25,%10010111; + !byte $1B,%00010110 + !byte $18,%01110010 + !byte $18,%10010011; + !byte $23,%11110001 + !byte $26,%01110010 + !byte $26,%10010011; + !byte $25,%11010011 + !byte $17,%10110011 + !byte $1B,%11110111 + !byte $20,%10110001 + !byte $24,%10110111 + !byte $17,%00010100 + !byte $26,%11110001 + !byte $22,%01110110 + !byte $22,%10010111; + !byte $20,%00010110 + !byte $1E,%11101111 + !byte $1F,%00010000 + !byte $1C,%00011000 + !byte $23,%10110111 + !byte $25,%10110111 + !byte $1B,%11110101 + !byte $1A,%01010010 + !byte $20,%01110000 + !byte $20,%10010001; + !byte $19,%01010010 + !byte $1D,%11101111 + !byte $26,%10110011 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $1B,%00011000 + !byte $21,%01010110 + !byte $1C,%10110001 + !byte $1B,%01010010 + !byte $18,%01010010 + !byte $27,%00110010 + !byte $27,%00010010 + !byte $20,%01010000 + !byte $24,%11010111 + !byte $1F,%11101111 + !byte $27,%01010010 + !byte $23,%00110100 + !byte $1E,%11001111 + !byte $25,%11010111 + !byte $25,%11110011 + !byte $24,%00010100 + !byte $1A,%10110111 + !byte $1C,%01110000 + !byte $1C,%10010001; + !byte $1A,%11010111 + !byte $1B,%11010101 + !byte $1C,%01010010 + !byte $1A,%01110110 + !byte $1A,%10010111; + !byte $16,%11010011 + !byte $16,%10110011 + !byte $22,%10110111 + !byte $1A,%11110111 + !byte $17,%01010010 + !byte $23,%11010111 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $20,%00110000 + !byte $27,%11110001 + !byte $26,%11010011 + !byte $1A,%01010110 + !byte $1D,%11001111 + !byte $1B,%00111000 + !byte $16,%01110010 + !byte $16,%10010011; + !byte $1F,%11001111 + !byte $20,%00110110 + !byte $1A,%00011000 + !byte $16,%11110011 + !byte $24,%11110111 + !byte $19,%00110010 + !byte $1A,%00110110 + !byte $25,%11110111 + !byte $21,%01110110 + !byte $21,%10010111; + !byte $20,%00010000 + !byte $18,%00110010 + !byte $1E,%10101111 + !byte $1B,%01110100 + !byte $1B,%10010101; + !byte $1A,%00110010 + !byte $27,%10110011 + !byte $26,%01110110 + !byte $26,%10010111; + !byte $1C,%00111000 + !byte $26,%10110111 + !byte $1B,%10110101 + !byte $26,%11010001 + !byte $16,%01010010 + !byte $21,%00010010 + !byte $1A,%00111000 + !byte $17,%00110010 + !byte $28,%00110010 + !byte $23,%11110111 + !byte $1F,%10101111 + !byte $28,%00010010 + !byte $26,%11010111 + !byte $22,%11010111 + !byte $1A,%00010110 + !byte $20,%11101111 + !byte $28,%01010010 + !byte $26,%11110011 + !byte $1B,%00110010 + !byte $21,%11110001 + !byte $25,%00010100 + !byte $25,%00011000 + !byte $24,%00011000 + !byte $1D,%10101111 + !byte $21,%11010001 + !byte $26,%01010110 + !byte $1E,%01101110 + !byte $1E,%10001111; + !byte $28,%01110010 + !byte $28,%10010011; + !byte $28,%11110001 + !byte $26,%11110111 + !byte $27,%11010011 + !byte $24,%00110100 + !byte $19,%11010111 + !byte $16,%00110010 + !byte $20,%11001111 + !byte $19,%11110111 + !byte $1C,%00110010 + !byte $21,%10110001 + !byte $20,%01010110 + !byte $21,%10110111 + !byte $1B,%01011000 + !byte $19,%10110111 + !byte $27,%11010001 + !byte $25,%11010001 + !byte $19,%00011000 + !byte $1A,%01011000 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $15,%01110010 + !byte $15,%10010011; + !byte $15,%10110011 + !byte $18,%00010010 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $1A,%11110101 + !byte $19,%00010010 + !byte $23,%00011000 + !byte $19,%01110110 + !byte $19,%10010111; + !byte $17,%00010010 + !byte $15,%01010010 + !byte $28,%10110011 + !byte $19,%00111000 + !byte $21,%01010000 + !byte $26,%00011000 + !byte $20,%10101111 + !byte $22,%11110111 + !byte $25,%00111000 + !byte $24,%00111000 + !byte $19,%01010110 + !byte $1A,%00010010 + !byte $21,%00110000 + !byte $16,%00010010 + !byte $1E,%01001110 + !byte $15,%11010011 + !byte $15,%00110010 + !byte $29,%00110010 + !byte $26,%00010100 + !byte $1F,%01001110 + !byte $27,%11110011 + !byte $19,%01011000 + !byte $29,%00010010 + !byte $29,%01010010 + !byte $21,%00010000 + !byte $20,%01101110 + !byte $20,%10001111; + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $21,%11010111 + !byte $1A,%11010101 + !byte $28,%11010011 + !byte $19,%00110110 + !byte $26,%00111000 + !byte $25,%00110100 + !byte $1F,%01010110 + !byte $23,%00111000 + !byte $20,%01110110 + !byte $20,%10010111; + !byte $29,%01110010 + !byte $29,%10010011; + !byte $21,%11101111 + !byte $17,%11110001 + !byte $18,%11110001 + !byte $25,%01011000 + !byte $1B,%00010010 + !byte $22,%00011000 + !byte $15,%00010010 + !byte $29,%11110001 + !byte $24,%01011000 + !byte $1A,%01111000 + !byte $1A,%10011001; + !byte $28,%11010001 + !byte $1C,%00010010 + !byte $24,%01010100 + !byte $18,%00011000 + !byte $18,%11110111 + !byte $16,%11110001 + !byte $20,%01001110 + !byte $19,%11110001 + !byte $1F,%00101110 + !byte $21,%11001111 + !byte $18,%11010111 + !byte $19,%01111000 + !byte $19,%10011001; + !byte $29,%10110011 + !byte $18,%00111000 + !byte $1E,%00101110 + !byte $26,%01011000 + !byte $19,%00010110 + !byte $18,%10110111 + !byte $27,%00010100 + !byte $28,%11110011 + !byte $21,%10101111 + !byte $18,%01011000 + !byte $14,%01010010 + !byte $21,%11110111 + !byte $23,%01011000 + !byte $1A,%10110101 + !byte $14,%00110010 + !byte $25,%01111000 + !byte $25,%10011001; + !byte $15,%11110001 + !byte $1A,%11110001 + !byte $18,%01110110 + !byte $18,%10010111; + !byte $20,%00101110 + !byte $26,%00110100 + !byte $14,%01110010 + !byte $14,%10010011; + !byte $2A,%00110010 + !byte $24,%01111000 + !byte $24,%10011001; + !byte $2A,%01010010 + !byte $20,%10110111 + !byte $22,%00111000 + !byte $29,%11010011 + !byte $2A,%00010010 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $17,%11010001 + !byte $14,%00010010 + !byte $16,%11010001 + !byte $1F,%00001110 + !byte $18,%11010001 + !byte $2A,%01110010 + !byte $2A,%10010011; + !byte $26,%01111000 + !byte $26,%10011001; + !byte $18,%01111000 + !byte $18,%10011001; + !byte $18,%01010110 + !byte $19,%11110101 + !byte $25,%01010100 + !byte $21,%01001110 + !byte $20,%00001110 + !byte $22,%11110001 + !byte $25,%10111001 + !byte $23,%01111000 + !byte $23,%10011001; + !byte $15,%11010001 + !byte $1A,%01110100 + !byte $1A,%10010101; + !byte $19,%11010001 + !byte $14,%11110001 + !byte $28,%00010100 + !byte $2A,%10110011 + !byte $24,%01110100 + !byte $24,%10010101; + !byte $21,%00011000 + !byte $1E,%00001110 + !byte $1B,%11110001 + !byte $22,%01010000 + !byte $22,%01110000 + !byte $22,%10010001; + !byte $22,%10110001 + !byte $22,%11010001 + !byte $24,%10111001 + !byte $17,%00011000 + !byte $22,%00110000 + !byte $19,%10111001 + !byte $27,%00110100 + !byte $29,%11110011 + !byte $17,%00111000 + !byte $2A,%11110001 + !byte $1C,%11110001 + !byte $22,%01011000 + !byte $17,%11110111 + !byte $22,%00010000 + !byte $21,%00101110 + !byte $26,%10111001 + !byte $20,%11010111 + !byte $17,%01011000 + !byte $18,%00110110 + !byte $17,%11010111 + !byte $22,%11101111 + !byte $1F,%11101101 + !byte $18,%10111001 + !byte $16,%10110001 + !byte $17,%10110001 + !byte $2A,%11010011 + !byte $14,%11010001 + !byte $20,%11101101 + !byte $22,%11001111 + !byte $19,%11010101 + !byte $17,%01111000 + !byte $17,%10011001; + !byte $17,%10110111 + !byte $1A,%11010001 + !byte $29,%11010001 + !byte $26,%01010100 + !byte $18,%10110001 + !byte $2B,%01010010 + !byte $25,%11011001 + !byte $2B,%00110010 + !byte $15,%10110001 + !byte $23,%10111001 + !byte $1F,%01110110 + !byte $1F,%10010111; + !byte $22,%10101111 + !byte $21,%00111000 + !byte $21,%00001110 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $24,%11011001 + !byte $22,%01111000 + !byte $22,%10011001; + !byte $18,%00010110 + !byte $29,%00010100 + !byte $22,%01101110 + !byte $22,%10001111; + !byte $26,%11011001 + !byte $17,%01110110 + !byte $17,%10010111; + !byte $28,%00110100 + !byte $2B,%00010010 + !byte $13,%00010010 + !byte $14,%10110001 + !byte $2B,%10110011 + !byte $2A,%11110011 + !byte $20,%11110111 + !byte $19,%10110001 + !byte $13,%11110001 + !byte $17,%10111001 + !byte $13,%00110010 + !byte $21,%11101101 + !byte $22,%01001110 + !byte $20,%11001101 + !byte $16,%01110000 + !byte $16,%10010001; + !byte $27,%01010100 + !byte $25,%11111001 + !byte $1F,%11001101 + !byte $25,%01110100 + !byte $25,%10010101; + !byte $23,%11011001 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $15,%01110000 + !byte $15,%10010001; + !byte $13,%11010001 + !byte $16,%00111000 + !byte $17,%01010110 + !byte $16,%00011000 + !byte $21,%01011000 + !byte $2B,%11010011 + !byte $24,%11111001 + !byte $1B,%11010001 + !byte $22,%00101110 + !byte $16,%01011000 + !byte $19,%10110101 + !byte $16,%11110111 + !byte $22,%10111001 + !byte $26,%11111001 + !byte $1F,%10110111 + !byte $18,%11110101 + !byte $18,%01110000 + !byte $18,%10010001; + !byte $16,%01111000 + !byte $16,%10011001; + !byte $14,%01110000 + !byte $14,%10010001; + !byte $29,%00110100 + !byte $1E,%11101101 + !byte $2A,%00010100 + !byte $21,%11001101 + !byte $1C,%11010001 + !byte $16,%11010111 + !byte $20,%00011000 + !byte $22,%00001110 + !byte $13,%10110001 + !byte $1A,%10110001 + !byte $2C,%01010010 + !byte $18,%11011001 + !byte $2C,%01110010 + !byte $2C,%10010011; + !byte $26,%01110100 + !byte $26,%10010101; + !byte $25,%00011010 + !byte $17,%00110110 + !byte $2B,%11110011 + !byte $28,%01010100 + !byte $23,%11111001 + !byte $20,%10101101 + !byte $2C,%00110010 + !byte $16,%10111001 + !byte $16,%10110111 + !byte $17,%11011001 + !byte $16,%01010000 + !byte $2B,%11110001 + !byte $24,%00011010 + !byte $15,%01010000 + !byte $2C,%10110011 + !byte $21,%01111000 + !byte $21,%10011001; + !byte $22,%11101101 + !byte $27,%01111000 + !byte $27,%10011001; + !byte $22,%11011001 + !byte $27,%01011000 + !byte $19,%01110000 + !byte $19,%10010001; + !byte $17,%01010000 + !byte $26,%00011010 + !byte $21,%10101101 + !byte $23,%11101111 + !byte $23,%00010000 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $23,%11001111 + !byte $23,%00110000 + !byte $14,%01010000 + !byte $19,%01110100 + !byte $19,%10010101; + !byte $23,%10101111 + !byte $16,%01110110 + !byte $16,%10010111; + !byte $23,%01010000 + !byte $20,%00111000 + !byte $1F,%11010111 + !byte $2C,%11010011 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $2A,%00110100 + !byte $27,%01110100 + !byte $27,%10010101; + !byte $18,%11010101 + !byte $22,%11001101 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $27,%10111001 + !byte $1F,%10101101 + !byte $2B,%00010100 + !byte $29,%01010100 + !byte $17,%00010110 + !byte $25,%00111010 + !byte $15,%00111000 + !byte $2C,%00010010 + !byte $18,%01010000 + !byte $23,%01001110 + !byte $23,%00011010 + !byte $15,%01011000 + !byte $23,%10110001 + !byte $25,%10110101 + !byte $15,%00011000 + !byte $16,%11011001 + !byte $24,%00111010 + !byte $21,%10111001 + !byte $15,%01111000 + !byte $15,%10011001; + !byte $13,%01010000 + !byte $23,%11010001 + !byte $22,%11111001 + !byte $1B,%10110001 + !byte $23,%00101110 + !byte $15,%00110000 + !byte $15,%11110111 + !byte $2C,%11110011 + !byte $16,%00110000 + !byte $16,%01010110 + !byte $20,%01101100 + !byte $20,%10001101; + !byte $21,%01101100 + !byte $21,%10001101; + !byte $26,%00111010 + !byte $14,%00110000 + !byte $22,%10101101 + !byte $28,%01110100 + !byte $28,%10010101; + !byte $1A,%01110000 + !byte $1A,%10010001; + !byte $23,%00001110 + !byte $15,%10111001 + !byte $20,%01011000 + !byte $12,%11010001 + !byte $12,%10110001 + !byte $15,%11010111 + !byte $27,%11011001 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $17,%00110000 + !byte $1F,%11110111 + !byte $2B,%00110100 + !byte $2D,%01010010 + !byte $19,%01010000 + !byte $2D,%10110011 + !byte $2A,%01010100 + !byte $23,%00111010 + !byte $25,%01011010 + !byte $23,%11101101 + !byte $26,%10110101 + !byte $17,%11110101 + !byte $12,%01110000 + !byte $12,%10010001; + !byte $2C,%00010100 + !byte $21,%11011001 + !byte $18,%10110101 + !byte $13,%00110000 + !byte $24,%01011010 + !byte $15,%10110111 + !byte $12,%11110001 + !byte $22,%00011010 + !byte $22,%01101100 + !byte $22,%10001101; + !byte $16,%00110110 + !byte $2D,%11010011 + !byte $29,%01110100 + !byte $29,%10010101; + !byte $18,%00110000 + !byte $15,%11011001 + !byte $23,%11001101 + !byte $15,%00010000 + !byte $2D,%00110010 + !byte $20,%01111000 + !byte $20,%10011001; + !byte $26,%01011010 + !byte $16,%00010000 + !byte $12,%01010000 + !byte $14,%00010000 + !byte $27,%10110101 + !byte $21,%01001100 + !byte $1F,%00011000 + !byte $2D,%11110011 + !byte $14,%01011000 + !byte $14,%00111000 + !byte $15,%01110110 + !byte $15,%10010111; + !byte $23,%01011010 + !byte $23,%10101101 + !byte $2B,%01010100 + !byte $21,%11111001 + !byte $14,%01111000 + !byte $14,%10011001; + !byte $2C,%00110100 + !byte $25,%01111010 + !byte $25,%10011011; + !byte $14,%00011000 + !byte $27,%11111001 + !byte $13,%00010000 + !byte $17,%00010000 + !byte $22,%00111010 + !byte $24,%01111010 + !byte $24,%10011011; + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $25,%11010101 + !byte $22,%01001100 + !byte $2A,%01110100 + !byte $2A,%10010101; + !byte $12,%00110000 + !byte $1A,%01010000 + !byte $24,%01101110 + !byte $24,%10001111; + !byte $24,%10101111 + !byte $28,%10110101 + !byte $24,%11001111 + !byte $14,%10111001 + !byte $14,%11110111 + !byte $20,%01001100 + !byte $16,%00010110 + !byte $24,%01001110 + !byte $24,%11101111 + !byte $17,%11010101 + !byte $20,%10111001 + !byte $2D,%00010100 + !byte $24,%00101110 + !byte $19,%00110000 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $15,%01010110 + !byte $16,%11111001 + !byte $24,%00010000 + !byte $15,%11101111 + !byte $14,%11101111 + !byte $14,%11010111 + !byte $24,%00001110 + !byte $18,%01110100 + !byte $18,%10010101; + !byte $26,%01111010 + !byte $26,%10011011; + !byte $1F,%00111000 + !byte $24,%00110000 + !byte $2E,%10110011 + !byte $23,%01111010 + !byte $23,%10011011; + !byte $16,%11101111 + !byte $2E,%01110010 + !byte $2E,%10010011; + !byte $18,%00010000 + !byte $29,%10110101 + !byte $21,%00011010 + !byte $24,%11101101 + !byte $2E,%11010011 + !byte $2C,%01010100 + !byte $25,%10111011 + !byte $1E,%11010111 + !byte $12,%00010000 + !byte $13,%11101111 + !byte $14,%11011001 + !byte $22,%01011010 + !byte $24,%01010000 + !byte $2B,%01110100 + !byte $2B,%10010101; + !byte $26,%11010101 + !byte $24,%10111011 + !byte $21,%00101100 + !byte $15,%11111001 + !byte $23,%01001100 + !byte $22,%00101100 + !byte $14,%10110111 + !byte $2D,%00110100 + !byte $24,%11001101 + !byte $20,%11011001 + !byte $2E,%11110011 + !byte $16,%11110101 + !byte $17,%11101111 + !byte $24,%01110000 + !byte $24,%10010001; + !byte $15,%00110110 + !byte $2E,%01010010 + !byte $1F,%01011000 + !byte $27,%11010101 + !byte $2A,%10110101 + !byte $24,%10101101 + !byte $13,%01011000 + !byte $21,%00111010 + !byte $23,%10111011 + !byte $13,%00111000 + !byte $14,%11001111 + !byte $15,%11001111 + !byte $13,%01111000 + !byte $13,%10011001; + !byte $12,%11101111 + !byte $17,%10110101 + !byte $2E,%00010100 + !byte $14,%01110110 + !byte $14,%10010111; + !byte $26,%10111011 + !byte $24,%10110001 + !byte $22,%01111010 + !byte $22,%10011011; + !byte $13,%00011000 + !byte $13,%11001111 + !byte $1A,%00110000 + !byte $1B,%01010000 + !byte $23,%00101100 + !byte $2C,%01110100 + !byte $2C,%10010101; + !byte $28,%11010101 + !byte $13,%10111001 + !byte $25,%11011011 + !byte $2D,%01010100 + !byte $24,%01101100 + !byte $24,%10001101; + !byte $16,%11001111 + !byte $19,%00010000 + !byte $24,%11011011 + !byte $18,%01010100 + !byte $20,%11111001 + !byte $13,%11110111 + !byte $24,%11010001 + !byte $1E,%11110111 + !byte $18,%11101111 + !byte $1F,%01111000 + !byte $1F,%10011001; + !byte $14,%11111001 + !byte $2B,%10110101 + !byte $15,%00010110 + !byte $29,%11010101 + !byte $2E,%00110100 + !byte $21,%01011010 + !byte $24,%01001100 + !byte $11,%01010000 + !byte $11,%00110000 + !byte $22,%00001100 + !byte $14,%01010110 + !byte $12,%11001111 + !byte $13,%11010111 + !byte $16,%11010101 + !byte $23,%11011011 + !byte $13,%11011001 + !byte $17,%11001111 + !byte $22,%10111011 + !byte $14,%10101111 + !byte $25,%00101110 + !byte $25,%01001110 + !byte $25,%01101110 + !byte $25,%10001111; + !byte $25,%00001110 + !byte $11,%00010000 + !byte $15,%10101111 + !byte $2F,%11010011 + !byte $20,%00011010 + !byte $25,%10101111 + !byte $13,%10101111 + !byte $23,%00001100 + !byte $25,%11101101 + !byte $2F,%10110011 + !byte $2A,%11010101 + !byte $2F,%11110011 + !byte $24,%11111011 + !byte $25,%11001111 + !byte $2D,%01110100 + !byte $2D,%10010101; + !byte $1F,%10111001 + !byte $1E,%00011000 + !byte $13,%10110111 + !byte $25,%11111011 + !byte $2C,%10110101 + !byte $25,%11001101 + !byte $26,%11110101 + !byte $24,%00101100 + !byte $26,%11011011 + !byte $16,%10101111 + !byte $2E,%01010100 + !byte $25,%11101111 + !byte $17,%01110100 + !byte $17,%10010101; + !byte $2F,%00010100 + !byte $21,%01111010 + !byte $21,%10011011; + !byte $11,%11101111 + !byte $25,%10101101 + !byte $14,%00110110 + !byte $12,%01011000 + !byte $12,%01111000 + !byte $12,%10011001; + !byte $12,%00111000 + !byte $21,%00001100 + !byte $27,%11110101 + !byte $23,%11111011 + !byte $12,%10101111 + !byte $15,%11110101 + !byte $11,%01110000 + !byte $11,%10010001; + !byte $19,%11101111 + !byte $1A,%00010000 + !byte $22,%11011011 + !byte $2B,%11010101 + !byte $25,%00010000 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $20,%00111010 + !byte $18,%11001111 + !byte $12,%00011000 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $28,%11110101 + !byte $13,%01110110 + !byte $13,%10010111; + !byte $12,%10111001 + !byte $1B,%00110000 + !byte $1C,%01010000 + !byte $1F,%11011001 + !byte $14,%01101110 + !byte $14,%10001111; + !byte $2F,%00110100 + !byte $24,%00001100 + !byte $13,%11111001 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $1E,%00111000 + !byte $12,%11110111 + !byte $16,%10110101 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $2D,%10110101 + !byte $11,%11001111 + !byte $17,%10101111 + !byte $25,%00110000 + !byte $2E,%01110100 + !byte $2E,%10010101; + !byte $29,%11110101 + !byte $24,%00011100 + !byte $21,%10111011 + !byte $25,%01001100 + !byte $23,%11101011 + !byte $2C,%11010101 + !byte $25,%00011100 + !byte $12,%11011001 + !byte $20,%01011010 + !byte $1F,%11111001 + !byte $12,%11010111 + !byte $12,%01101110 + !byte $12,%10001111; + !byte $22,%11101011 + !byte $23,%00011100 + !byte $13,%01010110 + !byte $25,%01010000 + !byte $14,%00010110 + !byte $2A,%11110101 + !byte $16,%01101110 + !byte $16,%10001111; + !byte $22,%11111011 + !byte $2F,%01010100 + !byte $25,%00101100 + !byte $1E,%01011000 + !byte $26,%11111011 + !byte $11,%10101111 + !byte $15,%11010101 + !byte $17,%01010100 + !byte $24,%11101011 + !byte $14,%01001110 + !byte $21,%11011011 + !byte $13,%01001110 + !byte $2B,%11110101 + !byte $2E,%10110101 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $12,%10110111 + !byte $19,%11001111 + !byte $18,%10101111 + !byte $26,%00001110 + !byte $30,%11110011 + !byte $2D,%11010101 + !byte $26,%11101101 + !byte $26,%00101110 + !byte $24,%00111100 + !byte $20,%01111010 + !byte $20,%10011011; + !byte $15,%01001110 + !byte $1A,%11101111 + !byte $1F,%00011010 + !byte $30,%00010100 + !byte $26,%11001101 + !byte $25,%00001100 + !byte $26,%01001110 + !byte $11,%01011000 + !byte $2F,%01110100 + !byte $2F,%10010101; + !byte $30,%11010011 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $11,%00111000 + !byte $26,%00010110 + !byte $22,%00011100 + !byte $1E,%01111000 + !byte $1E,%10011001; + !byte $11,%01111000 + !byte $11,%10011001; + !byte $13,%00110110 + !byte $12,%01001110 + !byte $26,%01101110 + !byte $26,%10001111; + !byte $26,%10101101 + !byte $23,%00111100 + !byte $16,%01110100 + !byte $16,%10010101; + !byte $11,%00011000 + !byte $1B,%00010000 + !byte $30,%00110100 + !byte $2C,%11110101 + !byte $27,%00010110 + !byte $14,%11110101 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $25,%00111100 + !byte $28,%00010110 + !byte $26,%10101111 + !byte $26,%01101100 + !byte $26,%10001101; + !byte $25,%10110001 + !byte $11,%10111001 + !byte $12,%01110110 + !byte $12,%10010111; + !byte $12,%11111001 + !byte $16,%01001110 + !byte $1C,%00110000 + !byte $29,%00010110 + !byte $21,%11111011 + !byte $11,%11110111 + !byte $1F,%00111010 + !byte $26,%11001111 + !byte $20,%10111011 + !byte $26,%01001100 + !byte $25,%11101011 + !byte $13,%00101110 + !byte $23,%11001011 + !byte $2E,%11010101 + !byte $1E,%10111001 + !byte $14,%00101110 + !byte $30,%01010100 + !byte $15,%10110101 + !byte $2A,%00010110 + !byte $24,%11001011 + !byte $2F,%10110101 + !byte $30,%10110011 + !byte $2D,%11110101 + !byte $22,%00111100 + !byte $26,%00101100 + !byte $26,%11101111 + !byte $24,%01011100 + !byte $11,%11010111 + !byte $13,%00010110 + !byte $15,%00101110 + !byte $12,%00101110 + !byte $11,%11011001 + !byte $11,%01001110 + !byte $18,%01101110 + !byte $18,%10001111; + !byte $12,%01010110 + !byte $2B,%00010110 + !byte $23,%01011100 + !byte $17,%00110100 + !byte $19,%10101111 + !byte $17,%01001110 + !byte $21,%00011100 + !byte $30,%01110100 + !byte $30,%10010101; + !byte $1F,%01011010 + !byte $1E,%11011001 + !byte $20,%11011011 + !byte $1D,%00011000 + !byte $1A,%11001111 + !byte $14,%11010101 + !byte $26,%00010000 + !byte $26,%00001100 + !byte $11,%10110111 + !byte $16,%00101110 + !byte $2C,%00010110 + !byte $26,%00011100 + !byte $2F,%11010101 + !byte $25,%11001011 + !byte $25,%01011100 + !byte $2E,%11110101 + !byte $13,%00001110 + !byte $10,%01011000 + !byte $14,%00001110 + !byte $1B,%11101111 + !byte $22,%01011100 + !byte $10,%00111000 + !byte $16,%01010100 + !byte $1E,%11111001 + !byte $1F,%01111010 + !byte $1F,%10011011; + !byte $10,%01111000 + !byte $10,%10011001; + !byte $11,%00101110 + !byte $26,%00110000 + !byte $30,%10110101 + !byte $26,%11101011 + !byte $20,%11111011 + !byte $12,%00110110 + !byte $27,%11101101 + !byte $10,%00011000 + !byte $27,%11001101 + !byte $12,%00001110 + !byte $27,%00001110 + !byte $24,%01111100 + !byte $24,%10011101; + !byte $21,%00111100 + !byte $27,%10101101 + !byte $13,%11110101 + !byte $23,%01111100 + !byte $23,%10011101; + !byte $15,%00001110 + !byte $2D,%00010110 + !byte $11,%01110110 + !byte $11,%10010111; + !byte $28,%00110110 + !byte $26,%00110110 + !byte $1D,%00111000 + !byte $27,%00101110 + !byte $31,%00110100 + !byte $29,%00110110 + !byte $31,%00010100 + !byte $27,%00110110 + !byte $10,%10111001 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $15,%01110100 + !byte $15,%10010101; + !byte $2A,%00110110 + !byte $18,%01001110 + !byte $1C,%00010000 + !byte $10,%11110111 + !byte $27,%01001110 + !byte $1E,%00011010 + !byte $17,%00101110 + !byte $27,%01001100 + !byte $11,%11111001 + !byte $31,%01010100 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $1F,%10111011 + !byte $2B,%00110110 + !byte $26,%01010000 + !byte $2F,%11110101 + !byte $24,%10101011 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $31,%11110011 + !byte $10,%11010111 + !byte $22,%01111100 + !byte $22,%10011101; + !byte $30,%11010101 + !byte $20,%00011100 + !byte $27,%00101100 + !byte $26,%11001011 + !byte $13,%11101101 + !byte $16,%00001110 + !byte $14,%10110101 + !byte $25,%10101011 + !byte $2E,%00010110 + !byte $11,%00001110 + !byte $1D,%01011000 + !byte $12,%00010110 + !byte $14,%11101101 + !byte $31,%01110100 + !byte $31,%10010101; + !byte $2C,%00110110 + !byte $21,%01011100 + !byte $11,%01010110 + !byte $1A,%10101111 + !byte $27,%10101111 + !byte $12,%11101101 + !byte $1E,%00111010 + !byte $10,%11011001 + !byte $27,%00001100 + !byte $10,%10101111 + !byte $1F,%11011011 + !byte $23,%10111101 + !byte $10,%01101110 + !byte $10,%10001111; + !byte $10,%10110111 + !byte $15,%11101101 + !byte $26,%01110000 + !byte $26,%10010001; + !byte $25,%01111100 + !byte $25,%10011101; + !byte $13,%11010101 + !byte $24,%10111101 + !byte $2D,%00110110 + !byte $31,%10110101 + !byte $1D,%01111000 + !byte $1D,%10011001; + !byte $27,%11001111 + !byte $1B,%11001111 + !byte $20,%00111100 + !byte $30,%11110101 + !byte $27,%11101011 + !byte $16,%00110100 + !byte $2F,%00010110 + !byte $11,%00110110 + !byte $10,%01001110 + !byte $26,%10101011 + !byte $1E,%01011010 + !byte $17,%00001110 + !byte $18,%00101110 + !byte $22,%10111101 + !byte $0F,%01011000 + !byte $0F,%00111000 + !byte $21,%01111100 + !byte $21,%10011101; + !byte $11,%11101101 + !byte $0F,%01111000 + !byte $0F,%10011001; + !byte $13,%11001101 + !byte $1F,%11111011 + !byte $19,%01001110 + !byte $12,%11110101 + !byte $1D,%10111001 + !byte $0F,%00011000 + !byte $16,%11101101 + !byte $2E,%00110110 + !byte $27,%11101111 + !byte $15,%01010100 + !byte $10,%01110110 + !byte $10,%10010111; + !byte $14,%11001101 + !byte $26,%10110001 + !byte $2A,%01010110 + !byte $29,%01010110 + !byte $31,%11010101 + !byte $12,%11001101 + !byte $2B,%01010110 + !byte $28,%01010110 + !byte $0F,%11110111 + !byte $14,%01110100 + !byte $14,%10010101; + !byte $1C,%11101111 + !byte $1E,%01111010 + !byte $1E,%10011011; + !byte $27,%11001011 + !byte $10,%00101110 + !byte $28,%10101101 + !byte $28,%11001101 + !byte $20,%01011100 + !byte $28,%01101100 + !byte $28,%10001101; + !byte $28,%11101101 + !byte $27,%01010110 + !byte $0F,%10111001 + !byte $1A,%01101110 + !byte $1A,%10001111; + !byte $2C,%01010110 + !byte $15,%11001101 + !byte $23,%11011101 + !byte $1D,%11011001 + !byte $28,%01001100 + !byte $28,%00001110 + !byte $27,%00010000 + !byte $30,%00010110 + !byte $21,%10111101 + !byte $0F,%11010111 + !byte $11,%00010110 + !byte $13,%10110101 + !byte $1F,%00011100 + !byte $10,%01010110 + !byte $2D,%01010110 + !byte $28,%00101100 + !byte $28,%00101110 + !byte $22,%11011101 + !byte $2F,%00110110 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $24,%11011101 + !byte $1E,%10111011 + !byte $11,%11001101 + !byte $31,%11110101 + !byte $17,%11101101 + !byte $32,%01010100 + !byte $28,%00001100 + !byte $1D,%11111001 + !byte $13,%10101101 + !byte $32,%01110100 + !byte $32,%10010101; + !byte $27,%10101011 + !byte $18,%00001110 + !byte $28,%01001110 + !byte $1B,%10101111 + !byte $10,%00001110 + !byte $12,%11010101 + !byte $14,%10101101 + !byte $26,%01101010 + !byte $26,%10001011; + !byte $20,%01111100 + !byte $20,%10011101; + !byte $32,%00110100 + !byte $0F,%10110111 + !byte $12,%10101101 + !byte $27,%00110000 + !byte $16,%11001101 + !byte $10,%11111001 + !byte $19,%00101110 + !byte $32,%10110101 + !byte $2E,%01010110 + !byte $1F,%00111100 + !byte $28,%11101011 + !byte $28,%01101110 + !byte $28,%10001111; + !byte $1E,%11011011 + !byte $1D,%00011010 + !byte $0F,%11011001 + !byte $16,%00010100 + !byte $10,%00110110 + !byte $30,%00110110 + !byte $21,%11011101 + !byte $15,%10101101 + !byte $2A,%01110110 + !byte $2A,%10010111; + !byte $31,%00010110 + !byte $2B,%01110110 + !byte $2B,%10010111; + !byte $23,%11111101 + !byte $11,%11110101 + !byte $0E,%00111000 + !byte $15,%00110100 + !byte $32,%11010101 + !byte $0E,%01011000 + !byte $0F,%01110110 + !byte $0F,%10010111; + !byte $1A,%01001110 + !byte $29,%01110110 + !byte $29,%10010111; + !byte $0E,%00011000 + !byte $28,%11001011 + !byte $28,%10101111 + !byte $2C,%01110110 + !byte $2C,%10010111; + !byte $14,%01010100 + !byte $22,%11111101 + !byte $11,%10101101 + !byte $25,%10111101 + !byte $2F,%01010110 + !byte $10,%11101101 + !byte $1C,%11001111 + !byte $27,%01010000 + !byte $20,%10111101 + !byte $1D,%00111010 + !byte $1E,%11111011 + !byte $0E,%01111000 + !byte $0E,%10011001; + !byte $13,%01110100 + !byte $13,%10010101; + !byte $27,%01101010 + !byte $27,%10001011; + !byte $1F,%01011100 + !byte $0E,%11110111 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $2D,%01110110 + !byte $2D,%10010111; + !byte $28,%01110110 + !byte $28,%10010111; + !byte $17,%11001101 + !byte $12,%01101100 + !byte $12,%10001101; + !byte $14,%01101100 + !byte $14,%10001101; + !byte $18,%11101101 + !byte $12,%10110101 + !byte $28,%11001111 + !byte $10,%00010110 + !byte $16,%10101101 + !byte $32,%11110101 + !byte $1D,%01011010 + !byte $0E,%11010111 + !byte $0F,%01010110 + !byte $28,%10101011 + !byte $29,%01101100 + !byte $29,%10001101; + !byte $29,%10101101 + !byte $31,%00110110 + !byte $21,%11111101 + !byte $27,%01110110 + !byte $27,%10010111; + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $2E,%01110110 + !byte $2E,%10010111; + !byte $29,%01001100 + !byte $29,%11001101 + !byte $30,%01010110 + !byte $29,%00101100 + !byte $0E,%10111001 + !byte $24,%11111101 + !byte $20,%11011101 + !byte $1E,%00011100 + !byte $19,%00001110 + !byte $1C,%01011000 + !byte $1F,%01111100 + !byte $1F,%10011101; + !byte $29,%11101101 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $27,%01110000 + !byte $27,%10010001; + !byte $10,%11001101 + !byte $11,%11010101 + !byte $29,%00001100 + !byte $0E,%10110111 + !byte $29,%00001110 + !byte $11,%01101100 + !byte $11,%10001101; + !byte $28,%11101111 + !byte $1D,%01111010 + !byte $1D,%10011011; + !byte $32,%00010100 + !byte $32,%00010110 + !byte $22,%00011110 + !byte $2F,%01110110 + !byte $2F,%10010111; + !byte $23,%00011110 + !byte $1C,%01111000 + !byte $1C,%10011001; + !byte $13,%01001100 + !byte $29,%11101011 + !byte $0F,%00110110 + !byte $1A,%00101110 + !byte $29,%00101110 + !byte $12,%01001100 + !byte $2C,%10110111 + !byte $2B,%10110111 + !byte $1E,%00111100 + !byte $28,%01101010 + !byte $28,%10001011; + !byte $2A,%10110111 + !byte $1D,%10111011 + !byte $14,%01001100 + !byte $1F,%10111101 + !byte $17,%10101101 + !byte $31,%01010110 + !byte $2D,%10110111 + !byte $0E,%01110110 + !byte $0E,%10010111; + !byte $10,%11110101 + !byte $13,%01010100 + !byte $21,%00011110 + !byte $14,%00110100 + !byte $18,%11001101 + !byte $15,%00010100 + !byte $16,%01101100 + !byte $16,%10001101; + !byte $1C,%10101111 + !byte $29,%11001011 + !byte $29,%01001110 + !byte $26,%01001010 + !byte $1C,%10111001 + !byte $20,%11111101 + !byte $28,%00010000 + !byte $29,%10110111 + !byte $30,%01110110 + !byte $30,%10010111; + !byte $27,%01001010 + !byte $27,%10110001 + !byte $0D,%00111000 + !byte $0D,%00011000 + !byte $12,%01110100 + !byte $12,%10010101; + !byte $2E,%10110111 + !byte $10,%10101101 + !byte $32,%00110110 + !byte $15,%01001100 + !byte $33,%10110101 + !byte $0D,%01011000 + !byte $19,%11101101 + !byte $1E,%01011100 + !byte $1D,%11011011 + !byte $33,%11010101 + !byte $1C,%11011001 + !byte $11,%01001100 + !byte $29,%01101110 + !byte $29,%10001111; + !byte $0D,%11110111 + !byte $11,%10110101 + !byte $1B,%01001110 + !byte $28,%10110111 + !byte $0E,%01010110 + !byte $0F,%00010110 + !byte $29,%10101011 + !byte $1F,%11011101 + !byte $33,%01110100 + !byte $33,%10010101; + !byte $2F,%10110111 + !byte $13,%00101100 + !byte $33,%11110101 + !byte $22,%00111110 + !byte $0D,%01111000 + !byte $0D,%10011001; + !byte $1C,%11111001 + !byte $0D,%11010111 + !byte $28,%00110000 + !byte $0E,%11011001 + !byte $1D,%11111011 + !byte $12,%00101100 + !byte $1A,%00001110 + !byte $10,%11010101 + !byte $14,%00101100 + !byte $31,%01110110 + !byte $31,%10010111; + !byte $20,%00011110 + !byte $1E,%01111100 + !byte $1E,%10011101; + !byte $17,%01101100 + !byte $17,%10001101; + !byte $29,%10101111 + !byte $27,%10110111 + !byte $21,%00111110 + !byte $28,%01001010 + !byte $1C,%00011010 + !byte $2A,%01001100 + !byte $2A,%01101100 + !byte $2A,%10001101; + !byte $32,%01010110 + !byte $2A,%00101100 + !byte $2A,%10101101 + !byte $30,%10110111 + !byte $33,%00010110 + !byte $16,%01001100 + !byte $18,%10101101 + !byte $23,%00111110 + !byte $0D,%10110111 + !byte $10,%01101100 + !byte $10,%10001101; + !byte $2C,%11010111 + !byte $2A,%00001100 + !byte $2A,%11001101 + !byte $2D,%11010111 + !byte $29,%01101010 + !byte $29,%10001011; + !byte $0E,%00110110 + !byte $2B,%11010111 + !byte $1D,%00011100 + !byte $1F,%11111101 + !byte $0F,%11110101 + !byte $15,%00101100 + !byte $2A,%11101011 + !byte $2E,%11010111 + !byte $2A,%11101101 + !byte $1C,%00111010 + !byte $11,%00101100 + !byte $1E,%10111101 + !byte $1C,%01101110 + !byte $1C,%10001111; + !byte $2A,%11010111 + !byte $29,%11001111 + !byte $19,%11001101 + !byte $12,%01010100 + !byte $13,%00110100 + !byte $0D,%01110110 + !byte $0D,%10010111; + !byte $2A,%00001110 + !byte $11,%01110100 + !byte $11,%10010101; + !byte $28,%01010000 + !byte $14,%00010100 + !byte $0D,%10111001 + !byte $13,%00001100 + !byte $33,%00110110 + !byte $20,%00111110 + !byte $1C,%01011010 + !byte $1D,%00111100 + !byte $15,%11110011 + !byte $1B,%00101110 + !byte $2F,%11010111 + !byte $2A,%11001011 + !byte $29,%11010111 + !byte $12,%00001100 + !byte $31,%10110111 + !byte $32,%01110110 + !byte $32,%10010111; + !byte $14,%00001100 + !byte $10,%10110101 + !byte $22,%01011110 + !byte $24,%00011110 + !byte $2A,%00101110 + !byte $21,%01011110 + !byte $1F,%00011110 + !byte $1C,%01111010 + !byte $1C,%10011011; + !byte $1A,%11101101 + !byte $0E,%00010110 + !byte $0C,%00011000 + !byte $29,%11101111 + !byte $16,%00101100 + !byte $1E,%11011101 + !byte $10,%01001100 + !byte $17,%01001100 + !byte $0C,%00111000 + !byte $2A,%10101011 + !byte $0D,%01010110 + !byte $18,%01101100 + !byte $18,%10001101; + !byte $30,%11010111 + !byte $29,%01001010 + !byte $0C,%11110111 + !byte $1D,%01011100 + !byte $33,%01010110 + !byte $28,%11010111 + !byte $0F,%11010101 + !byte $15,%00001100 + !byte $1C,%10111011 + !byte $11,%00001100 + !byte $2A,%01001110 + !byte $28,%01110000 + !byte $28,%10010001; + !byte $0C,%01011000 + !byte $0C,%11010111 + !byte $2D,%11110111 + !byte $2C,%11110111 + !byte $2E,%11110111 + !byte $19,%10101101 + !byte $32,%10110111 + !byte $20,%01011110 + !byte $13,%11101011 + !byte $1C,%01001110 + !byte $2B,%11110111 + !byte $1D,%01111100 + !byte $1D,%10011101; + !byte $1E,%11111101 + !byte $1C,%11011011 + !byte $2A,%01101010 + !byte $2A,%10001011; + !byte $1F,%00111110 + !byte $0C,%10110111 + !byte $31,%11010111 + !byte $29,%00010000 + !byte $12,%11101011 + !byte $2A,%01101110 + !byte $2A,%10001111; + !byte $0D,%00110110 + !byte $11,%01010100 + !byte $2F,%11110111 + !byte $12,%00110100 + !byte $14,%11101011 + !byte $0E,%11110101 + !byte $2B,%00101100 + !byte $2B,%01001100 + !byte $27,%11010111 + !byte $1B,%00001110 + !byte $33,%01110110 + !byte $33,%10010111; + !byte $28,%00101010 + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $10,%01110100 + !byte $10,%10010101; + !byte $2A,%11110111 + !byte $2B,%00001100 + !byte $0C,%01111000 + !byte $0C,%10011001; + !byte $13,%00010100 + !byte $17,%00101100 + !byte $1C,%11111011 + !byte $2B,%10101101 + !byte $16,%00001100 + !byte $10,%00101100 + !byte $2B,%11101011 + !byte $23,%01011110 + !byte $21,%01111110 + !byte $21,%10011111; + !byte $1B,%01111000 + !byte $1B,%10011001; + !byte $0C,%01110110 + !byte $0C,%10010111; + !byte $18,%01001100 + !byte $1A,%11001101 + !byte $30,%11110111 + !byte $1D,%10111101 + !byte $14,%11110011 + !byte $2B,%11001101 + !byte $0F,%10110101 + !byte $28,%10110001 + !byte $2A,%10101111 + !byte $1E,%00011110 + !byte $2B,%11001011 + !byte $34,%00010110 + !byte $15,%11101011 + !byte $34,%11110101 + !byte $29,%11110111 + !byte $22,%01111110 + !byte $22,%10011111; + !byte $1B,%10111001 + !byte $11,%11101011 + !byte $1C,%00011100 + !byte $32,%11010111 + !byte $0D,%00010110 + !byte $2A,%01001010 + !byte $29,%00110000 + !byte $2B,%11101101 + !byte $20,%01111110 + !byte $20,%10011111; + !byte $1F,%01011110 + !byte $29,%00101010 + !byte $34,%00110110 + !byte $1B,%11011001 + !byte $13,%11001011 + !byte $0C,%01010110 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $33,%10110111 + !byte $31,%11110111 + !byte $2B,%10101011 + !byte $1D,%11011101 + !byte $0E,%11010101 + !byte $12,%11001011 + !byte $2B,%00001110 + !byte $2D,%00011000 + !byte $2E,%00011000 + !byte $1C,%00111100 + !byte $1B,%11111001 + !byte $14,%11001011 + !byte $2A,%11001111 + !byte $2C,%00011000 + !byte $34,%01010110 + !byte $0B,%00011000 + !byte $2F,%00011000 + !byte $0B,%11110111 + !byte $1E,%00111110 + !byte $1C,%00101110 + !byte $17,%00001100 + !byte $1B,%11101101 + !byte $28,%11110111 + !byte $1B,%00011010 + !byte $16,%11101011 + !byte $2B,%00011000 + !byte $34,%11010101 + !byte $0B,%00111000 + !byte $1A,%10101101 + !byte $0B,%11010111 + !byte $2B,%00101110 + !byte $11,%00110100 + !byte $0D,%11110101 + !byte $10,%01010100 + !byte $1B,%00111010 + !byte $18,%00101100 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $1C,%01011100 + !byte $12,%00010100 + !byte $1D,%11111101 + !byte $30,%00011000 + !byte $0C,%00110110 + !byte $10,%00001100 + !byte $15,%11001011 + !byte $32,%11110111 + !byte $0F,%01110100 + !byte $0F,%10010101; + !byte $29,%01010000 + !byte $1F,%01111110 + !byte $1F,%10011111; + !byte $33,%11010111 + !byte $0B,%10110111 + !byte $1B,%01011010 + !byte $11,%11001011 + !byte $21,%10111111 + !byte $34,%01110110 + !byte $34,%10010111; + !byte $2A,%00011000 + !byte $2A,%11101111 + !byte $1C,%01111100 + !byte $1C,%10011101; + !byte $2B,%01001110 + !byte $20,%10111111 + !byte $13,%11110011 + !byte $13,%10101011 + !byte $2A,%00101010 + !byte $1B,%01111010 + !byte $1B,%10011011; + !byte $0E,%10110101 + !byte $19,%01001100 + !byte $31,%00011000 + !byte $1E,%01011110 + !byte $0B,%01011000 + !byte $2C,%00101100 + !byte $27,%11110111 + !byte $0B,%01110110 + !byte $0B,%10010111; + !byte $12,%10101011 + !byte $2C,%00001100 + !byte $2C,%01001100 + !byte $1D,%00011110 + !byte $14,%10101011 + !byte $2C,%01101100 + !byte $2C,%10001101; + !byte $1B,%10111011 + !byte $0C,%00010110 + !byte $2C,%11101011 + !byte $2B,%01001010 + !byte $2C,%10101101 + !byte $17,%11101011 + !byte $16,%11001011 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $2E,%00111000 + !byte $2D,%00111000 + !byte $34,%10110111 + !byte $1C,%10111101 + !byte $0D,%11010101 + !byte $14,%11010011 + !byte $29,%00011000 + !byte $2C,%11001011 + !byte $2F,%00111000 + !byte $1B,%11001101 + !byte $1C,%00001110 + !byte $1B,%11011011 + !byte $18,%00001100 + !byte $2C,%00111000 + !byte $0C,%10111001 + !byte $0B,%01010110 + !byte $1D,%01001110 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $1F,%10111111 + !byte $2C,%11001101 + !byte $33,%11110111 + !byte $32,%00011000 + !byte $15,%10101011 + !byte $2A,%00010000 + !byte $30,%00111000 + !byte $1E,%01111110 + !byte $1E,%10011111; + !byte $1A,%01101100 + !byte $1A,%10001101; + !byte $10,%00110100 + !byte $2C,%10101011 + !byte $1D,%00111110 + !byte $1B,%11111011 + !byte $22,%10111111 + !byte $0F,%01010100 + !byte $2C,%11101101 + !byte $10,%11101011 + !byte $11,%10101011 + !byte $2B,%00111000 + !byte $1C,%11011101 + !byte $11,%00010100 + !byte $0C,%11110101 + !byte $19,%00101100 + !byte $0E,%01110100 + !byte $0E,%10010101; + !byte $13,%01101010 + !byte $13,%10001011; + !byte $2B,%10101111 + !byte $34,%11010111 + !byte $1B,%00011100 + !byte $31,%00111000 + !byte $12,%01101010 + !byte $12,%10001011; + !byte $20,%11011111 + !byte $14,%01101010 + !byte $14,%10001011; + !byte $28,%00011000 + !byte $0B,%00110110 + !byte $12,%11110011 + !byte $2C,%01101010 + !byte $2C,%10001011; + !byte $2C,%00001110 + !byte $2B,%00101010 + !byte $0A,%11110111 + !byte $0A,%11010111 + !byte $1D,%01011110 + !byte $1C,%11111101 + !byte $0D,%10110101 + !byte $21,%11011111 + !byte $17,%11001011 + !byte $0A,%00011000 + !byte $2A,%00111000 + !byte $1B,%00111100 + !byte $16,%10101011 + !byte $33,%00011000 + !byte $0A,%10110111 + !byte $18,%11101011 + !byte $2A,%00110000 + !byte $1B,%10101101 + !byte $1E,%10111111 + !byte $29,%10110001 + !byte $1F,%11011111 + !byte $0B,%01111000 + !byte $0B,%10011001; + !byte $2B,%11001111 + !byte $13,%11010011 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $32,%00111000 + !byte $2F,%01011000 + !byte $2E,%01011000 + !byte $1A,%01001100 + !byte $2C,%00101110 + !byte $0B,%00010110 + !byte $1B,%01011100 + !byte $1C,%11101101 + !byte $2D,%01011000 + !byte $0A,%01110110 + !byte $0A,%10010111; + !byte $34,%11110111 + !byte $0C,%11010101 + !byte $2C,%01001010 + !byte $30,%01011000 + !byte $1C,%00011110 + !byte $1D,%00101110 + !byte $0A,%00111000 + !byte $11,%01101010 + !byte $11,%10001011; + !byte $2C,%01011000 + !byte $0F,%00110100 + !byte $10,%11001011 + !byte $13,%01001010 + !byte $2D,%00001100 + !byte $2D,%00101100 + !byte $0E,%01010100 + !byte $27,%00011000 + !byte $19,%00001100 + !byte $1B,%01111100 + !byte $1B,%10011101; + !byte $1D,%01111110 + !byte $1D,%10011111; + !byte $2D,%11101011 + !byte $2D,%01001100 + !byte $31,%01011000 + !byte $29,%00111000 + !byte $10,%00010100 + !byte $2C,%01001110 + !byte $14,%01001010 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $0A,%01010110 + !byte $14,%10110011 + !byte $12,%01001010 + !byte $2D,%11001011 + !byte $1A,%10111001 + !byte $0D,%01110100 + !byte $0D,%10010101; + !byte $17,%10101011 + !byte $35,%01110110 + !byte $35,%10010111; + !byte $2B,%01011000 + !byte $1A,%11011001 + !byte $16,%01101010 + !byte $16,%10001011; + !byte $2B,%11101111 + !byte $35,%01010110 + !byte $33,%00111000 + !byte $2D,%10101101 + !byte $1C,%00111110 + !byte $1B,%10111101 + !byte $1A,%11111001 + !byte $11,%11110011 + !byte $2A,%01010000 + !byte $1E,%11011111 + !byte $0B,%11110101 + !byte $2D,%10101011 + !byte $35,%10110111 + !byte $1A,%00011010 + !byte $2A,%00001010 + !byte $18,%11001011 + !byte $34,%00011000 + !byte $20,%11111111 + !byte $1A,%00111010 + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $32,%01011000 + !byte $2D,%11001101 + !byte $15,%01001010 + !byte $2C,%01101110 + !byte $2C,%10001111; + !byte $1F,%11111111 + !byte $1A,%01011010 + !byte $0C,%10110101 + !byte $1A,%00101100 + !byte $0A,%00110110 + !byte $1C,%11001101 + !byte $2C,%00101010 + !byte $1A,%01111010 + !byte $1A,%10011011; + !byte $1D,%10111111 + !byte $12,%11010011 + !byte $2F,%01111000 + !byte $2F,%10011001; + !byte $2E,%01111000 + !byte $2E,%10011001; + !byte $1B,%11011101 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $2A,%01011000 + !byte $2D,%11101101 + !byte $28,%00111000 + !byte $1C,%01011110 + !byte $1A,%10111011 + !byte $30,%01111000 + !byte $30,%10011001; + !byte $35,%11010111 + !byte $19,%11101011 + !byte $2D,%01111000 + !byte $2D,%10011001; + !byte $11,%01001010 + !byte $13,%00101010 + !byte $1D,%00001110 + !byte $35,%00110110 + !byte $1A,%11011011 + !byte $31,%01111000 + !byte $31,%10011001; + !byte $0B,%11010101 + !byte $14,%00101010 + !byte $2B,%00010000 + !byte $0A,%01011000 + !byte $0E,%00110100 + !byte $0F,%00010100 + !byte $2B,%00001010 + !byte $1B,%11111101 + !byte $0A,%00010110 + !byte $33,%01011000 + !byte $0D,%01010100 + !byte $16,%01001010 + !byte $2C,%10101111 + !byte $1A,%11111011 + !byte $17,%01101010 + !byte $17,%10001011; + !byte $09,%11010111 + !byte $12,%00101010 + !byte $34,%00111000 + !byte $1E,%11111111 + !byte $13,%10110011 + !byte $2D,%00001110 + !byte $2C,%01111000 + !byte $2C,%10011001; + !byte $09,%10110111 + !byte $2A,%01110000 + !byte $2A,%10010001; + !byte $10,%11110011 + !byte $09,%11110111 + !byte $35,%11110111 + !byte $1A,%00011100 + !byte $1D,%11011111 + !byte $2D,%01001010 + !byte $1C,%01111110 + !byte $1C,%10011111; + !byte $0C,%01110100 + !byte $0C,%10010101; + !byte $18,%10101011 + !byte $09,%01110110 + !byte $09,%10010111; + !byte $32,%01111000 + !byte $32,%10011001; + !byte $1B,%00011110 + !byte $15,%00101010 + !byte $1A,%00001100 + !byte $10,%10101011 + !byte $1B,%01001100 + !byte $1A,%00111100 + !byte $2D,%00101110 + !byte $29,%01011000 + !byte $21,%11111111 + !byte $2B,%01111000 + !byte $2B,%10011001; + !byte $0A,%11110101 + !byte $2E,%00001100 + !byte $11,%11010011 + !byte $2E,%00101100 + !byte $09,%01010110 + !byte $1C,%10101101 + !byte $27,%00111000 + !byte $2E,%11101011 + !byte $1A,%01011100 + !byte $2C,%11001111 + !byte $19,%11001011 + !byte $2E,%01001100 + !byte $09,%00011000 + !byte $2E,%11001011 + !byte $2B,%00110000 + !byte $30,%10111001 + !byte $2F,%10111001 + !byte $5F,%00000000 + !byte $0B,%10110101 + !byte $1B,%00111110 + !byte $13,%00001010 + !byte $35,%00011000 + !byte $2E,%10111001 + !byte $2E,%01101100 + !byte $2E,%10001101; + !byte $1C,%10111111 + !byte $14,%00001010 + !byte $34,%01011000 + !byte $33,%01111000 + !byte $33,%10011001; + !byte $1D,%11111111 + !byte $17,%01001010 + !byte $1D,%11101101 + !byte $31,%10111001 + !byte $1A,%01111100 + !byte $1A,%10011101; + !byte $09,%00110110 + !byte $2E,%10101011 + !byte $0D,%00110100 + !byte $2D,%10111001 + !byte $16,%00101010 + !byte $2D,%01001110 + !byte $11,%00101010 + !byte $2E,%10101101 + !byte $0E,%00010100 + !byte $2D,%00101010 + !byte $60,%00000000 + !byte $5E,%00000000 + !byte $2C,%00001010 + !byte $2A,%01111000 + !byte $2A,%10011001; + !byte $0C,%01010100 + !byte $12,%00001010 + !byte $12,%10110011 + !byte $2A,%10110001 + !byte $18,%01101010 + !byte $18,%10001011; + !byte $1A,%10111101 + !byte $0F,%11110011 + !byte $1B,%01011110 + !byte $15,%00001010 + !byte $0A,%11010101 + !byte $1B,%00101100 + !byte $32,%10111001 + !byte $2E,%11001101 + !byte $1A,%11101011 + !byte $2E,%01101010 + !byte $2E,%10001011; + !byte $28,%01011000 + !byte $2C,%10111001 + !byte $2C,%11101111 + !byte $35,%00111000 + !byte $1C,%11011111 + !byte $09,%00010110 + !byte $0B,%01110100 + !byte $0B,%10010101; + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $1A,%11011101 + !byte $10,%11010011 + !byte $19,%10101011 + !byte $1C,%01101100 + !byte $1C,%10001101; + !byte $2B,%01010000 + !byte $2E,%11101101 + !byte $34,%01111000 + !byte $34,%10011001; + !byte $1B,%01111110 + !byte $1B,%10011111; + !byte $13,%11101001 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $1A,%11111101 + !byte $33,%10111001 + !byte $5D,%00000000 + !byte $14,%11101001 + !byte $17,%00101010 + !byte $30,%11011001 + !byte $2F,%11011001 + !byte $2E,%01001010 + !byte $1D,%11001101 + !byte $29,%01111000 + !byte $29,%10011001; + !byte $16,%00001010 + !byte $09,%00111000 + !byte $2E,%11011001 + !byte $2E,%00001110 + !byte $0A,%10110101 + !byte $31,%11011001 + !byte $2B,%10111001 + !byte $09,%11110101 + !byte $0D,%00010100 + !byte $11,%10110011 + !byte $18,%01001010 + !byte $2D,%10101111 + !byte $08,%10110111 + !byte $1C,%11111111 + !byte $0C,%00110100 + !byte $35,%01011000 + !byte $2C,%00010000 + !byte $1A,%00011110 + !byte $08,%01110110 + !byte $08,%10010111; + !byte $1A,%11001011 + !byte $1B,%00001100 + !byte $0E,%11110011 + !byte $12,%11101001 + !byte $08,%11010111 + !byte $15,%11101001 + !byte $1B,%10111111 + !byte $32,%11011001 + !byte $2D,%11011001 + !byte $2A,%11010001 + !byte $5E,%00100000 + !byte $19,%01011010 + !byte $19,%00111010 + !byte $0B,%01010100 + !byte $5F,%00100000 + !byte $19,%01111010 + !byte $19,%10011011; + !byte $19,%00011010 + !byte $11,%00001010 + !byte $08,%01010110 + !byte $2F,%11101011 + !byte $2F,%00001100 + !byte $2F,%00101100 + !byte $19,%10111011 + !byte $19,%11111001 + !byte $2E,%00101110 + !byte $19,%11011011 + !byte $19,%11011001 + !byte $1C,%01001100 + !byte $2F,%11001011 + !byte $19,%11111011 + !byte $0F,%11010011 + !byte $2F,%01001100 + !byte $2D,%00001010 + !byte $34,%10111001 + !byte $1A,%00111110 + !byte $19,%01101010 + !byte $19,%10001011; + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $2A,%10111001 + !byte $08,%00110110 + !byte $19,%00011100 + !byte $09,%11010101 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $2F,%10101011 + !byte $2C,%11011001 + !byte $2E,%00101010 + !byte $19,%00111100 + !byte $0A,%01110100 + !byte $0A,%10010101; + !byte $33,%11011001 + !byte $12,%01110010 + !byte $12,%10010011; + !byte $5D,%00100000 + !byte $08,%11110111 + !byte $35,%01111000 + !byte $35,%10011001; + !byte $1B,%11011111 + !byte $13,%11001001 + !byte $14,%11001001 + !byte $16,%11101001 + !byte $1D,%10101101 + !byte $2F,%10101101 + !byte $2D,%11001111 + !byte $17,%00001010 + !byte $10,%10110011 + !byte $30,%11111001 + !byte $5C,%00000000 + !byte $19,%01011100 + !byte $18,%00101010 + !byte $2F,%11111001 + !byte $1A,%01011110 + !byte $2E,%01001110 + !byte $28,%01111000 + !byte $28,%10011001; + !byte $08,%00010110 + !byte $2C,%00110000 + !byte $31,%11111001 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $1B,%11101011 + !byte $19,%01111100 + !byte $19,%10011101; + !byte $2F,%11001101 + !byte $0C,%00010100 + !byte $15,%11001001 + !byte $1A,%10101011 + !byte $2E,%11111001 + !byte $2B,%11011001 + !byte $0B,%00110100 + !byte $0D,%11110011 + !byte $09,%10110101 + !byte $32,%11111001 + !byte $19,%10111101 + !byte $19,%01001010 + !byte $1C,%00101100 + !byte $12,%11001001 + !byte $36,%11110111 + !byte $1A,%01111110 + !byte $1A,%10011111; + !byte $34,%11011001 + !byte $1B,%11111111 + !byte $36,%00011000 + !byte $29,%10111001 + !byte $08,%11110101 + !byte $0E,%11010011 + !byte $2D,%11111001 + !byte $19,%11011101 + !byte $2F,%01001010 + !byte $2E,%01101110 + !byte $2E,%10001111; + !byte $2D,%11101111 + !byte $0A,%01010100 + !byte $2F,%11101101 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $13,%01010010 + !byte $35,%10111001 + !byte $2B,%10110001 + !byte $33,%11111001 + !byte $11,%11101001 + !byte $17,%11101001 + !byte $5C,%00100000 + !byte $16,%11001001 + !byte $36,%00111000 + !byte $0F,%10110011 + !byte $19,%11111101 + !byte $5E,%01000000 + !byte $14,%10101001 + !byte $1A,%10111111 + !byte $18,%00001010 + !byte $13,%10101001 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $2F,%00001110 + !byte $1A,%01101010 + !byte $1A,%10001011; + !byte $2C,%01010000 + !byte $5D,%01000000 + !byte $09,%01110100 + !byte $09,%10010101; + !byte $2C,%11111001 + !byte $1B,%11001011 + !byte $08,%11010101 + !byte $2E,%00001010 + !byte $30,%00011010 + !byte $5B,%00000000 + !byte $19,%00011110 + !byte $31,%00011010 + !byte $30,%11101011 + !byte $30,%00001100 + !byte $36,%01011000 + !byte $2F,%00011010 + !byte $2A,%11011001 + !byte $15,%10101001 + !byte $36,%11010111 + !byte $30,%00101100 + !byte $0C,%11110011 + !byte $2E,%10101111 + !byte $1C,%00001100 + !byte $07,%01110110 + !byte $07,%10010111; + !byte $07,%01010110 + !byte $30,%11001011 + !byte $32,%00011010 + !byte $19,%00101010 + !byte $0B,%00010100 + !byte $30,%01001100 + !byte $34,%11111001 + !byte $1A,%11011111 + !byte $19,%00111110 + !byte $0D,%11010011 + !byte $2D,%00010000 + !byte $2E,%00011010 + !byte $12,%01010010 + !byte $2F,%00101010 + !byte $10,%01110010 + !byte $10,%10010011; + !byte $2F,%00101110 + !byte $07,%10110111 + !byte $07,%00110110 + !byte $0A,%00110100 + !byte $30,%10101011 + !byte $35,%11011001 + !byte $30,%01101100 + !byte $30,%10001101; + !byte $12,%10101001 + !byte $28,%10111001 + !byte $17,%11001001 + !byte $1E,%11001101 + !byte $08,%00011000 + !byte $08,%10110101 + !byte $33,%00011010 + !byte $2B,%11111001 + !byte $0E,%10110011 + !byte $30,%10101101 + !byte $36,%01111000 + !byte $36,%10011001; + !byte $5C,%01000000 + !byte $07,%00010110 + !byte $18,%11101001 + !byte $16,%10101001 + !byte $1D,%01001100 + !byte $2D,%00011010 + !byte $19,%01011110 + !byte $09,%01010100 + !byte $2B,%11010001 + !byte $30,%01101010 + !byte $30,%10001011; + !byte $2E,%11001111 + !byte $5F,%01000000 + !byte $5B,%00100000 + !byte $14,%01101000 + !byte $14,%10001001; + !byte $1A,%11111111 + !byte $2F,%01001110 + !byte $1A,%01001010 + !byte $1B,%10101011 + !byte $2C,%01110000 + !byte $2C,%10010001; + !byte $13,%01101000 + !byte $13,%10001001; + !byte $18,%11011011 + !byte $19,%00001010 + !byte $29,%11011001 + !byte $18,%11111011 + !byte $18,%10111011 + !byte $30,%11001101 + !byte $18,%00011100 + !byte $07,%11110101 + !byte $1C,%11101011 + !byte $18,%00111100 + !byte $18,%01111010 + !byte $18,%10011011; + !byte $15,%01101000 + !byte $15,%10001001; + !byte $19,%01111110 + !byte $19,%10011111; + !byte $11,%01010010 + !byte $31,%00111010 + !byte $30,%00111010 + !byte $2D,%00110000 + !byte $18,%01011010 + !byte $07,%11010111 + !byte $0B,%11110011 + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $34,%00011010 + !byte $18,%01011100 + !byte $36,%10111001 + !byte $32,%00111010 + !byte $2F,%00111010 + !byte $18,%00111010 + !byte $35,%11111001 + !byte $0A,%00010100 + !byte $0C,%11010011 + !byte $2C,%00011010 + !byte $30,%01001010 + !byte $18,%01111100 + !byte $18,%10011101; + !byte $08,%01110100 + !byte $08,%10010101; + !byte $11,%11001001 + !byte $30,%11101101 + !byte $18,%00011010 + !byte $17,%10101001 + !byte $1E,%10101101 + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $2A,%11111001 + !byte $5A,%00000000 + !byte $18,%10111101 + !byte $19,%10111111 + !byte $0D,%10110011 + !byte $18,%11111001 + !byte $07,%11010101 + !byte $09,%00110100 + !byte $2E,%00111010 + !byte $18,%11001001 + !byte $2E,%11101111 + !byte $33,%00111010 + !byte $16,%01101000 + !byte $16,%10001001; + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $5B,%01000000 + !byte $18,%11011101 + !byte $1D,%00101100 + !byte $1A,%00101010 + !byte $18,%11111101 + !byte $5C,%01100000 + !byte $5C,%10000001; + !byte $12,%01101000 + !byte $12,%10001001; + !byte $2F,%00001010 + !byte $30,%00001110 + !byte $5E,%01100000 + !byte $5E,%10000001; + !byte $14,%01001000 + !byte $1C,%11001011 + !byte $31,%00001100 + !byte $19,%11011111 + !byte $31,%11101011 + !byte $10,%01010010 + !byte $0E,%01110010 + !byte $0E,%10010011; + !byte $36,%11011001 + !byte $19,%11101001 + !byte $31,%11001011 + !byte $31,%00101100 + !byte $2D,%00111010 + !byte $08,%01010100 + !byte $2C,%10110001 + !byte $2D,%01010000 + !byte $2B,%00011010 + !byte $07,%10110101 + !byte $15,%01001000 + !byte $18,%00011110 + !byte $13,%01001000 + !byte $35,%00011010 + !byte $34,%00111010 + !byte $5A,%00100000 + !byte $12,%00110010 + !byte $31,%01001100 + !byte $28,%11011001 + !byte $2F,%10101111 + !byte $31,%10101011 + !byte $31,%01011010 + !byte $30,%01011010 + !byte $0A,%11110011 + !byte $0B,%11010011 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $30,%00101010 + !byte $32,%01011010 + !byte $30,%00101110 + !byte $09,%00010100 + !byte $18,%00111110 + !byte $0C,%10110011 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $1E,%01101100 + !byte $1E,%10001101; + !byte $2F,%01011010 + !byte $19,%11111111 + !byte $1D,%00001100 + !byte $06,%00110110 + !byte $18,%10101001 + !byte $1B,%01001010 + !byte $2E,%00010000 + !byte $29,%11111001 + !byte $1A,%00001010 + !byte $06,%01010110 + !byte $31,%10101101 + !byte $2C,%00111010 + !byte $06,%00010110 + !byte $0F,%01010010 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $18,%01011110 + !byte $16,%01001000 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $33,%01011010 + !byte $07,%01110100 + !byte $07,%10010101; + !byte $19,%11001001 + !byte $2E,%01011010 + !byte $36,%11111001 + !byte $1C,%10101011 + !byte $5A,%01000000 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $11,%00110010 + !byte $08,%00110100 + !byte $30,%01001110 + !byte $31,%11001101 + !byte $2F,%11001111 + !byte $18,%01111110 + !byte $18,%10011111; + !byte $06,%01110110 + !byte $06,%10010111; + !byte $06,%11110101 + !byte $2A,%00011010 + !byte $59,%00000000 + !byte $14,%00101000 + !byte $35,%00111010 + !byte $15,%00101000 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $34,%01011010 + !byte $2C,%11010001 + !byte $06,%11010101 + !byte $1D,%11101011 + !byte $31,%01001010 + !byte $31,%11101101 + !byte $1E,%01001100 + !byte $18,%10111111 + !byte $0A,%11010011 + !byte $07,%01010100 + !byte $17,%01001000 + !byte $31,%01111010 + !byte $31,%10011011; + !byte $5C,%10100001 + !byte $12,%01001000 + !byte $2D,%01011010 + !byte $09,%11110011 + !byte $0B,%10110011 + !byte $13,%00101000 + !byte $32,%01111010 + !byte $32,%10011011; + !byte $30,%01111010 + !byte $30,%10011011; + !byte $0E,%01010010 + !byte $1A,%11101001 + !byte $1B,%00101010 + !byte $2E,%00110000 + !byte $2B,%00111010 + !byte $18,%01101000 + !byte $18,%10001001; + !byte $30,%01101110 + !byte $30,%10001111; + !byte $10,%00110010 + !byte $36,%00011010 + !byte $59,%00100000 + !byte $17,%00111100 + !byte $16,%00101000 + !byte $17,%00011100 + !byte $5D,%10100001 + !byte $17,%01011100 + !byte $08,%00010100 + !byte $2F,%01111010 + !byte $2F,%10011011; + !byte $17,%11111011 + !byte $0C,%01110010 + !byte $0C,%10010011; + !byte $17,%01111100 + !byte $17,%10011101; + !byte $33,%01111010 + !byte $33,%10011011; + !byte $1C,%01101010 + !byte $1C,%10001011; + !byte $5A,%01100000 + !byte $5A,%10000001; + !byte $2F,%11101111 + !byte $18,%11011111 + !byte $06,%10110101 + !byte $31,%00001110 + !byte $17,%10111101 + !byte $17,%11011011 + !byte $19,%10101001 + !byte $32,%11101011 + !byte $32,%00001100 + !byte $5B,%10100001 + !byte $28,%11111001 + !byte $32,%00101100 + !byte $17,%11011101 + !byte $17,%10111011 + !byte $32,%11001011 + !byte $2C,%01011010 + !byte $35,%01011010 + !byte $2E,%01111010 + !byte $2E,%10011011; + !byte $29,%00011010 + !byte $32,%01001100 + !byte $17,%11111101 + !byte $12,%00010010 + !byte $17,%01111010 + !byte $17,%10011011; + !byte $30,%00001010 + !byte $07,%00110100 + !byte $1D,%11001011 + !byte $18,%11111111 + !byte $0F,%00110010 + !byte $14,%00001000 + !byte $1E,%00101100 + !byte $17,%01011010 + !byte $0D,%01010010 + !byte $30,%10101111 + !byte $34,%01111010 + !byte $34,%10011011; + !byte $17,%00011110 + !byte $06,%10110111 + !byte $15,%00001000 + !byte $1A,%11001001 + !byte $32,%10101011 + !byte $32,%01101100 + !byte $32,%10001101; + !byte $1B,%00001010 + !byte $31,%00101010 + !byte $31,%00101110 + !byte $06,%01110100 + !byte $06,%10010101; + !byte $59,%01000000 + !byte $09,%11010011 + !byte $17,%00101000 + !byte $2D,%10110001 + !byte $18,%01001000 + !byte $2E,%01010000 + !byte $17,%00111110 + !byte $0A,%10110011 + !byte $17,%00111010 + !byte $36,%00111010 + !byte $31,%10111011 + !byte $32,%10101101 + !byte $08,%11110011 + !byte $2A,%00111010 + !byte $2F,%00010000 + !byte $32,%10111011 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $1C,%01001010 + !byte $2C,%11110001 + !byte $30,%10111011 + !byte $16,%00001000 + !byte $11,%00010010 + !byte $2D,%01111010 + !byte $2D,%10011011; + !byte $32,%01101010 + !byte $32,%10001011; + !byte $58,%00000000 + !byte $17,%00011010 + !byte $17,%01011110 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $33,%10111011 + !byte $5A,%10100001 + !byte $0E,%00110010 + !byte $13,%00001000 + !byte $2F,%10111011 + !byte $2B,%01011010 + !byte $32,%11001101 + !byte $07,%00010100 + !byte $31,%01001110 + !byte $35,%01111010 + !byte $35,%10011011; + !byte $06,%01010100 + !byte $17,%01111110 + !byte $17,%10011111; + !byte $17,%11111001 + !byte $30,%11001111 + !byte $59,%01100000 + !byte $59,%10000001; + !byte $0C,%01010010 + !byte $05,%00010110 + !byte $05,%11110101 + !byte $1D,%10101011 + !byte $1E,%00001100 + !byte $1B,%11101001 + !byte $58,%00100000 + !byte $1A,%10101001 + !byte $10,%00010010 + !byte $05,%00110110 + !byte $34,%10111011 + !byte $17,%10111111 + !byte $05,%11010101 + !byte $12,%00101000 + !byte $18,%00101000 + !byte $32,%11101101 + !byte $2E,%10111011 + !byte $32,%01001010 + !byte $2C,%01111010 + !byte $2C,%10011011; + !byte $15,%11100111 + !byte $17,%00001000 + !byte $1C,%00101010 + !byte $36,%01011010 + !byte $09,%10110011 + !byte $2E,%01110000 + !byte $2E,%10010001; + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $5B,%11000001 + !byte $28,%00011010 + !byte $14,%11100111 + !byte $19,%01001000 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $08,%11010011 + !byte $0D,%00110010 + !byte $2D,%11010001 + !byte $06,%00110100 + !byte $5C,%11000001 + !byte $17,%11011111 + !byte $05,%10110101 + !byte $0A,%01110010 + !byte $0A,%10010011; + !byte $2F,%00110000 + !byte $32,%11011011 + !byte $31,%11011011 + !byte $29,%00111010 + !byte $16,%11100111 + !byte $30,%11101111 + !byte $32,%00001110 + !byte $33,%00001100 + !byte $30,%11011011 + !byte $58,%01000000 + !byte $0F,%00010010 + !byte $07,%11110011 + !byte $0B,%01010010 + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $33,%11101011 + !byte $33,%00101100 + !byte $33,%11011011 + !byte $1E,%11101011 + !byte $35,%10111011 + !byte $59,%10100001 + !byte $33,%11001011 + !byte $2D,%10111011 + !byte $1B,%11001001 + !byte $33,%01001100 + !byte $2A,%01011010 + !byte $17,%11111111 + !byte $05,%01110100 + !byte $05,%10010101; + !byte $5A,%11000001 + !byte $05,%01010110 + !byte $1C,%00001010 + !byte $2F,%11011011 + !byte $1A,%01101000 + !byte $1A,%10001001; + !byte $33,%01101100 + !byte $33,%10001101; + !byte $37,%11011001 + !byte $0C,%00110010 + !byte $16,%01111100 + !byte $16,%10011101; + !byte $16,%01011100 + !byte $32,%00101110 + !byte $37,%11111001 + !byte $16,%10111101 + !byte $18,%00001000 + !byte $31,%10101111 + !byte $34,%11011011 + !byte $16,%11011101 + !byte $16,%00111100 + !byte $2B,%01111010 + !byte $2B,%10011011; + !byte $36,%01111010 + !byte $36,%10011011; + !byte $1F,%01001100 + !byte $33,%10101011 + !byte $06,%00010100 + !byte $16,%00011100 + !byte $16,%11111101 + !byte $0E,%00010010 + !byte $17,%11100111 + !byte $13,%11100111 + !byte $57,%00000000 + !byte $11,%11110001 + !byte $16,%00011110 + !byte $16,%11111011 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $05,%01010100 + !byte $58,%01100000 + !byte $58,%10000001; + !byte $08,%10110011 + !byte $19,%00101000 + !byte $33,%10101101 + !byte $31,%00001010 + !byte $15,%11000111 + !byte $07,%11010011 + !byte $2E,%11011011 + !byte $16,%00111110 + !byte $32,%00101010 + !byte $2F,%01010000 + !byte $16,%11011011 + !byte $0A,%01010010 + !byte $1D,%01001010 + !byte $30,%00010000 + !byte $1E,%11001011 + !byte $37,%00011010 + !byte $2E,%10110001 + !byte $32,%11111011 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $2C,%10111011 + !byte $14,%11000111 + !byte $16,%11000111 + !byte $31,%11111011 + !byte $16,%01011110 + !byte $1B,%10101001 + !byte $33,%11001101 + !byte $16,%10111011 + !byte $32,%01001110 + !byte $10,%11110001 + !byte $1C,%11101001 + !byte $2D,%11110001 + !byte $33,%11111011 + !byte $35,%11011011 + !byte $30,%11111011 + !byte $57,%00100000 + !byte $16,%01111110 + !byte $16,%10011111; + !byte $0D,%00010010 + !byte $1A,%01001000 + !byte $31,%11001111 + !byte $59,%11000001 + !byte $27,%00011010 + !byte $28,%00111010 + !byte $16,%01111010 + !byte $16,%10011011; + !byte $0B,%00110010 + !byte $1F,%00101100 + !byte $05,%00110100 + !byte $36,%10111011 + !byte $2D,%11011011 + !byte $06,%11110011 + !byte $37,%00111010 + !byte $29,%01011010 + !byte $16,%10111111 + !byte $2F,%11111011 + !byte $58,%10100001 + !byte $18,%11100111 + !byte $33,%11101101 + !byte $16,%01011010 + !byte $34,%11111011 + !byte $17,%11000111 + !byte $32,%01101110 + !byte $32,%10001111; + !byte $0F,%11110001 + !byte $19,%00001000 + !byte $57,%01000000 + !byte $1D,%00101010 + !byte $33,%01001010 + !byte $2A,%01111010 + !byte $2A,%10011011; + !byte $08,%01110010 + !byte $08,%10010011; + !byte $16,%11011111 + !byte $09,%01010010 + !byte $30,%00110000 + !byte $1E,%10101011 + !byte $07,%10110011 + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $33,%00001110 + !byte $16,%00111010 + !byte $2B,%10111011 + !byte $5A,%11100001 + !byte $04,%11010101 + !byte $0C,%00010010 + !byte $1A,%00101000 + !byte $04,%10110101 + !byte $34,%00001100 + !byte $34,%00101100 + !byte $15,%10100111 + !byte $1C,%11001001 + !byte $2E,%11111011 + !byte $05,%00010100 + !byte $34,%11101011 + !byte $32,%00011100 + !byte $16,%11111111 + !byte $0A,%00110010 + !byte $31,%11101111 + !byte $04,%11110101 + !byte $06,%11010011 + !byte $2E,%11010001 + !byte $34,%01001100 + !byte $31,%00011100 + !byte $5B,%11100001 + !byte $16,%10100111 + !byte $1F,%00001100 + !byte $0E,%11110001 + !byte $37,%01011010 + !byte $34,%11001011 + !byte $35,%11111011 + !byte $33,%00011100 + !byte $57,%01100000 + !byte $57,%10000001; + !byte $16,%00011010 + !byte $34,%01101100 + !byte $34,%10001101; + !byte $04,%01110100 + !byte $04,%10010101; + !byte $2C,%11011011 + !byte $36,%11011011 + !byte $30,%00011100 + !byte $13,%11000111 + !byte $1D,%00001010 + !byte $58,%11000001 + !byte $14,%10100111 + !byte $18,%11000111 + !byte $33,%00101110 + !byte $2D,%00010010 + !byte $1E,%01101010 + !byte $1E,%10001011; + !byte $32,%10101111 + !byte $56,%00000000 + !byte $19,%11100111 + !byte $59,%11100001 + !byte $0B,%00010010 + !byte $11,%11010001 + !byte $34,%10101011 + !byte $17,%10100111 + !byte $34,%00011100 + !byte $1B,%01001000 + !byte $04,%01010100 + !byte $0D,%11110001 + !byte $34,%10101101 + !byte $2D,%11111011 + !byte $04,%00010110 + !byte $05,%11110011 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $08,%01010010 + !byte $2F,%00011100 + !byte $1F,%11101011 + !byte $27,%00111010 + !byte $31,%00010000 + !byte $15,%11011101 + !byte $1C,%10101001 + !byte $30,%01010000 + !byte $56,%00100000 + !byte $12,%00001000 + !byte $15,%10111101 + !byte $15,%01111100 + !byte $15,%10011101; + !byte $09,%00110010 + !byte $10,%11010001 + !byte $15,%11111101 + !byte $1A,%00001000 + !byte $15,%00011110 + !byte $2F,%10110001 + !byte $28,%01011010 + !byte $34,%11001101 + !byte $29,%01111010 + !byte $29,%10011011; + !byte $57,%10100001 + !byte $37,%01111010 + !byte $37,%10011011; + !byte $15,%01011100 + !byte $2A,%10111011 + !byte $33,%01001110 + !byte $06,%10110011 + !byte $15,%00111110 + !byte $15,%00111100 + !byte $15,%01011110 + !byte $04,%00110100 + !byte $32,%11001111 + !byte $1D,%11101001 + !byte $32,%00111100 + !byte $1E,%01001010 + !byte $34,%01101010 + !byte $34,%10001011; + !byte $0C,%11110001 + !byte $0F,%11010001 + !byte $16,%01100110 + !byte $16,%10000111; + !byte $35,%00011100 + !byte $31,%00111100 + !byte $15,%00011100 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $33,%00111100 + !byte $2E,%00011100 + !byte $2B,%11011011 + !byte $15,%01111110 + !byte $15,%10011111; + !byte $0A,%00010010 + !byte $33,%00101010 + !byte $2E,%11110001 + !byte $18,%10100111 + !byte $56,%01000000 + !byte $34,%11101101 + !byte $05,%11010011 + !byte $36,%11111011 + !byte $19,%11000111 + !byte $1B,%00101000 + !byte $15,%10111111 + !byte $15,%11111011 + !byte $30,%00111100 + !byte $1F,%11001011 + !byte $2C,%11111011 + !byte $58,%11100001 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $33,%01101110 + !byte $33,%10001111; + !byte $1C,%01101000 + !byte $1C,%10001001; + !byte $04,%00010100 + !byte $34,%00111100 + !byte $07,%01010010 + !byte $0E,%11010001 + !byte $15,%11011111 + !byte $15,%11011011 + !byte $31,%00110000 + !byte $37,%10111011 + !byte $1A,%11100111 + !byte $34,%00001110 + !byte $57,%11000001 + !byte $1D,%11001001 + !byte $2F,%00111100 + !byte $08,%00110010 + !byte $1E,%00101010 + !byte $32,%11101111 + !byte $0B,%11110001 + !byte $06,%01110010 + !byte $06,%10010011; + !byte $15,%10111011 + !byte $56,%01100000 + !byte $56,%10000001; + !byte $30,%01110000 + !byte $30,%10010001; + !byte $2D,%00011100 + !byte $35,%00101100 + !byte $35,%00001100 + !byte $15,%11111111 + !byte $09,%00010010 + !byte $35,%11101011 + !byte $35,%01001100 + !byte $14,%01100110 + !byte $14,%10000111; + !byte $0D,%11010001 + !byte $34,%01001010 + !byte $1F,%10101011 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $33,%10101111 + !byte $35,%00111100 + !byte $04,%11110011 + !byte $05,%10110011 + !byte $2F,%11010001 + !byte $35,%11001011 + !byte $55,%00000000 + !byte $19,%10100111 + !byte $1C,%01001000 + !byte $34,%00101110 + !byte $32,%01011100 + !byte $18,%01100110 + !byte $18,%10000111; + !byte $20,%00101100 + !byte $29,%10111011 + !byte $15,%01111010 + !byte $15,%10011011; + !byte $1B,%00001000 + !byte $36,%00011100 + !byte $33,%01011100 + !byte $31,%01011100 + !byte $11,%10110001 + !byte $2A,%11011011 + !byte $28,%01111010 + !byte $28,%10011011; + !byte $16,%01000110 + !byte $2E,%00111100 + !byte $59,%00000010 + !byte $35,%10101101 + !byte $27,%01011010 + !byte $56,%10100001 + !byte $0A,%11110001 + !byte $1E,%00001010 + !byte $2B,%11111011 + !byte $10,%10110001 + !byte $15,%01000110 + !byte $1D,%10101001 + !byte $30,%01011100 + !byte $15,%01011010 + !byte $0C,%11010001 + !byte $1A,%11000111 + !byte $37,%11011011 + !byte $34,%01011100 + !byte $57,%11100001 + !byte $17,%01000110 + !byte $07,%00110010 + !byte $35,%10101011 + !byte $35,%11001101 + !byte $2E,%00010010 + !byte $55,%00100000 + !byte $32,%00010000 + !byte $31,%01010000 + !byte $03,%01110100 + !byte $03,%10010101; + !byte $06,%01010010 + !byte $34,%01001110 + !byte $2C,%00011100 + !byte $08,%00010010 + !byte $03,%01010100 + !byte $0F,%10110001 + !byte $5A,%00000010 + !byte $04,%11010011 + !byte $03,%10110101 + !byte $20,%00001100 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $58,%00000010 + !byte $15,%00111010 + !byte $33,%11001111 + !byte $1C,%00101000 + !byte $30,%10110001 + !byte $2F,%01011100 + !byte $13,%10100111 + !byte $55,%01000000 + !byte $2D,%00111100 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $14,%11111101 + !byte $03,%00110100 + !byte $0B,%11010001 + !byte $1B,%11100111 + !byte $35,%11101101 + !byte $14,%00111110 + !byte $14,%11011101 + !byte $09,%11110001 + !byte $14,%00011110 + !byte $0E,%10110001 + !byte $35,%01011100 + !byte $56,%11000001 + !byte $14,%01011110 + !byte $14,%10111101 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $1E,%11101001 + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $36,%00111100 + !byte $14,%01111110 + !byte $14,%10011111; + !byte $18,%01000110 + !byte $14,%01111100 + !byte $14,%10011101; + !byte $35,%01101010 + !byte $35,%10001011; + !byte $2F,%11110001 + !byte $33,%01111100 + !byte $33,%10011101; + !byte $32,%01111100 + !byte $32,%10011101; + !byte $15,%00011010 + !byte $34,%01101110 + !byte $34,%10001111; + !byte $31,%01111100 + !byte $31,%10011101; + !byte $1A,%10100111 + !byte $14,%01011100 + !byte $14,%10111111 + !byte $0D,%10110001 + !byte $03,%00010100 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $03,%11010101 + !byte $1F,%01001010 + !byte $20,%11101011 + !byte $2E,%01011100 + !byte $14,%00111100 + !byte $04,%10110011 + !byte $35,%00001110 + !byte $37,%11111011 + !byte $07,%00010010 + !byte $16,%00100110 + !byte $34,%01111100 + !byte $34,%10011101; + !byte $29,%11011011 + !byte $14,%11011111 + !byte $32,%00110000 + !byte $2A,%11111011 + !byte $06,%00110010 + !byte $0A,%11010001 + !byte $30,%01111100 + !byte $30,%10011101; + !byte $1C,%00001000 + !byte $2B,%00011100 + !byte $28,%10111011 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $17,%00100110 + !byte $14,%00011100 + !byte $33,%11101111 + !byte $36,%00101100 + !byte $36,%00001100 + !byte $14,%11111111 + !byte $05,%01010010 + !byte $1B,%11000111 + !byte $1E,%11001001 + !byte $57,%00000010 + !byte $27,%01111010 + !byte $27,%10011011; + !byte $0C,%10110001 + !byte $36,%01001100 + !byte $03,%11110011 + !byte $08,%11110001 + !byte $14,%01000110 + !byte $1D,%01001000 + !byte $2E,%00110010 + !byte $56,%11100001 + !byte $36,%11101011 + !byte $35,%00101110 + !byte $2C,%00111100 + !byte $14,%11111011 + !byte $36,%01101100 + !byte $36,%10001101; + !byte $15,%00100110 + !byte $34,%10101111 + !byte $19,%01000110 + !byte $55,%10100001 + !byte $30,%11010001 + !byte $54,%00000000 + !byte $2F,%01111100 + !byte $2F,%10011101; + !byte $1F,%00101010 + !byte $18,%00100110 + !byte $35,%01111100 + !byte $35,%10011101; + !byte $2D,%01011100 + !byte $1A,%01100110 + !byte $1A,%10000111; + !byte $04,%01110010 + !byte $04,%10010011; + !byte $36,%01011100 + !byte $09,%11010001 + !byte $10,%01110000 + !byte $10,%10010001; + !byte $36,%11001011 + !byte $20,%11001011 + !byte $36,%10101101 + !byte $14,%11011011 + !byte $32,%10111101 + !byte $54,%00100000 + !byte $0B,%10110001 + !byte $37,%00011100 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $33,%10111101 + !byte $03,%11010011 + !byte $1C,%11100111 + !byte $31,%10111101 + !byte $1E,%10101001 + !byte $32,%01010000 + !byte $2F,%00010010 + !byte $06,%00010010 + !byte $36,%11001101 + !byte $35,%01001110 + !byte $33,%00010000 + !byte $05,%00110010 + !byte $55,%11000001 + !byte $14,%10111011 + !byte $07,%11110001 + !byte $1B,%10100111 + !byte $34,%10111101 + !byte $0E,%01110000 + !byte $0E,%10010001; + !byte $1D,%00101000 + !byte $34,%11001111 + !byte $1F,%00001010 + !byte $2E,%01111100 + !byte $2E,%10011101; + !byte $35,%01001010 + !byte $30,%10111101 + !byte $31,%10110001 + !byte $20,%10101011 + !byte $54,%01000000 + !byte $17,%00000110 + !byte $34,%00101010 + !byte $36,%10101011 + !byte $16,%00000110 + !byte $08,%11010001 + !byte $36,%11101101 + !byte $0A,%10110001 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $19,%00100110 + !byte $2A,%00011100 + !byte $14,%01111010 + !byte $14,%10011011; + !byte $04,%01010010 + !byte $56,%00000010 + !byte $1A,%01000110 + !byte $2B,%00111100 + !byte $29,%11111011 + !byte $03,%10110011 + !byte $35,%01101110 + !byte $35,%10001111; + !byte $58,%00100010 + !byte $54,%01100000 + !byte $54,%10000001; + !byte $1E,%01101000 + !byte $1E,%10001001; + !byte $2F,%10111101 + !byte $18,%00000110 + !byte $36,%00001110 + !byte $2C,%01011100 + !byte $13,%01011110 + !byte $13,%00111110 + !byte $1C,%11000111 + !byte $35,%10111101 + !byte $13,%00011110 + !byte $30,%11110001 + !byte $28,%11011011 + !byte $0C,%01110000 + !byte $0C,%10010001; + !byte $13,%01111110 + !byte $13,%10011111; + !byte $36,%01111100 + !byte $36,%10011101; + !byte $13,%11111101 + !byte $32,%11011101 + !byte $55,%11100001 + !byte $13,%11011101 + !byte $1F,%11101001 + !byte $13,%10111111 + !byte $2D,%01111100 + !byte $2D,%10011101; + !byte $14,%01011010 + !byte $20,%01101010 + !byte $20,%10001011; + !byte $33,%00110000 + !byte $27,%10111011 + !byte $1D,%00001000 + !byte $34,%11101111 + !byte $33,%11011101 + !byte $57,%00100010 + !byte $13,%10111101 + !byte $06,%11110001 + !byte $09,%10110001 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $32,%01110000 + !byte $32,%10010001; + !byte $37,%00111100 + !byte $31,%11011101 + !byte $13,%11011111 + !byte $03,%01110010 + !byte $03,%10010011; + !byte $05,%00010010 + !byte $54,%10100001 + !byte $13,%01111100 + !byte $13,%10011101; + !byte $02,%00110100 + !byte $07,%11010001 + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $35,%10101111 + !byte $34,%11011101 + !byte $37,%00101100 + !byte $13,%11111111 + !byte $02,%00010100 + !byte $37,%00001100 + !byte $37,%01001100 + !byte $2E,%10111101 + !byte $15,%00000110 + !byte $04,%00110010 + !byte $1E,%01001000 + !byte $36,%00101110 + !byte $30,%11011101 + !byte $13,%01011100 + !byte $31,%11010001 + !byte $2F,%00110010 + !byte $02,%01010100 + !byte $36,%01101010 + !byte $36,%10001011; + !byte $37,%01101100 + !byte $37,%10001101; + !byte $1A,%00100110 + !byte $20,%01001010 + !byte $53,%00000000 + !byte $14,%00111010 + !byte $02,%11110011 + !byte $10,%01010000 + !byte $1F,%11001001 + !byte $19,%00000110 + !byte $1C,%10100111 + !byte $0F,%01010000 + !byte $13,%00111100 + !byte $08,%10110001 + !byte $0A,%01110000 + !byte $0A,%10010001; + !byte $17,%11100101 + !byte $37,%11101011 + !byte $37,%10101101 + !byte $2A,%00111100 + !byte $1D,%11100111 + !byte $0E,%01010000 + !byte $54,%11000001 + !byte $53,%00100000 + !byte $1B,%01000110 + !byte $34,%00010000 + !byte $33,%01010000 + !byte $2B,%01011100 + !byte $29,%00011100 + !byte $56,%00100010 + !byte $36,%10111101 + !byte $13,%00011100 + !byte $36,%01001110 + !byte $35,%11011101 + !byte $02,%11010011 + !byte $55,%00000010 + !byte $16,%11100101 + !byte $18,%11100101 + !byte $35,%11001111 + !byte $2F,%11011101 + !byte $37,%11001101 + !byte $2C,%01111100 + !byte $2C,%10011101; + !byte $03,%01010010 + !byte $05,%11110001 + !byte $21,%11101011 + !byte $0D,%01010000 + !byte $32,%10110001 + !byte $37,%01011100 + !byte $14,%00011010 + !byte $33,%11111101 + !byte $53,%01000000 + !byte $06,%11010001 + !byte $32,%11111101 + !byte $28,%11111011 + !byte $1E,%00101000 + !byte $30,%00010010 + !byte $20,%00101010 + !byte $2D,%10111101 + !byte $13,%11111011 + !byte $37,%11001011 + !byte $31,%11111101 + !byte $04,%00010010 + !byte $09,%01110000 + !byte $09,%10010001; + !byte $1F,%10101001 + !byte $0C,%01010000 + !byte $37,%11101101 + !byte $07,%10110001 + !byte $34,%11111101 + !byte $1C,%01100110 + !byte $1C,%10000111; + !byte $02,%10110011 + !byte $1A,%00000110 + !byte $36,%01101110 + !byte $36,%10001111; + !byte $27,%11011011 + !byte $19,%11100101 + !byte $1D,%11000111 + !byte $02,%01110100 + !byte $02,%10010101; + !byte $53,%01100000 + !byte $53,%10000001; + !byte $54,%11100001 + !byte $30,%11111101 + !byte $31,%11110001 + !byte $2E,%11011101 + !byte $03,%00110010 + !byte $0B,%01010000 + !byte $21,%11001011 + !byte $13,%11011011 + !byte $1B,%00100110 + !byte $37,%00001110 + !byte $35,%11101111 + !byte $34,%00110000 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $20,%00001010 + !byte $1E,%00001000 + !byte $08,%01110000 + !byte $08,%10010001; + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $02,%01110010 + !byte $02,%10010011; + !byte $37,%10101011 + !byte $2F,%01010010 + !byte $35,%11111101 + !byte $12,%01011110 + !byte $12,%00111110 + !byte $36,%11011101 + !byte $53,%10100001 + !byte $12,%01111110 + !byte $12,%10011111; + !byte $05,%11010001 + !byte $17,%11000101 + !byte $12,%10111111 + !byte $12,%00011110 + !byte $13,%10111011 + !byte $0A,%01010000 + !byte $36,%10101111 + !byte $2B,%01111100 + !byte $2B,%10011101; + !byte $55,%00100010 + !byte $2F,%11111101 + !byte $18,%11000101 + !byte $2C,%10111101 + !byte $2A,%01011100 + !byte $04,%11110001 + !byte $12,%11111101 + !byte $29,%00111100 + !byte $37,%01111100 + !byte $37,%10011101; + !byte $1C,%01000110 + !byte $06,%10110001 + !byte $37,%00101110 + !byte $33,%00011110 + !byte $32,%00011110 + !byte $12,%11011111 + !byte $21,%10101011 + !byte $1D,%10100111 + !byte $12,%11011101 + !byte $32,%11010001 + !byte $0F,%00110000 + !byte $1A,%11100101 + !byte $12,%11111111 + !byte $10,%00110000 + !byte $20,%11101001 + !byte $31,%00011110 + !byte $2D,%11011101 + !byte $54,%00000010 + !byte $0E,%00110000 + !byte $38,%00101100 + !byte $38,%01001100 + !byte $38,%01101100 + !byte $38,%10001101; + !byte $34,%00011110 + !byte $28,%00011100 + !byte $52,%00000000 + !byte $12,%10111101 + !byte $03,%00010010 + !byte $13,%01111010 + !byte $13,%10011011; + !byte $09,%01010000 + !byte $1B,%00000110 + !byte $53,%11000001 + !byte $07,%01110000 + !byte $07,%10010001; + !byte $1F,%01001000 + !byte $1E,%11100111 + !byte $30,%00110010 + !byte $34,%01010000 + !byte $37,%01001110 + !byte $0D,%00110000 + !byte $19,%11000101 + !byte $38,%10101101 + !byte $35,%00010000 + !byte $02,%01010010 + !byte $38,%00001100 + !byte $12,%01111100 + !byte $12,%10011101; + !byte $30,%00011110 + !byte $0C,%00110000 + !byte $16,%11000101 + !byte $36,%11001111 + !byte $2E,%11111101 + !byte $52,%00100000 + !byte $21,%01101010 + !byte $21,%10001011; + !byte $38,%11001101 + !byte $27,%11111011 + !byte $33,%10110001 + !byte $13,%01011010 + !byte $20,%11001001 + !byte $31,%00010010 + !byte $12,%01011100 + !byte $1C,%00100110 + !byte $05,%10110001 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $0B,%00110000 + !byte $04,%11010001 + !byte $38,%11101011 + !byte $52,%01000000 + !byte $08,%01010000 + !byte $35,%00011110 + !byte $15,%11100101 + !byte $37,%10111101 + !byte $36,%11111101 + !byte $1F,%00101000 + !byte $2F,%00011110 + !byte $53,%11100001 + !byte $12,%00111100 + !byte $37,%01101110 + !byte $37,%10001111; + !byte $2B,%10111101 + !byte $56,%01000010 + !byte $06,%01110000 + !byte $06,%10010001; + !byte $1E,%11000111 + !byte $38,%11101101 + !byte $02,%00110010 + !byte $21,%01001010 + !byte $33,%00111110 + !byte $32,%00111110 + !byte $03,%11110001 + !byte $2A,%01111100 + !byte $2A,%10011101; + !byte $52,%01100000 + !byte $52,%10000001; + !byte $1A,%11000101 + !byte $1B,%11100101 + !byte $2C,%11011101 + !byte $0A,%00110000 + !byte $54,%00100010 + !byte $18,%10100101 + !byte $31,%00111110 + !byte $20,%10101001 + !byte $36,%11101111 + !byte $13,%00111010 + !byte $32,%11110001 + !byte $29,%01011100 + !byte $35,%00110000 + !byte $34,%01110000 + !byte $34,%10010001; + !byte $34,%00111110 + !byte $12,%00011100 + !byte $38,%00001110 + !byte $07,%01010000 + !byte $17,%10100101 + !byte $2D,%11111101 + !byte $01,%11010011 + !byte $1C,%00000110 + !byte $38,%11001011 + !byte $1D,%01000110 + !byte $21,%00101010 + !byte $52,%10100001 + !byte $19,%10100101 + !byte $1F,%00001000 + !byte $01,%11110011 + !byte $09,%00110000 + !byte $30,%00111110 + !byte $28,%00111100 + !byte $37,%10101111 + !byte $55,%01000010 + !byte $01,%10110011 + !byte $12,%11111011 + !byte $57,%01000010 + !byte $2E,%00011110 + !byte $02,%00010010 + !byte $30,%01010010 + !byte $1E,%10100111 + !byte $53,%00000010 + !byte $33,%11010001 + !byte $0E,%00010000 + !byte $0F,%00010000 + !byte $04,%10110001 + !byte $20,%01101000 + !byte $20,%10001001; + !byte $38,%00101110 + !byte $0D,%00010000 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $10,%00010000 + !byte $13,%00011010 + !byte $05,%01110000 + !byte $05,%10010001; + !byte $0C,%00010000 + !byte $11,%01111110 + !byte $11,%10011111; + !byte $11,%01011110 + !byte $11,%00111110 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $11,%10111111 + !byte $35,%00111110 + !byte $27,%00011100 + !byte $03,%11010001 + !byte $36,%00011110 + !byte $08,%00110000 + !byte $35,%01010000 + !byte $11,%11011111 + !byte $06,%01010000 + !byte $01,%00010100 + !byte $11,%11111111 + !byte $12,%11011011 + !byte $1B,%11000101 + !byte $1F,%11100111 + !byte $36,%00010000 + !byte $31,%00110010 + !byte $32,%01011110 + !byte $2F,%00111110 + !byte $52,%11000001 + !byte $11,%00011110 + !byte $21,%00001010 + !byte $33,%01011110 + !byte $0B,%00010000 + !byte $1A,%10100101 + !byte $38,%01001110 + !byte $11,%11111101 + !byte $1D,%00100110 + !byte $39,%01001100 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $37,%11001111 + !byte $51,%00000000 + !byte $37,%11011101 + !byte $39,%10101101 + !byte $32,%00010010 + !byte $31,%01011110 + !byte $2A,%10111101 + !byte $01,%01010010 + !byte $2B,%11011101 + !byte $1E,%01100110 + !byte $1E,%10000111; + !byte $2C,%11111101 + !byte $1C,%11100101 + !byte $20,%01001000 + !byte $39,%00101100 + !byte $51,%00100000 + !byte $11,%11011101 + !byte $34,%10110001 + !byte $34,%01011110 + !byte $2D,%00011110 + !byte $02,%11110001 + !byte $0A,%00010000 + !byte $22,%11001011 + !byte $29,%01111100 + !byte $29,%10011101; + !byte $12,%10111011 + !byte $39,%11001101 + !byte $11,%10111101 + !byte $07,%00110000 + !byte $18,%01100100 + !byte $18,%10000101; + !byte $52,%11100001 + !byte $30,%01011110 + !byte $53,%00100010 + !byte $21,%11101001 + !byte $39,%00001100 + !byte $54,%01000010 + !byte $51,%01000000 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $1F,%11000111 + !byte $38,%01101110 + !byte $38,%10001111; + !byte $04,%01110000 + !byte $04,%10010001; + !byte $2E,%00111110 + !byte $38,%10101011 + !byte $09,%00010000 + !byte $39,%11101101 + !byte $33,%11110001 + !byte $03,%10110001 + !byte $11,%01111100 + !byte $11,%10011101; + !byte $01,%00110010 + !byte $05,%01010000 + !byte $37,%11101111 + !byte $36,%00110000 + !byte $28,%01011100 + !byte $1D,%00000110 + !byte $20,%00101000 + !byte $22,%10101011 + !byte $51,%01100000 + !byte $51,%10000001; + !byte $16,%10100101 + !byte $30,%01110010 + !byte $30,%10010011; + !byte $35,%01011110 + !byte $1B,%10100101 + !byte $1E,%01000110 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $12,%01111010 + !byte $12,%10011011; + !byte $39,%00001110 + !byte $11,%01011100 + !byte $21,%11001001 + !byte $06,%00110000 + !byte $36,%00111110 + !byte $32,%01111110 + !byte $32,%10011111; + !byte $2F,%01011110 + !byte $08,%00010000 + !byte $17,%01100100 + !byte $17,%10000101; + !byte $1A,%01100100 + !byte $1A,%10000101; + !byte $33,%01111110 + !byte $33,%10011111; + !byte $02,%11010001 + !byte $39,%11101011 + !byte $1C,%11000101 + !byte $31,%01010010 + !byte $27,%00111100 + !byte $38,%10101111 + !byte $0D,%11101111 + !byte $2B,%11111101 + !byte $1F,%10100111 + !byte $52,%00000010 + !byte $34,%11010001 + !byte $51,%10100001 + !byte $37,%11111101 + !byte $01,%00010010 + !byte $0C,%11101111 + !byte $0E,%11101111 + !byte $22,%01101010 + !byte $22,%10001011; + !byte $11,%00111100 + !byte $31,%01111110 + !byte $31,%10011111; + !byte $2C,%00011110 + !byte $0F,%11101111 + !byte $34,%01111110 + !byte $34,%10011111; + !byte $20,%00001000 + !byte $2A,%11011101 + !byte $0B,%11101111 + !byte $21,%10101001 + !byte $12,%01011010 + !byte $39,%00101110 + !byte $2D,%00111110 + !byte $04,%01010000 + !byte $10,%11101111 + !byte $1D,%11100101 + !byte $36,%01010000 + !byte $07,%00010000 + !byte $32,%00110010 + !byte $29,%10111101 + !byte $03,%01110000 + !byte $03,%10010001; + !byte $0A,%11101111 + !byte $37,%00010000 + !byte $1E,%00100110 + !byte $30,%01111110 + !byte $30,%10011111; + !byte $51,%11000001 + !byte $22,%01001010 + !byte $11,%00011100 + !byte $05,%00110000 + !byte $2E,%01011110 + !byte $38,%11001111 + !byte $53,%01000010 + !byte $35,%10110001 + !byte $19,%01000100 + !byte $10,%01111110 + !byte $10,%10011111; + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $10,%10111111 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $39,%01001110 + !byte $10,%11011111 + !byte $09,%11101111 + !byte $10,%11111111 + !byte $10,%01011110 + !byte $02,%10110001 + !byte $20,%11100111 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $1C,%10100101 + !byte $33,%00010010 + !byte $10,%00111110 + !byte $01,%11110001 + !byte $35,%01111110 + !byte $35,%10011111; + !byte $52,%00100010 + !byte $18,%01000100 + !byte $12,%00111010 + !byte $50,%00000000 + !byte $10,%00011110 + !byte $06,%00010000 + !byte $28,%01111100 + !byte $28,%10011101; + !byte $11,%11111011 + !byte $33,%10111111 + !byte $32,%10111111 + !byte $51,%11100001 + !byte $1A,%01000100 + !byte $2F,%01111110 + !byte $2F,%10011111; + !byte $22,%00101010 + !byte $36,%01011110 + !byte $50,%00100000 + !byte $08,%11101111 + !byte $3A,%01101100 + !byte $3A,%10001101; + !byte $3A,%10101101 + !byte $1D,%11000101 + !byte $3A,%01001100 + !byte $3A,%11001101 + !byte $31,%10111111 + !byte $39,%11001011 + !byte $1E,%00000110 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $10,%11111101 + !byte $34,%11110001 + !byte $37,%00110000 + !byte $03,%01010000 + !byte $50,%01000000 + !byte $04,%00110000 + !byte $1F,%01000110 + !byte $21,%01001000 + !byte $38,%11101111 + !byte $2B,%00011110 + !byte $27,%01011100 + !byte $34,%10111111 + !byte $2C,%00111110 + !byte $10,%11011101 + !byte $20,%11000111 + !byte $36,%01110000 + !byte $36,%10010001; + !byte $22,%00001010 + !byte $3A,%00101100 + !byte $11,%11011011 + !byte $3A,%11101101 + !byte $30,%10111111 + !byte $2D,%01011110 + !byte $2A,%11111101 + !byte $50,%01100000 + !byte $50,%10000001; + !byte $12,%00011010 + !byte $01,%11010001 + !byte $31,%01110010 + !byte $31,%10010011; + !byte $07,%11101111 + !byte $0C,%11001111 + !byte $0D,%11001111 + !byte $02,%01110000 + !byte $02,%10010001; + !byte $10,%10111101 + !byte $37,%00011110 + !byte $0B,%11001111 + !byte $0E,%11001111 + !byte $32,%01010010 + !byte $05,%00010000 + !byte $1C,%01100100 + !byte $1C,%10000101; + !byte $1B,%01000100 + !byte $35,%11010001 + !byte $51,%00000010 + !byte $3A,%00001110 + !byte $2E,%01111110 + !byte $2E,%10011111; + !byte $39,%10101111 + !byte $0A,%11001111 + !byte $21,%00101000 + !byte $1E,%11100101 + !byte $29,%11011101 + !byte $22,%11101001 + !byte $0F,%11001111 + !byte $10,%01111100 + !byte $10,%10011101; + !byte $11,%10111011 + !byte $50,%10100001 + !byte $00,%01010010 + !byte $00,%01110010 + !byte $00,%10010011; + !byte $1F,%00100110 + !byte $20,%10100111 + !byte $26,%00111100 + !byte $3A,%00001100 + !byte $06,%11101111 + !byte $09,%11001111 + !byte $1D,%10100101 + !byte $35,%10111111 + !byte $32,%11011111 + !byte $2F,%10111111 + !byte $3A,%00101110 + !byte $37,%01010000 + !byte $33,%00110010 + !byte $52,%01000010 + !byte $01,%10110001 + !byte $10,%11001111 + !byte $33,%11011111 + !byte $00,%00110010 + !byte $38,%00010000 + !byte $28,%10111101 + !byte $19,%00100100 + !byte $36,%10110001 + !byte $10,%01011100 + !byte $36,%01111110 + !byte $36,%10011111; + !byte $31,%11011111 + !byte $03,%00110000 + !byte $1A,%00100100 + !byte $54,%01100010 + !byte $54,%10000011; + !byte $50,%11000001 + !byte $08,%11001111 + !byte $34,%00010010 + !byte $2B,%00111110 + !byte $00,%00010010 + !byte $21,%00001000 + !byte $22,%11001001 + !byte $2C,%01011110 + !byte $04,%00010000 + !byte $39,%11001111 + !byte $11,%01111010 + !byte $11,%10011011; + !byte $34,%11011111 + !byte $02,%01010000 + !byte $2D,%01111110 + !byte $2D,%10011111; + !byte $3A,%01001110 + !byte $51,%00100010 + !byte $20,%01100110 + !byte $20,%10000111; + !byte $10,%00111100 + !byte $1E,%11000101 + !byte $27,%01111100 + !byte $27,%10011101; + !byte $17,%01000100 + !byte $30,%11011111 + !byte $2A,%00011110 + !byte $1C,%01000100 + !byte $2E,%10111111 + !byte $00,%10110011 + !byte $05,%11101111 + !byte $1F,%00000110 + !byte $35,%11110001 + !byte $23,%10101011 + !byte $07,%11001111 + !byte $0F,%11111111 + !byte $0F,%11011111 + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $38,%00110000 + !byte $0F,%10111111 + !byte $0F,%01111110 + !byte $0F,%10011111; + !byte $31,%10110011 + !byte $50,%11100001 + !byte $00,%11110001 + !byte $18,%00100100 + !byte $1B,%00100100 + !byte $21,%11100111 + !byte $29,%11111101 + !byte $4F,%00000000 + !byte $0F,%01011110 + !byte $22,%10101001 + !byte $3A,%01101110 + !byte $3A,%10001111; + !byte $53,%01100010 + !byte $53,%10000011; + !byte $37,%01110000 + !byte $37,%10010001; + !byte $10,%00011100 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $0F,%00111110 + !byte $11,%01011010 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $4F,%00100000 + !byte $39,%11101111 + !byte $32,%01110010 + !byte $32,%10010011; + !byte $0B,%10101111 + !byte $0C,%10101111 + !byte $0D,%10101111 + !byte $35,%11011111 + !byte $37,%00111110 + !byte $20,%01000110 + !byte $0A,%10101111 + !byte $3B,%10101101 + !byte $33,%01010010 + !byte $32,%11111111 + !byte $0F,%00011110 + !byte $3A,%11101011 + !byte $2F,%11011111 + !byte $4F,%01000000 + !byte $03,%00010000 + !byte $06,%11001111 + !byte $0E,%10101111 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $3B,%11001101 + !byte $33,%11111111 + !byte $28,%11011101 + !byte $02,%00110000 + !byte $22,%01101000 + !byte $22,%10001001; + !byte $36,%11010001 + !byte $09,%10101111 + !byte $31,%11111111 + !byte $04,%11101111 + !byte $26,%01011100 + !byte $00,%11010001 + !byte $1E,%10100101 + !byte $3B,%11101101 + !byte $0F,%11111101 + !byte $1F,%11100101 + !byte $21,%11000111 + !byte $23,%01001010 + !byte $34,%00110010 + !byte $36,%10111111 + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $50,%00000010 + !byte $3A,%10101111 + !byte $10,%11111011 + !byte $34,%11111111 + !byte $0F,%10101111 + !byte $3B,%01001100 + !byte $3B,%00001110 + !byte $0F,%11011101 + !byte $08,%10101111 + !byte $2C,%01111110 + !byte $2C,%10011111; + !byte $2B,%01011110 + !byte $30,%11111111 + !byte $2D,%10111111 + !byte $1A,%00000100 + !byte $1C,%00100100 + !byte $2A,%00111110 + !byte $22,%01001000 + !byte $38,%01010000 + !byte $51,%01000010 + !byte $39,%00010000 + !byte $01,%01010000 + !byte $05,%11001111 + !byte $20,%00100110 + !byte $23,%00101010 + !byte $1D,%01000100 + !byte $4F,%10100001 + !byte $11,%00111010 + !byte $0F,%10111101 + !byte $19,%00000100 + !byte $35,%00010010 + !byte $27,%10111101 + !byte $3B,%00101110 + !byte $29,%00011110 + !byte $10,%11011011 + !byte $21,%10100111 + !byte $2E,%11011111 + !byte $07,%10101111 + !byte $37,%10110001 + !byte $1B,%00000100 + !byte $00,%10110001 + !byte $52,%01100010 + !byte $52,%10000011; + !byte $3B,%00101100 + !byte $3A,%11001111 + !byte $1E,%01100100 + !byte $1E,%10000101; + !byte $02,%00010000 + !byte $4F,%11000001 + !byte $1F,%11000101 + !byte $22,%00101000 + !byte $2F,%11111111 + !byte $0F,%01111100 + !byte $0F,%10011101; + !byte $72,%00000000 + !byte $03,%11101111 + !byte $23,%00001010 + !byte $35,%11111111 + !byte $73,%00000000 + !byte $50,%00100010 + !byte $06,%10101111 + !byte $3B,%01001110 + !byte $36,%11110001 + !byte $31,%11010011 + !byte $04,%11001111 + !byte $39,%00110000 + !byte $38,%01110000 + !byte $38,%10010001; + !byte $20,%00000110 + !byte $71,%00000000 + !byte $28,%11111101 + !byte $11,%00011010 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $0C,%01101110 + !byte $0C,%10001111; + !byte $32,%10110011 + !byte $10,%10111011 + !byte $01,%00110000 + !byte $21,%01100110 + !byte $21,%10000111; + !byte $33,%01110010 + !byte $33,%10010011; + !byte $0A,%01101110 + !byte $0A,%10001111; + !byte $2C,%10111111 + !byte $23,%11101001 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $1C,%00000100 + !byte $2B,%01111110 + !byte $2B,%10011111; + !byte $26,%01111100 + !byte $26,%10011101; + !byte $4F,%11100001 + !byte $00,%01110000 + !byte $00,%10010001; + !byte $1D,%00100100 + !byte $22,%00001000 + !byte $34,%01010010 + !byte $2D,%11011111 + !byte $0F,%01011100 + !byte $74,%00000000 + !byte $3A,%11101111 + !byte $37,%11010001 + !byte $36,%11011111 + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $0E,%01101110 + !byte $0E,%10001111; + !byte $0E,%11111111 + !byte $0E,%11011111 + !byte $0E,%10111111 + !byte $70,%00000000 + !byte $05,%10101111 + !byte $1F,%10100101 + !byte $08,%01101110 + !byte $08,%10001111; + !byte $2E,%11111111 + !byte $0E,%01111110 + !byte $0E,%10011111; + !byte $4E,%00000000 + !byte $23,%11001001 + !byte $1E,%01000100 + !byte $35,%00110010 + !byte $4E,%00100000 + !byte $20,%11100101 + !byte $21,%01000110 + !byte $27,%11011101 + !byte $2A,%01011110 + !byte $0E,%01011110 + !byte $0F,%00111100 + !byte $22,%11100111 + !byte $02,%11101111 + !byte $4E,%01000000 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $3B,%10101111 + !byte $29,%00111110 + !byte $0E,%00111110 + !byte $10,%01111010 + !byte $10,%10011011; + !byte $03,%11001111 + !byte $1A,%11100011 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $3B,%00001100 + !byte $39,%01010000 + !byte $4F,%00000010 + !byte $00,%01010000 + !byte $1B,%11100011 + !byte $3A,%00010000 + !byte $6F,%00000000 + !byte $50,%01000010 + !byte $0E,%00011110 + !byte $37,%01011110 + !byte $38,%10110001 + !byte $4E,%01100000 + !byte $4E,%10000001; + !byte $01,%00010000 + !byte $23,%10101001 + !byte $3C,%11001101 + !byte $36,%00010010 + !byte $72,%00100000 + !byte $51,%01100010 + !byte $51,%10000011; + !byte $3C,%10101101 + !byte $3C,%11101101 + !byte $73,%00100000 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $0F,%00011100 + !byte $04,%10101111 + !byte $3C,%00001110 + !byte $71,%00100000 + !byte $21,%00100110 + !byte $28,%00011110 + !byte $06,%01101110 + !byte $06,%10001111; + !byte $22,%11000111 + !byte $75,%00000000 + !byte $1D,%00000100 + !byte $0E,%11111101 + !byte $4E,%10100001 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $3C,%01101100 + !byte $3C,%10001101; + !byte $1E,%00100100 + !byte $20,%11000101 + !byte $37,%11110001 + !byte $3B,%11001111 + !byte $2B,%10111111 + !byte $10,%01011010 + !byte $2C,%11011111 + !byte $70,%00100000 + !byte $2D,%11111111 + !byte $3C,%00101110 + !byte $26,%10111101 + !byte $0A,%01001110 + !byte $0B,%01001110 + !byte $1C,%11100011 + !byte $0E,%11011101 + !byte $33,%10110011 + !byte $74,%00100000 + !byte $0F,%11111011 + !byte $32,%11010011 + !byte $0C,%01001110 + !byte $34,%01110010 + !byte $34,%10010011; + !byte $2A,%01111110 + !byte $2A,%10011111; + !byte $4E,%11000001 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $09,%01001110 + !byte $4F,%00100010 + !byte $08,%01001110 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $6E,%00000000 + !byte $02,%11001111 + !byte $22,%10100111 + !byte $24,%01101010 + !byte $24,%10001011; + !byte $0D,%01001110 + !byte $23,%01001000 + !byte $00,%00110000 + !byte $3C,%01001110 + !byte $3A,%00110000 + !byte $0E,%10111101 + !byte $03,%10101111 + !byte $36,%11111111 + !byte $35,%01010010 + !byte $27,%11111101 + !byte $21,%00000110 + !byte $19,%11100011 + !byte $3C,%01001100 + !byte $07,%01001110 + !byte $01,%11101111 + !byte $3B,%11101111 + !byte $29,%01011110 + !byte $1F,%01000100 + !byte $6F,%00100000 + !byte $38,%11010001 + !byte $24,%01001010 + !byte $0F,%11011011 + !byte $10,%00111010 + !byte $0E,%01001110 + !byte $72,%01000000 + !byte $4E,%11100001 + !byte $20,%10100101 + !byte $3C,%01101110 + !byte $3C,%10001111; + !byte $0E,%01111100 + !byte $0E,%10011101; + !byte $23,%00101000 + !byte $36,%00110010 + !byte $04,%01101110 + !byte $04,%10001111; + !byte $22,%01100110 + !byte $22,%10000111; + !byte $06,%01001110 + !byte $73,%01000000 + !byte $71,%01000000 + !byte $1D,%11100011 + !byte $1E,%00000100 + !byte $24,%00101010 + !byte $28,%00111110 + !byte $3A,%01010000 + !byte $37,%00010010 + !byte $21,%11100101 + !byte $75,%00100000 + !byte $2C,%11111111 + !byte $0D,%11111111 + !byte $0D,%11011111 + !byte $39,%10110001 + !byte $6D,%00000000 + !byte $00,%00010000 + !byte $1B,%11000011 + !byte $2B,%11011111 + !byte $4D,%00000000 + !byte $0D,%10111111 + !byte $0E,%01011100 + !byte $0F,%01001110 + !byte $23,%00001000 + !byte $2A,%10111111 + !byte $4D,%00100000 + !byte $0D,%01111110 + !byte $0D,%10011111; + !byte $3C,%10101111 + !byte $70,%01000000 + !byte $50,%01100010 + !byte $50,%10000011; + !byte $26,%11011101 + !byte $24,%00001010 + !byte $1F,%00100100 + !byte $3B,%00010000 + !byte $6E,%00100000 + !byte $02,%10101111 + !byte $05,%01001110 + !byte $1C,%11000011 + !byte $74,%01000000 + !byte $20,%01100100 + !byte $20,%10000101; + !byte $22,%01000110 + !byte $4E,%00000010 + !byte $4F,%01000010 + !byte $0D,%01011110 + !byte $4D,%01000000 + !byte $0F,%10111011 + !byte $01,%11001111 + !byte $09,%00101110 + !byte $34,%10110011 + !byte $10,%00011010 + !byte $0A,%00101110 + !byte $33,%11010011 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $0B,%00101110 + !byte $1A,%11000011 + !byte $24,%11101001 + !byte $0D,%00111110 + !byte $0E,%00111100 + !byte $38,%11110001 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $23,%11100111 + !byte $08,%00101110 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $27,%00011110 + !byte $0C,%00101110 + !byte $0D,%00011110 + !byte $21,%11000101 + !byte $3C,%11001111 + !byte $6F,%01000000 + !byte $3C,%00101100 + !byte $32,%11110011 + !byte $29,%01111110 + !byte $29,%10011111; + !byte $24,%11001001 + !byte $3B,%00110000 + !byte $3A,%01110000 + !byte $3A,%10010001; + !byte $4D,%10100001 + !byte $04,%01001110 + !byte $07,%00101110 + !byte $22,%00100110 + !byte $1E,%11100011 + !byte $3D,%11101101 + !byte $72,%01100000 + !byte $72,%10000001; + !byte $0D,%00101110 + !byte $1D,%11000011 + !byte $3D,%00001110 + !byte $39,%11010001 + !byte $36,%01010010 + !byte $73,%01100000 + !byte $73,%10000001; + !byte $71,%01100000 + !byte $71,%10000001; + !byte $0D,%11111101 + !byte $00,%11101111 + !byte $0F,%01111010 + !byte $0F,%10011011; + !byte $20,%01000100 + !byte $3D,%11001101 + !byte $23,%11000111 + !byte $37,%00110010 + !byte $6C,%00000000 + !byte $76,%00000000 + !byte $0E,%00011100 + !byte $3D,%00101110 + !byte $4E,%00100010 + !byte $06,%00101110 + !byte $2B,%11111111 + !byte $28,%01011110 + !byte $1F,%00000100 + !byte $6D,%00100000 + !byte $02,%01101110 + !byte $02,%10001111; + !byte $70,%01100000 + !byte $70,%10000001; + !byte $24,%10101001 + !byte $3C,%11101111 + !byte $4D,%11000001 + !byte $0E,%00101110 + !byte $3D,%01001110 + !byte $21,%10100101 + !byte $3D,%10101101 + !byte $0D,%11011101 + !byte $01,%10101111 + !byte $22,%00000110 + !byte $6E,%01000000 + !byte $2A,%11011111 + !byte $75,%01000000 + !byte $23,%10100111 + !byte $05,%00101110 + !byte $26,%11111101 + !byte $03,%01001110 + !byte $74,%01100000 + !byte $74,%10000001; + !byte $24,%01101000 + !byte $24,%10001001; + !byte $38,%00010010 + !byte $4D,%11100001 + !byte $0E,%11111011 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $3B,%01010000 + !byte $0F,%01011010 + !byte $00,%11001111 + !byte $3A,%10110001 + !byte $0F,%00101110 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $29,%10111111 + !byte $27,%00111110 + !byte $0D,%10111101 + !byte $1C,%10100011 + !byte $20,%00100100 + !byte $09,%00001110 + !byte $1E,%11000011 + !byte $24,%01001000 + !byte $0A,%00001110 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $0B,%00001110 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $35,%10110011 + !byte $08,%00001110 + !byte $3C,%00010000 + !byte $39,%11110001 + !byte $33,%11110011 + !byte $1B,%10100011 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $22,%11100101 + !byte $34,%11010011 + !byte $3D,%10101111 + !byte $72,%10100001 + !byte $04,%00101110 + !byte $0C,%11111111 + !byte $07,%00001110 + !byte $1F,%11100011 + !byte $36,%01110010 + !byte $36,%10010011; + !byte $71,%10100001 + !byte $0D,%01111100 + !byte $0D,%10011101; + !byte $0E,%11011011 + !byte $0C,%00001110 + !byte $4C,%00000000 + !byte $0C,%11011111 + !byte $24,%00101000 + !byte $37,%01010010 + !byte $6B,%00000000 + !byte $4E,%01000010 + !byte $4C,%00100000 + !byte $73,%10100001 + !byte $0C,%10111111 + !byte $4D,%00000010 + !byte $28,%01111110 + !byte $28,%10011111; + !byte $06,%00001110 + !byte $1D,%10100011 + !byte $6C,%00100000 + !byte $6D,%01000000 + !byte $02,%01001110 + !byte $25,%11011101 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $0C,%01111110 + !byte $0C,%10011111; + !byte $0F,%00111010 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $70,%10100001 + !byte $4C,%01000000 + !byte $23,%01000110 + !byte $22,%11000101 + !byte $0C,%01011110 + !byte $3D,%11001111 + !byte $0D,%00001110 + !byte $20,%00000100 + !byte $6E,%01100000 + !byte $6E,%10000001; + !byte $2A,%11111111 + !byte $4C,%01100000 + !byte $4C,%10000001; + !byte $03,%00101110 + !byte $24,%00001000 + !byte $21,%01000100 + !byte $3C,%00110000 + !byte $0D,%01011100 + !byte $05,%00001110 + !byte $3A,%11010001 + !byte $00,%10101111 + !byte $38,%00110010 + !byte $25,%01001010 + !byte $26,%00011110 + !byte $0C,%00111110 + !byte $29,%11011111 + !byte $4C,%10100001 + !byte $74,%10100001 + !byte $0E,%10111011 + !byte $23,%00100110 + !byte $27,%01011110 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $39,%00010010 + !byte $76,%00100000 + !byte $6F,%10100001 + !byte $0E,%00001110 + !byte $4D,%00100010 + !byte $24,%11100111 + !byte $25,%00101010 + !byte $0C,%00011110 + !byte $1E,%10100011 + !byte $3D,%11101111 + !byte $04,%00001110 + !byte $1F,%11000011 + !byte $0F,%00011010 + !byte $22,%10100101 + !byte $4C,%11000001 + !byte $0D,%00111100 + !byte $25,%00001010 + !byte $72,%11000001 + !byte $09,%11101101 + !byte $3B,%10110001 + !byte $71,%11000001 + !byte $6C,%01000000 + !byte $01,%01001110 + !byte $08,%11101101 + !byte $35,%11010011 + !byte $0C,%11111101 + !byte $0A,%11101101 + !byte $3C,%01010000 + !byte $07,%11101101 + !byte $3E,%00001110 + !byte $24,%11000111 + !byte $3E,%00101110 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $02,%00101110 + !byte $36,%10110011 + !byte $6B,%00100000 + !byte $0B,%11101101 + !byte $0F,%00001110 + !byte $21,%00100100 + !byte $23,%00000110 + !byte $20,%11100011 + !byte $3E,%11101101 + !byte $3E,%01001110 + !byte $73,%11000001 + !byte $25,%11101001 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $28,%10111111 + !byte $06,%11101101 + !byte $34,%11110011 + !byte $70,%11000001 + !byte $00,%01101110 + !byte $00,%10001111; + !byte $3A,%11110001 + !byte $0E,%01111010 + !byte $0E,%10011011; + !byte $3D,%00010000 + !byte $4C,%11100001 + !byte $0C,%11011101 + !byte $22,%01100100 + !byte $22,%10000101; + !byte $6E,%10100001 + !byte $6A,%00000000 + !byte $0D,%00011100 + !byte $3D,%01001100 + !byte $0C,%11101101 + !byte $1C,%01100010 + !byte $1C,%10000011; + !byte $3E,%01101110 + !byte $3E,%10001111; + !byte $33,%00010100 + !byte $03,%00001110 + !byte $25,%11001001 + !byte $38,%01010010 + !byte $4E,%01100010 + !byte $4E,%10000011; + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $24,%10100111 + !byte $25,%11111101 + !byte $05,%11101101 + !byte $3E,%11001101 + !byte $29,%11111111 + !byte $26,%00111110 + !byte $23,%11100101 + !byte $3C,%01110000 + !byte $3C,%10010001; + !byte $39,%00110010 + !byte $0C,%10111101 + !byte $25,%10101001 + !byte $3B,%11010001 + !byte $1F,%10100011 + !byte $6F,%11000001 + !byte $0F,%11111001 + !byte $21,%00000100 + !byte $4D,%01000010 + !byte $3E,%10101111 + !byte $0D,%11111011 + !byte $0D,%11101101 + !byte $24,%01100110 + !byte $24,%10000111; + !byte $27,%01111110 + !byte $27,%10011111; + !byte $01,%00101110 + !byte $04,%11101101 + !byte $4C,%00000010 + !byte $4B,%00000000 + !byte $0B,%11111111 + !byte $0B,%11011111 + !byte $1E,%01100010 + !byte $1E,%10000011; + !byte $25,%01101000 + !byte $25,%10001001; + !byte $74,%11000001 + !byte $3D,%00110000 + !byte $4B,%00100000 + !byte $0E,%01011010 + !byte $20,%11000011 + !byte $6C,%01100000 + !byte $6C,%10000001; + !byte $0B,%10111111 + !byte $22,%01000100 + !byte $72,%11100001 + !byte $71,%11100001 + !byte $6D,%10100001 + !byte $4B,%01000000 + !byte $0C,%01111100 + !byte $0C,%10011101; + !byte $23,%11000101 + !byte $75,%10100001 + !byte $00,%01001110 + !byte $3A,%00010010 + !byte $0B,%01111110 + !byte $0B,%10011111; + !byte $6B,%01000000 + !byte $02,%00001110 + !byte $25,%01001000 + !byte $3E,%11001111 + !byte $0E,%11101101 + !byte $07,%11001101 + !byte $36,%11010011 + !byte $08,%11001101 + !byte $09,%11001101 + !byte $24,%01000110 + !byte $6A,%00100000 + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $28,%11011111 + !byte $0D,%11011011 + !byte $73,%11100001 + !byte $0B,%01011110 + !byte $3E,%10101101 + !byte $6E,%11000001 + !byte $0A,%11001101 + !byte $70,%11100001 + !byte $03,%11101101 + !byte $06,%11001101 + !byte $35,%11110011 + !byte $37,%10110011 + !byte $25,%00101000 + !byte $3C,%10110001 + !byte $38,%01110010 + !byte $38,%10010011; + !byte $0B,%11001101 + !byte $21,%11100011 + !byte $0B,%00111110 + !byte $3D,%01010000 + !byte $0C,%01011100 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $25,%00011110 + !byte $4B,%10100001 + !byte $3B,%11110001 + !byte $3E,%11101111 + !byte $34,%00010100 + !byte $26,%01011110 + !byte $23,%10100101 + !byte $69,%00000000 + !byte $05,%11001101 + !byte $22,%00100100 + !byte $24,%00100110 + !byte $39,%01010010 + !byte $4C,%00100010 + !byte $25,%00001000 + !byte $0B,%00011110 + !byte $0E,%00111010 + !byte $6F,%11100001 + !byte $0C,%11001101 + !byte $0F,%11101101 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $20,%10100011 + !byte $33,%00110100 + !byte $27,%10111111 + !byte $4B,%11000001 + !byte $0D,%10111011 + !byte $01,%00001110 + !byte $04,%11001101 + !byte $6C,%10100001 + !byte $0C,%00111100 + !byte $00,%00101110 + !byte $25,%11100111 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $0B,%11111101 + !byte $02,%11101101 + !byte $24,%00000110 + !byte $3E,%00010000 + !byte $3A,%00110010 + !byte $1D,%01000010 + !byte $23,%01100100 + !byte $23,%10000101; + !byte $72,%00000010 + !byte $21,%11000011 + !byte $76,%01000000 + !byte $71,%00000010 + !byte $6D,%11000001 + !byte $0D,%11001101 + !byte $22,%00000100 + !byte $6A,%01000000 + !byte $28,%11111111 + !byte $4B,%11100001 + !byte $25,%11000111 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $3C,%11010001 + !byte $74,%11100001 + !byte $6E,%11100001 + !byte $0B,%11011101 + !byte $1E,%01000010 + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $07,%10101101 + !byte $3F,%00101110 + !byte $3F,%01001110 + !byte $70,%00000010 + !byte $08,%10101101 + !byte $3B,%00010010 + !byte $03,%11001101 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $09,%10101101 + !byte $24,%11100101 + !byte $25,%00111110 + !byte $0C,%00011100 + !byte $38,%10110011 + !byte $37,%11010011 + !byte $73,%00000010 + !byte $0E,%00011010 + !byte $06,%10101101 + !byte $0A,%10101101 + !byte $0D,%01111010 + !byte $0D,%10011011; + !byte $3F,%00001110 + !byte $26,%01111110 + !byte $26,%10011111; + !byte $25,%10100111 + !byte $4C,%01000010 + !byte $3E,%00110000 + !byte $23,%01000100 + !byte $26,%00101010 + !byte $36,%11110011 + !byte $35,%00010100 + !byte $69,%00100000 + !byte $26,%00001010 + !byte $3F,%10101111 + !byte $0B,%10111101 + !byte $0E,%11001101 + !byte $1C,%01000010 + !byte $20,%01100010 + !byte $20,%10000011; + !byte $6F,%00000010 + !byte $75,%11000001 + !byte $4B,%00000010 + !byte $05,%10101101 + !byte $39,%01110010 + !byte $39,%10010011; + !byte $27,%11011111 + !byte $4A,%00000000 + !byte $0A,%11111111 + !byte $01,%11101101 + !byte $0B,%10101101 + !byte $26,%11101001 + !byte $34,%00110100 + !byte $4A,%00100000 + !byte $1F,%01000010 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $0A,%11011111 + !byte $22,%11100011 + !byte $3D,%10110001 + !byte $3A,%01010010 + !byte $24,%11000101 + !byte $4A,%01000000 + !byte $0A,%10111111 + !byte $00,%00001110 + !byte $21,%10100011 + !byte $3F,%11101101 + !byte $3F,%11001111 + !byte $0C,%11111011 + !byte $6C,%11000001 + !byte $04,%10101101 + !byte $3E,%01010000 + !byte $3C,%11110001 + !byte $02,%11001101 + !byte $26,%11001001 + !byte $6B,%10100001 + !byte $23,%00100100 + !byte $6D,%11100001 + !byte $4A,%01100000 + !byte $4A,%10000001; + !byte $0B,%01111100 + !byte $0B,%10011101; + !byte $0C,%10101101 + !byte $0A,%01111110 + !byte $0A,%10011111; + !byte $3B,%00110010 + !byte $71,%00100010 + !byte $0D,%01011010 + !byte $26,%10101001 + !byte $33,%01010100 + !byte $6A,%01100000 + !byte $6A,%10000001; + !byte $68,%00000000 + !byte $4A,%10100001 + !byte $0E,%11111001 + !byte $0F,%11001101 + !byte $0A,%01011110 + !byte $25,%01000110 + !byte $3F,%11101111 + !byte $72,%00100010 + !byte $6E,%00000010 + !byte $70,%00100010 + !byte $24,%10100101 + !byte $26,%01101000 + !byte $26,%10001001; + !byte $03,%10101101 + !byte $26,%10111111 + !byte $4B,%00100010 + !byte $3D,%11010001 + !byte $0B,%01011100 + !byte $22,%11000011 + !byte $0A,%00111110 + !byte $74,%00000010 + !byte $0C,%11011011 + !byte $07,%01101100 + !byte $07,%10001101; + !byte $37,%11110011 + !byte $25,%01011110 + !byte $08,%01101100 + !byte $08,%10001101; + !byte $0D,%10101101 + !byte $26,%01001000 + !byte $25,%00100110 + !byte $4A,%11000001 + !byte $06,%01101100 + !byte $06,%10001101; + !byte $09,%01101100 + !byte $09,%10001101; + !byte $38,%11010011 + !byte $69,%01000000 + !byte $3F,%00010000 + !byte $20,%01000010 + !byte $36,%00010100 + !byte $3E,%01110000 + !byte $3E,%10010001; + !byte $39,%10110011 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $6F,%00100010 + !byte $00,%11101101 + !byte $26,%00101000 + !byte $0A,%00011110 + !byte $01,%11001101 + !byte $73,%00100010 + !byte $23,%00000100 + !byte $3C,%00010010 + !byte $05,%01101100 + !byte $05,%10001101; + !byte $0A,%01101100 + !byte $0A,%10001101; + !byte $24,%01100100 + !byte $24,%10000101; + !byte $3A,%01110010 + !byte $3A,%10010011; + !byte $27,%11111111 + !byte $1E,%00100010 + !byte $6B,%11000001 + !byte $25,%00000110 + !byte $02,%10101101 + !byte $0D,%00111010 + !byte $26,%00001000 + !byte $6C,%11100001 + !byte $35,%00110100 + !byte $4A,%11100001 + !byte $04,%01101100 + !byte $04,%10001101; + !byte $0B,%00111100 + !byte $0A,%11111101 + !byte $6D,%00000010 + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $3F,%11001101 + !byte $4C,%01100010 + !byte $4C,%10000011; + !byte $0E,%10101101 + !byte $3B,%01010010 + !byte $6A,%10100001 + !byte $68,%00100000 + !byte $1F,%00100010 + !byte $3F,%00110000 + !byte $0C,%10111011 + !byte $71,%01000010 + !byte $26,%11100111 + !byte $3D,%11110001 + !byte $22,%10100011 + !byte $24,%01000100 + !byte $6E,%00100010 + !byte $1D,%00100010 + !byte $23,%11100011 + !byte $3E,%10110001 + !byte $25,%11100101 + !byte $34,%01010100 + !byte $0A,%11011101 + !byte $70,%01000010 + !byte $72,%01000010 + !byte $25,%01111110 + !byte $25,%10011111; + !byte $03,%01101100 + !byte $03,%10001101; + !byte $0C,%01101100 + !byte $0C,%10001101; + !byte $26,%11000111 + !byte $26,%11011111 + !byte $24,%00111110 + !byte $4B,%01000010 + !byte $0B,%00011100 + !byte $00,%11001101 + !byte $69,%01100000 + !byte $69,%10000001; + !byte $3C,%00110010 + !byte $01,%10101101 + !byte $4A,%00000010 + !byte $49,%00000000 + !byte $09,%11111111 + !byte $3F,%01010000 + !byte $38,%11110011 + !byte $75,%11100001 + !byte $49,%00100000 + !byte $0A,%10111101 + !byte $06,%01001100 + !byte $07,%01001100 + !byte $09,%11011111 + !byte $0D,%00011010 + !byte $08,%01001100 + !byte $24,%00100100 + !byte $26,%10100111 + !byte $67,%00000000 + !byte $0F,%10101101 + !byte $21,%01000010 + !byte $25,%11000101 + !byte $39,%11010011 + !byte $6F,%01000010 + !byte $6B,%11100001 + !byte $49,%01000000 + !byte $09,%10111111 + !byte $20,%00100010 + !byte $37,%00010100 + !byte $0C,%01111010 + !byte $0C,%10011011; + !byte $05,%01001100 + !byte $6C,%00000010 + !byte $09,%01001100 + !byte $02,%01101100 + !byte $02,%10001101; + !byte $3A,%10110011 + !byte $74,%00100010 + !byte $09,%01111110 + !byte $09,%10011111; + !byte $6D,%00100010 + !byte $49,%01100000 + !byte $49,%10000001; + !byte $0B,%11111011 + !byte $3E,%11010001 + !byte $73,%01000010 + !byte $0A,%01001100 + !byte $22,%01100010 + !byte $22,%10000011; + !byte $68,%01000000 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $23,%11000011 + !byte $26,%01100110 + !byte $26,%10000111; + !byte $3D,%00010010 + !byte $36,%00110100 + !byte $04,%01001100 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $09,%01011110 + !byte $25,%10100101 + !byte $49,%10100001 + !byte $0A,%01111100 + !byte $0A,%10011101; + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $6A,%11000001 + !byte $6E,%01000010 + !byte $35,%01010100 + !byte $24,%00000100 + !byte $26,%01000110 + !byte $3C,%01010010 + !byte $71,%01100010 + !byte $71,%10000011; + !byte $09,%00111110 + !byte $0B,%01001100 + !byte $4A,%00100010 + !byte $27,%00101010 + !byte $25,%10111111 + !byte $27,%00001010 + !byte $70,%01100010 + !byte $70,%10000011; + !byte $26,%11111111 + !byte $69,%10100001 + !byte $03,%01001100 + !byte $49,%11000001 + !byte $00,%10101101 + !byte $27,%11101001 + !byte $3E,%11110001 + !byte $72,%01100010 + !byte $72,%10000011; + !byte $0E,%01101100 + !byte $0E,%10001101; + !byte $23,%10100011 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $0A,%01011100 + !byte $0C,%01011010 + !byte $27,%11001001 + !byte $67,%00100000 + !byte $09,%00011110 + !byte $0D,%11111001 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $26,%00100110 + !byte $0B,%11011011 + !byte $21,%00100010 + !byte $34,%01110100 + !byte $34,%10010101; + !byte $24,%01011110 + !byte $6B,%00000010 + !byte $1F,%00000010 + !byte $27,%10101001 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $22,%01000010 + !byte $6C,%00100010 + !byte $3F,%10110001 + !byte $3A,%11010011 + !byte $39,%11110011 + !byte $06,%00101100 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $3D,%00110010 + !byte $07,%00101100 + !byte $0C,%01001100 + !byte $08,%00101100 + !byte $24,%11100011 + !byte $38,%00010100 + !byte $02,%01001100 + !byte $05,%00101100 + !byte $6D,%01000010 + !byte $49,%11100001 + !byte $09,%11111101 + !byte $26,%00000110 + !byte $3B,%10110011 + !byte $25,%01000100 + !byte $68,%01100000 + !byte $68,%10000001; + !byte $09,%00101100 + !byte $27,%01001000 + !byte $37,%00110100 + !byte $6A,%11100001 + !byte $1E,%00000010 + !byte $0C,%00111010 + !byte $20,%00000010 + !byte $0A,%00111100 + !byte $27,%00101000 + !byte $04,%00101100 + !byte $36,%01010100 + !byte $6E,%01100010 + !byte $6E,%10000011; + !byte $09,%11011101 + !byte $26,%11100101 + !byte $3E,%00010010 + !byte $3C,%01110010 + !byte $3C,%10010011; + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $23,%01100010 + !byte $23,%10000011; + !byte $27,%00001000 + !byte $0A,%00101100 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $3F,%11010001 + !byte $69,%11000001 + !byte $25,%11011111 + !byte $0B,%10111011 + !byte $0D,%01001100 + !byte $24,%11000011 + !byte $25,%00100100 + !byte $66,%00000000 + !byte $0A,%00011100 + !byte $71,%10100011 + !byte $24,%01111110 + !byte $24,%10011111; + !byte $0D,%11011001 + !byte $00,%01101100 + !byte $00,%10001101; + !byte $03,%00101100 + !byte $27,%11100111 + !byte $70,%10100011 + !byte $4A,%01000010 + !byte $48,%00000000 + !byte $08,%11111111 + !byte $74,%01000010 + !byte $48,%00100000 + !byte $49,%00000010 + !byte $26,%11000101 + !byte $67,%01000000 + !byte $08,%11011111 + !byte $01,%01001100 + !byte $09,%10111101 + !byte $48,%01000000 + !byte $27,%11000111 + !byte $35,%01110100 + !byte $35,%10010101; + !byte $08,%10111111 + !byte $0B,%00101100 + !byte $6F,%10100011 + !byte $6B,%00100010 + !byte $3D,%01010010 + !byte $48,%01100000 + !byte $48,%10000001; + !byte $72,%10100011 + !byte $6C,%01000010 + !byte $21,%00000010 + !byte $22,%00100010 + !byte $68,%10100001 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $08,%01111110 + !byte $08,%10011111; + !byte $0B,%01111010 + !byte $0B,%10011011; + !byte $02,%00101100 + !byte $06,%00001100 + !byte $26,%10100101 + !byte $27,%10100111 + !byte $6A,%00000010 + !byte $0C,%00011010 + !byte $07,%00001100 + !byte $3A,%11110011 + !byte $39,%00010100 + !byte $38,%00110100 + !byte $0E,%01001100 + !byte $05,%00001100 + !byte $25,%00000100 + !byte $48,%10100001 + !byte $3F,%11110001 + !byte $08,%01011110 + !byte $3B,%11010011 + !byte $23,%01000010 + !byte $24,%10100011 + !byte $0A,%11111011 + !byte $09,%01111100 + !byte $09,%10011101; + !byte $08,%00001100 + !byte $0C,%00101100 + !byte $3E,%00110010 + !byte $34,%10110101 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $6E,%10100011 + !byte $37,%01010100 + !byte $04,%00001100 + !byte $3C,%10110011 + !byte $09,%00001100 + !byte $69,%11100001 + !byte $08,%00111110 + !byte $66,%00100000 + !byte $49,%00100010 + !byte $25,%11111111 + !byte $26,%01100100 + !byte $26,%10000101; + !byte $48,%11000001 + !byte $00,%01001100 + !byte $27,%01000110 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $24,%10111111 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $25,%11100011 + !byte $03,%00001100 + !byte $01,%00101100 + !byte $0A,%00001100 + !byte $70,%11000011 + !byte $6B,%01000010 + !byte $71,%11000011 + !byte $09,%01011100 + !byte $36,%01110100 + !byte $36,%10010101; + !byte $08,%00011110 + !byte $0B,%01011010 + !byte $0F,%01001100 + !byte $24,%01100010 + !byte $24,%10000011; + !byte $27,%00100110 + !byte $3F,%00010010 + !byte $73,%10100011 + !byte $6C,%01100010 + !byte $6C,%10000011; + !byte $68,%11000001 + !byte $0D,%00101100 + !byte $0A,%11011011 + !byte $20,%11100001 + !byte $6F,%11000011 + !byte $22,%00000010 + !byte $26,%01000100 + !byte $0C,%11111001 + !byte $6D,%10100011 + !byte $23,%00100010 + !byte $6A,%00100010 + !byte $48,%11100001 + !byte $08,%11111101 + !byte $3A,%00010100 + !byte $02,%00001100 + !byte $25,%11000011 + !byte $27,%00000110 + !byte $3E,%01010010 + !byte $3B,%11110011 + !byte $0B,%00001100 + !byte $1F,%11100001 + !byte $09,%00111100 + !byte $39,%00110100 + !byte $3C,%11010011 + !byte $72,%11000011 + !byte $05,%11101011 + !byte $21,%11100001 + !byte $08,%11011101 + !byte $06,%11101011 + !byte $07,%11101011 + !byte $35,%10110101 + !byte $66,%01000000 + !byte $65,%00000000 + !byte $08,%11101011 + !byte $6E,%11000011 + !byte $26,%00100100 + !byte $38,%01010100 + !byte $27,%11100101 + !byte $69,%00000010 + !byte $04,%11101011 + !byte $28,%11001001 + !byte $28,%11101001 + !byte $0A,%10111011 + !byte $00,%00101100 + !byte $28,%00001010 + !byte $67,%10100001 + !byte $0E,%00101100 + !byte $28,%10101001 + !byte $47,%00000000 + !byte $24,%01000010 + !byte $3D,%10110011 + !byte $24,%11011111 + !byte $07,%11111111 + !byte $28,%01101000 + !byte $28,%10001001; + !byte $47,%00100000 + !byte $3F,%00110010 + !byte $07,%11011111 + !byte $27,%11000101 + !byte $0B,%00111010 + !byte $09,%11101011 + !byte $03,%11101011 + !byte $28,%01001000 + !byte $08,%10111101 + !byte $01,%00001100 + !byte $37,%01110100 + !byte $37,%10010101; + !byte $47,%01000000 + !byte $0C,%00001100 + !byte $28,%00101000 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $48,%00000010 + !byte $07,%10111111 + !byte $09,%00011100 + !byte $25,%10100011 + !byte $26,%00000100 + !byte $23,%01111110 + !byte $23,%10011111; + !byte $68,%11100001 + !byte $6C,%10100011 + !byte $0C,%11011001 + !byte $28,%00001000 + !byte $70,%11100011 + !byte $49,%01000010 + !byte $07,%01111110 + !byte $07,%10011111; + !byte $3E,%01110010 + !byte $3E,%10010011; + !byte $74,%01100010 + !byte $74,%10000011; + !byte $47,%01100000 + !byte $47,%10000001; + !byte $0A,%11101011 + !byte $71,%11100011 + !byte $6A,%01000010 + !byte $4A,%01100010 + !byte $4A,%10000011; + !byte $27,%10100101 + !byte $28,%11100111 + !byte $23,%00000010 + !byte $6D,%11000011 + !byte $22,%11100001 + !byte $6F,%11100011 + !byte $02,%11101011 + !byte $47,%10100001 + !byte $36,%10110101 + !byte $66,%01100000 + !byte $66,%10000001; + !byte $07,%01011110 + !byte $28,%11000111 + !byte $65,%00100000 + !byte $0D,%00001100 + !byte $3B,%00010100 + !byte $08,%01111100 + !byte $08,%10011101; + !byte $69,%00100010 + !byte $0A,%01111010 + !byte $0A,%10011011; + !byte $3A,%00110100 + !byte $26,%11100011 + !byte $3C,%11110011 + !byte $0B,%00011010 + !byte $0F,%00101100 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $27,%01100100 + !byte $27,%10000101; + !byte $28,%10100111 + !byte $67,%11000001 + !byte $24,%11111111 + !byte $09,%11111011 + !byte $05,%11001011 + !byte $39,%01010100 + !byte $06,%11001011 + !byte $07,%00111110 + !byte $0B,%11101011 + !byte $24,%00100010 + !byte $6E,%11100011 + !byte $3D,%11010011 + !byte $3F,%01010010 + !byte $00,%00001100 + !byte $07,%11001011 + !byte $28,%01100110 + !byte $28,%10000111; + !byte $47,%11000001 + !byte $04,%11001011 + !byte $08,%11001011 + !byte $35,%11010101 + !byte $73,%11000011 + !byte $3E,%10110011 + !byte $38,%01110100 + !byte $38,%10010101; + !byte $48,%00100010 + !byte $6B,%10100011 + !byte $07,%00011110 + !byte $08,%01011100 + !byte $72,%11100011 + !byte $01,%11101011 + !byte $26,%11000011 + !byte $68,%00000010 + !byte $27,%01000100 + !byte $28,%01000110 + !byte $6C,%11000011 + !byte $03,%11001011 + !byte $09,%11011011 + !byte $09,%11001011 + !byte $23,%10111111 + !byte $0A,%01011010 + !byte $6A,%01100010 + !byte $6A,%10000011; + !byte $0C,%11101011 + !byte $6D,%11100011 + !byte $0E,%00001100 + !byte $28,%00100110 + !byte $07,%11111101 + !byte $70,%00000100 + !byte $66,%10100001 + !byte $25,%01000010 + !byte $23,%11100001 + !byte $37,%10110101 + !byte $65,%01000000 + !byte $21,%11000001 + !byte $27,%00100100 + !byte $6F,%00000100 + !byte $47,%11100001 + !byte $02,%11001011 + !byte $69,%01000010 + !byte $08,%00111100 + !byte $28,%00000110 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $0B,%11111001 + !byte $0A,%11001011 + !byte $24,%00000010 + !byte $3C,%00010100 + !byte $3B,%00110100 + !byte $71,%00000100 + !byte $67,%11100001 + !byte $07,%11011101 + !byte $28,%11100101 + !byte $26,%10100011 + !byte $64,%00000000 + !byte $20,%11000001 + !byte $3D,%11110011 + !byte $3A,%01010100 + !byte $46,%00000000 + !byte $00,%11101011 + !byte $6E,%00000100 + !byte $06,%11111111 + !byte $46,%00100000 + !byte $06,%11011111 + !byte $05,%10101011 + !byte $06,%10101011 + !byte $22,%11000001 + !byte $36,%11010101 + !byte $04,%10101011 + !byte $07,%10101011 + !byte $6B,%11000011 + !byte $68,%00100010 + !byte $23,%11011111 + !byte $46,%01000000 + !byte $0D,%11101011 + !byte $06,%10111111 + !byte $27,%00000100 + !byte $39,%01110100 + !byte $39,%10010101; + !byte $09,%10111011 + !byte $0B,%11001011 + !byte $01,%11001011 + !byte $28,%11000101 + !byte $6C,%11100011 + !byte $3E,%11010011 + !byte $08,%10101011 + !byte $25,%00100010 + !byte $6A,%10100011 + !byte $46,%01100000 + !byte $46,%10000001; + !byte $06,%01111110 + !byte $06,%10011111; + !byte $08,%00011100 + !byte $0F,%00001100 + !byte $47,%00000010 + !byte $07,%10111101 + !byte $0A,%00111010 + !byte $03,%10101011 + !byte $26,%01100010 + !byte $26,%10000011; + !byte $66,%11000001 + !byte $28,%10100101 + !byte $06,%01011110 + !byte $0B,%11011001 + !byte $3F,%10110011 + !byte $38,%10110101 + !byte $6D,%00000100 + !byte $27,%11100011 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $69,%01100010 + !byte $69,%10000011; + !byte $67,%00000010 + !byte $29,%10101001 + !byte $29,%11001001 + !byte $72,%00000100 + !byte $46,%10100001 + !byte $09,%10101011 + !byte $29,%01101000 + !byte $29,%10001001; + !byte $35,%11110101 + !byte $07,%01111100 + !byte $07,%10011101; + !byte $02,%10101011 + !byte $70,%00100100 + !byte $0C,%11001011 + !byte $6F,%00100100 + !byte $06,%00111110 + !byte $09,%01111010 + !byte $09,%10011011; + !byte $29,%00101000 + !byte $29,%01001000 + !byte $29,%11101001 + !byte $29,%00001010 + !byte $64,%00100000 + !byte $24,%11100001 + !byte $3C,%00110100 + !byte $23,%11000001 + !byte $3D,%00010100 + !byte $3B,%01010100 + !byte $28,%01100100 + !byte $28,%10000101; + !byte $48,%01000010 + !byte $0E,%11101011 + !byte $29,%00001000 + !byte $08,%11111011 + !byte $0A,%00011010 + !byte $00,%11001011 + !byte $29,%11100111 + !byte $37,%11010101 + !byte $3E,%11110011 + !byte $3A,%01110100 + !byte $3A,%10010101; + !byte $68,%01000010 + !byte $6E,%00100100 + !byte $06,%00011110 + !byte $0A,%10101011 + !byte $29,%11000111 + !byte $27,%11000011 + !byte $25,%00000010 + !byte $26,%01000010 + !byte $07,%01011100 + !byte $29,%10100111 + !byte $71,%00100100 + !byte $73,%11100011 + !byte $6B,%11100011 + !byte $46,%11000001 + !byte $23,%11111111 + !byte $6C,%00000100 + !byte $05,%01101010 + !byte $05,%10001011; + !byte $28,%01000100 + !byte $06,%01101010 + !byte $06,%10001011; + !byte $6A,%11000011 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $01,%10101011 + !byte $04,%01101010 + !byte $04,%10001011; + !byte $29,%01100110 + !byte $29,%10000111; + !byte $39,%10110101 + !byte $66,%11100001 + !byte $06,%11111101 + !byte $3F,%11010011 + !byte $67,%00100010 + !byte $65,%10100001 + !byte $03,%01101010 + !byte $03,%10001011; + !byte $29,%01000110 + !byte $0D,%11001011 + !byte $69,%10100011 + !byte $27,%10100011 + !byte $08,%11011011 + !byte $08,%01101010 + !byte $08,%10001011; + !byte $0B,%10101011 + !byte $28,%00100100 + !byte $6D,%00100100 + !byte $64,%01000000 + !byte $47,%00100010 + !byte $36,%11110101 + !byte $09,%01011010 + !byte $29,%00100110 + !byte $46,%11100001 + !byte $0B,%10111001 + !byte $07,%00111100 + !byte $0F,%11101011 + !byte $02,%01101010 + !byte $02,%10001011; + !byte $26,%00100010 + !byte $29,%00000110 + !byte $38,%11010101 + !byte $06,%11011101 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $24,%11000001 + !byte $68,%01100010 + !byte $68,%10000011; + !byte $28,%00000100 + !byte $6F,%01000100 + !byte $05,%11111111 + !byte $3D,%00110100 + !byte $3C,%01010100 + !byte $63,%00000000 + !byte $05,%11011111 + !byte $0A,%11111001 + !byte $22,%10100001 + !byte $45,%00000000 + !byte $00,%10101011 + !byte $3B,%01110100 + !byte $3B,%10010101; + !byte $70,%01000100 + !byte $45,%00100000 + !byte $25,%11100001 + !byte $05,%10111111 + !byte $08,%10111011 + !byte $29,%11100101 + !byte $6B,%00000100 + !byte $6A,%11100011 + !byte $3E,%00010100 + !byte $6E,%01000100 + !byte $45,%01000000 + !byte $0C,%10101011 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $35,%00010110 + !byte $3A,%10110101 + !byte $06,%10111101 + !byte $0A,%01101010 + !byte $0A,%10001011; + !byte $29,%11000101 + !byte $66,%00000010 + !byte $05,%01111110 + !byte $05,%10011111; + !byte $01,%01101010 + !byte $01,%10001011; + !byte $28,%11100011 + !byte $07,%00011100 + !byte $05,%01001010 + !byte $3F,%11110011 + !byte $6C,%00100100 + !byte $67,%01000010 + !byte $65,%11000001 + !byte $0E,%11001011 + !byte $37,%11110101 + !byte $06,%01001010 + !byte $64,%01100000 + !byte $64,%10000001; + !byte $04,%01001010 + !byte $69,%11000011 + !byte $45,%01100000 + !byte $45,%10000001; + !byte $09,%00111010 + !byte $23,%10100001 + !byte $21,%10100001 + !byte $05,%01011110 + !byte $07,%01001010 + !byte $72,%00100100 + !byte $29,%10100101 + !byte $22,%11011111 + !byte $03,%01001010 + !byte $26,%00000010 + !byte $71,%01000100 + !byte $46,%00000010 + !byte $27,%01000010 + !byte $6D,%01000100 + !byte $06,%01111100 + !byte $06,%10011101; + !byte $68,%10100011 + !byte $39,%11010101 + !byte $05,%00111110 + !byte $08,%01001010 + !byte $0A,%11011001 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $45,%10100001 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $08,%01111010 + !byte $08,%10011011; + !byte $07,%11111011 + !byte $02,%01001010 + !byte $63,%00100000 + !byte $28,%11000011 + !byte $0D,%10101011 + !byte $3D,%01010100 + !byte $6A,%00000100 + !byte $05,%00011110 + !byte $36,%00010110 + !byte $3C,%01110100 + !byte $3C,%10010101; + !byte $6B,%00100100 + !byte $65,%11100001 + !byte $00,%01101010 + !byte $00,%10001011; + !byte $09,%01001010 + !byte $3E,%00110100 + !byte $09,%00011010 + !byte $25,%11000001 + !byte $29,%01000100 + !byte $38,%11110101 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $3B,%10110101 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $24,%10100001 + !byte $6C,%01000100 + !byte $66,%00100010 + !byte $69,%11100011 + !byte $06,%01011100 + !byte $0F,%11001011 + !byte $3F,%00010100 + !byte $6E,%01100100 + !byte $6E,%10000101; + !byte $28,%10100011 + !byte $45,%11000001 + !byte $26,%11100001 + !byte $2A,%11100111 + !byte $01,%01001010 + !byte $27,%00100010 + !byte $2A,%00001000 + !byte $2A,%00101000 + !byte $2A,%01001000 + !byte $2A,%01101000 + !byte $2A,%10001001; + !byte $70,%01100100 + !byte $70,%10000101; + !byte $64,%10100001 + !byte $2A,%10101001 + !byte $05,%11111101 + !byte $05,%00101010 + !byte $29,%00100100 + !byte $2A,%11001001 + !byte $2A,%11000111 + !byte $3A,%11010101 + !byte $04,%00101010 + !byte $06,%00101010 + !byte $22,%11111111 + !byte $0A,%01001010 + !byte $2A,%10100111 + !byte $0C,%01101010 + !byte $0C,%10001011; + !byte $07,%11011011 + !byte $2A,%11101001 + !byte $68,%11000011 + !byte $06,%00111100 + !byte $03,%00101010 + !byte $07,%00101010 + !byte $2A,%01100110 + !byte $2A,%10000111; + !byte $0E,%10101011 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $63,%01000000 + !byte $37,%00010110 + !byte $2A,%01000110 + !byte $05,%11011101 + !byte $08,%01011010 + !byte $28,%01100010 + !byte $28,%10000011; + !byte $29,%00000100 + !byte $2A,%00100110 + !byte $0A,%10111001 + !byte $65,%00000010 + !byte $04,%11111111 + !byte $02,%00101010 + !byte $08,%00101010 + !byte $3E,%01010100 + !byte $2A,%00000110 + !byte $6B,%01000100 + !byte $44,%00000000 + !byte $04,%11011111 + !byte $39,%11110101 + !byte $44,%00100000 + !byte $3D,%01110100 + !byte $3D,%10010101; + !byte $66,%01000010 + !byte $45,%11100001 + !byte $00,%01001010 + !byte $27,%00000010 + !byte $67,%10100011 + !byte $04,%10111111 + !byte $07,%10111011 + !byte $0B,%01001010 + !byte $3F,%00110100 + !byte $6A,%00100100 + !byte $09,%11111001 + !byte $29,%11100011 + !byte $2A,%11100101 + !byte $3C,%10110101 + !byte $25,%10100001 + !byte $05,%10111101 + !byte $69,%00000100 + !byte $64,%11000001 + !byte $62,%00000000 + !byte $44,%01000000 + !byte $47,%01000010 + !byte $46,%00100010 + !byte $04,%01111110 + !byte $04,%10011111; + !byte $06,%00011100 + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $71,%01100100 + !byte $71,%10000101; + !byte $6C,%01100100 + !byte $6C,%10000101; + !byte $26,%11000001 + !byte $09,%00101010 + !byte $3B,%11010101 + !byte $08,%00111010 + !byte $28,%01000010 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $04,%01011110 + !byte $2A,%11000101 + !byte $36,%00110110 + !byte $6F,%10100101 + !byte $6E,%10100101 + !byte $01,%00101010 + !byte $38,%00010110 + !byte $68,%11100011 + !byte $44,%01100000 + !byte $44,%10000001; + !byte $05,%00001010 + !byte $05,%01111100 + !byte $05,%10011101; + !byte $04,%00001010 + !byte $06,%00001010 + !byte $2A,%10100101 + !byte $04,%00111110 + !byte $3A,%11110101 + !byte $29,%11000011 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $72,%01000100 + !byte $03,%00001010 + !byte $0F,%10101011 + !byte $0C,%01001010 + !byte $70,%10100101 + !byte $6D,%10100101 + !byte $0A,%00101010 + !byte $27,%11100001 + !byte $66,%01100010 + !byte $66,%10000011; + !byte $06,%11111011 + !byte $07,%00001010 + !byte $65,%00100010 + !byte $0A,%01111000 + !byte $0A,%10011001; + !byte $07,%01111010 + !byte $07,%10011011; + !byte $28,%00100010 + !byte $2A,%01100100 + !byte $2A,%10000101; + !byte $44,%10100001 + !byte $04,%00011110 + !byte $24,%01100000 + !byte $24,%10000001; + !byte $64,%11100001 + !byte $3E,%01110100 + !byte $3E,%10010101; + !byte $3D,%10110101 + !byte $09,%11011001 + !byte $02,%00001010 + !byte $6A,%01000100 + !byte $3F,%01010100 + !byte $00,%00101010 + !byte $08,%00001010 + !byte $29,%10100011 + !byte $69,%00100100 + !byte $62,%00100000 + !byte $37,%00110110 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $67,%11000011 + !byte $05,%01011100 + !byte $2A,%01000100 + !byte $08,%00011010 + !byte $0E,%01101010 + !byte $0E,%10001011; + !byte $45,%00000010 + !byte $04,%11111101 + !byte $39,%00010110 + !byte $6C,%10100101 + !byte $0B,%00101010 + !byte $26,%10100001 + !byte $3C,%11010101 + !byte $63,%10100001 + !byte $2A,%00100100 + !byte $68,%00000100 + !byte $01,%00001010 + !byte $06,%11011011 + !byte $44,%11000001 + !byte $05,%00111100 + !byte $09,%00001010 + !byte $28,%00000010 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $3B,%11110101 + !byte $66,%10100011 + !byte $0D,%01001010 + !byte $6E,%11000101 + !byte $07,%01011010 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $64,%00000010 + !byte $04,%11101001 + !byte $05,%11101001 + !byte $27,%11000001 + !byte $04,%11011101 + !byte $6F,%11000101 + !byte $65,%01000010 + !byte $06,%11101001 + !byte $03,%11101001 + !byte $2A,%00000100 + !byte $2B,%11000111 + !byte $2B,%11100111 + !byte $38,%00110110 + !byte $6A,%01100100 + !byte $6A,%10000101; + !byte $2B,%00001000 + !byte $09,%10111001 + !byte $62,%01000000 + !byte $6D,%11000101 + !byte $03,%11111111 + !byte $03,%11011111 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $2B,%10100111 + !byte $2B,%00101000 + !byte $2B,%01001000 + !byte $3A,%00010110 + !byte $36,%01010110 + !byte $67,%11100011 + !byte $2B,%01000110 + !byte $43,%00000000 + !byte $04,%10111101 + !byte $07,%11101001 + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $6B,%10100101 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $3E,%10110101 + !byte $03,%10111111 + !byte $2B,%00100110 + !byte $2B,%10101001 + !byte $3F,%01110100 + !byte $3F,%10010101; + !byte $3D,%11010101 + !byte $69,%01000100 + !byte $0C,%00101010 + !byte $43,%00100000 + !byte $02,%11101001 + !byte $0A,%00001010 + !byte $29,%01000010 + !byte $06,%10111011 + !byte $08,%11111001 + !byte $2A,%11100011 + !byte $2B,%11001001 + !byte $05,%00011100 + !byte $00,%00001010 + !byte $63,%11000001 + !byte $03,%01111110 + !byte $03,%10011111; + !byte $2B,%00000110 + !byte $71,%10100101 + !byte $28,%11100001 + !byte $08,%11101001 + !byte $2B,%11100101 + !byte $2B,%11101001 + !byte $6C,%11000101 + !byte $68,%00100100 + !byte $44,%11100001 + !byte $43,%01000000 + !byte $66,%11000011 + !byte $03,%01011110 + !byte $07,%00111010 + !byte $3C,%11110101 + !byte $70,%11000101 + !byte $2A,%11000011 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $01,%11101001 + !byte $2B,%11000101 + !byte $39,%00110110 + !byte $62,%01100000 + !byte $62,%10000001; + !byte $37,%01010110 + !byte $04,%01111100 + !byte $04,%10011101; + !byte $0E,%01001010 + !byte $29,%00100010 + !byte $64,%00100010 + !byte $61,%00000000 + !byte $26,%01100000 + !byte $26,%10000001; + !byte $43,%01100000 + !byte $43,%10000001; + !byte $2B,%10100101 + !byte $03,%00111110 + !byte $0B,%00001010 + !byte $22,%01100000 + !byte $22,%10000001; + !byte $3B,%00010110 + !byte $67,%00000100 + !byte $05,%11111011 + !byte $09,%11101001 + !byte $27,%10100001 + !byte $04,%11001001 + !byte $05,%11001001 + !byte $09,%01111000 + !byte $09,%10011001; + !byte $63,%11100001 + !byte $03,%11001001 + !byte $2A,%10100011 + !byte $6E,%11100101 + !byte $6A,%10100101 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $06,%01111010 + !byte $06,%10011011; + !byte $06,%11001001 + !byte $0D,%00101010 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $03,%00011110 + !byte $04,%01011100 + !byte $6D,%11100101 + !byte $03,%11111101 + !byte $07,%00011010 + !byte $6B,%11000101 + !byte $08,%11011001 + !byte $2B,%01000100 + !byte $3F,%10110101 + !byte $3E,%11010101 + !byte $02,%11001001 + !byte $07,%11001001 + !byte $38,%01010110 + !byte $68,%01000100 + !byte $00,%11101001 + !byte $10,%01101010 + !byte $10,%10001011; + !byte $28,%11000001 + !byte $43,%10100001 + !byte $3D,%11110101 + !byte $6F,%11100101 + !byte $29,%00000010 + !byte $65,%10100011 + !byte $0A,%11101001 + !byte $2A,%01100010 + !byte $2A,%10000011; + !byte $66,%11100011 + !byte $3A,%00110110 + !byte $05,%11011011 + !byte $0C,%00001010 + !byte $2B,%00100100 + !byte $6C,%11100101 + !byte $08,%11001001 + !byte $0F,%01001010 + !byte $36,%01110110 + !byte $36,%10010111; + !byte $64,%01000010 + !byte $61,%00100000 + !byte $67,%00100100 + !byte $62,%10100001 + !byte $01,%11001001 + !byte $63,%00000010 + !byte $03,%11011101 + !byte $06,%01011010 + !byte $04,%00111100 + !byte $3C,%00010110 + !byte $2B,%00000100 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $25,%01000000 + !byte $6A,%11000101 + !byte $45,%00100010 + !byte $2A,%01000010 + !byte $39,%01010110 + !byte $69,%10100101 + !byte $0E,%00101010 + !byte $24,%01000000 + !byte $3B,%00110110 + !byte $02,%11111111 + !byte $02,%11011111 + !byte $04,%10101001 + !byte $05,%10101001 + !byte $0B,%11101001 + !byte $29,%11100001 + !byte $43,%11000001 + !byte $09,%11001001 + !byte $03,%10111101 + !byte $03,%10101001 + !byte $06,%10101001 + !byte $04,%00011100 + !byte $09,%01011000 + !byte $6B,%11100101 + !byte $44,%00000010 + !byte $42,%00000000 + !byte $07,%11111001 + !byte $2B,%11100011 + !byte $68,%01100100 + !byte $68,%10000101; + !byte $65,%11000011 + !byte $02,%10111111 + !byte $08,%10111001 + !byte $61,%01000000 + !byte $28,%10100001 + !byte $37,%01110110 + !byte $37,%10010111; + !byte $3F,%11010101 + !byte $02,%01111110 + !byte $02,%10011111; + !byte $05,%10111011 + !byte $3E,%11110101 + !byte $02,%10101001 + !byte $0D,%00001010 + !byte $66,%00000100 + !byte $2C,%10100111 + !byte $70,%11100101 + !byte $64,%01100010 + !byte $64,%10000011; + !byte $2C,%11000111 + !byte $62,%11000001 + !byte $42,%00100000 + !byte $2C,%00100110 + !byte $2C,%01000110 + !byte $6E,%00000110 + !byte $6D,%00000110 + !byte $07,%10101001 + !byte $2A,%00100010 + !byte $2C,%01100110 + !byte $2C,%10000111; + !byte $3D,%00010110 + !byte $00,%11001001 + !byte $2B,%11000011 + !byte $2C,%11100111 + !byte $2C,%00001000 + !byte $02,%01011110 + !byte $06,%00111010 + !byte $26,%01000000 + !byte $2C,%00000110 + !byte $03,%01111100 + !byte $03,%10011101; + !byte $2C,%00101000 + !byte $2C,%01001000 + !byte $42,%01000000 + !byte $0A,%11001001 + !byte $67,%01000100 + !byte $63,%00100010 + !byte $02,%00111110 + !byte $0C,%11101001 + !byte $2C,%11100101 + !byte $6C,%00000110 + !byte $3A,%01010110 + !byte $04,%11111011 + !byte $29,%11000001 + !byte $2C,%11000101 + !byte $2C,%01101000 + !byte $2C,%10001001; + !byte $38,%01110110 + !byte $38,%10010111; + !byte $6F,%00000110 + !byte $01,%10101001 + !byte $08,%10101001 + !byte $10,%01001010 + !byte $2B,%10100011 + !byte $2C,%10101001 + !byte $05,%01111010 + !byte $05,%10011011; + !byte $65,%11100011 + !byte $2C,%10100101 + !byte $3C,%00110110 + !byte $02,%00011110 + !byte $08,%01111000 + !byte $08,%10011001; + !byte $69,%11000101 + !byte $62,%11100001 + !byte $0F,%00101010 + !byte $6A,%11100101 + !byte $42,%01100000 + !byte $42,%10000001; + !byte $03,%01011100 + !byte $2C,%11001001 + !byte $64,%10100011 + !byte $61,%01100000 + !byte $61,%10000001; + !byte $2A,%00000010 + !byte $2C,%01100100 + !byte $2C,%10000101; + !byte $71,%11000101 + !byte $05,%01101000 + !byte $05,%10001001; + !byte $66,%00100100 + !byte $06,%00011010 + !byte $04,%01101000 + !byte $04,%10001001; + !byte $36,%10110111 + !byte $6B,%00000110 + !byte $68,%10100101 + !byte $07,%11011001 + !byte $02,%11111101 + !byte $09,%10101001 + !byte $3F,%11110101 + !byte $43,%11100001 + !byte $03,%01101000 + !byte $03,%10001001; + !byte $06,%01101000 + !byte $06,%10001001; + !byte $39,%01110110 + !byte $39,%10010111; + !byte $0B,%11001001 + !byte $28,%01100000 + !byte $28,%10000001; + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $2C,%11101001 + !byte $3E,%00010110 + !byte $0E,%00001010 + !byte $27,%01000000 + !byte $2C,%01000100 + !byte $3B,%01010110 + !byte $02,%01101000 + !byte $02,%10001001; + !byte $00,%10101001 + !byte $63,%01000010 + !byte $04,%11011011 + !byte $02,%11011101 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $07,%01101000 + !byte $07,%10001001; + !byte $2C,%00100100 + !byte $03,%00111100 + !byte $37,%10110111 + !byte $6D,%00100110 + !byte $0D,%11101001 + !byte $05,%01011010 + !byte $42,%10100001 + !byte $29,%10100001 + !byte $2A,%11100001 + !byte $2B,%01000010 + !byte $3D,%00110110 + !byte $61,%10100001 + !byte $0A,%10101001 + !byte $64,%11000011 + !byte $65,%00000100 + !byte $6E,%00100110 + !byte $69,%11100101 + !byte $2C,%00000100 + !byte $08,%01101000 + !byte $08,%10001001; + !byte $3A,%01110110 + !byte $3A,%10010111; + !byte $6C,%00100110 + !byte $62,%00000010 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $6A,%00000110 + !byte $66,%01000100 + !byte $60,%00100000 + !byte $68,%11000101 + !byte $02,%10111101 + !byte $03,%00011100 + !byte $0C,%11001001 + !byte $3C,%01010110 + !byte $06,%11111001 + !byte $08,%01011000 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $2B,%00100010 + !byte $01,%11111111 + !byte $01,%11011111 + !byte $01,%10111111 + !byte $2C,%11100011 + !byte $04,%10111011 + !byte $07,%10111001 + !byte $04,%01001000 + !byte $10,%00101010 + !byte $38,%10110111 + !byte $01,%01111110 + !byte $01,%10011111; + !byte $05,%01001000 + !byte $0F,%00001010 + !byte $6B,%00100110 + !byte $67,%10100101 + !byte $41,%00000000 + !byte $03,%01001000 + !byte $3F,%00010110 + !byte $2A,%11000001 + !byte $02,%01111100 + !byte $02,%10011101; + !byte $2C,%11000011 + !byte $01,%01011110 + !byte $05,%00111010 + !byte $0B,%10101001 + !byte $41,%00100000 + !byte $06,%01001000 + !byte $09,%01101000 + !byte $09,%10001001; + !byte $28,%01000000 + !byte $3E,%00110110 + !byte $61,%11000001 + !byte $00,%01101000 + !byte $00,%10001001; + !byte $02,%01001000 + !byte $62,%00100010 + !byte $64,%11100011 + !byte $03,%11111011 + !byte $01,%00111110 + !byte $0E,%11101001 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $2D,%01000110 + !byte $6F,%00100110 + !byte $65,%00100100 + !byte $42,%11000001 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $3B,%01110110 + !byte $3B,%10010111; + !byte $07,%01001000 + !byte $2D,%00000110 + !byte $2D,%00100110 + !byte $63,%10100011 + !byte $04,%01111010 + !byte $04,%10011011; + !byte $2B,%00000010 + !byte $2D,%10100111 + !byte $2D,%11000111 + !byte $39,%10110111 + !byte $66,%01100100 + !byte $66,%10000101; + !byte $2C,%10100011 + !byte $60,%01000000 + !byte $70,%00000110 + !byte $2D,%11100101 + !byte $3D,%01010110 + !byte $68,%11100101 + !byte $69,%00000110 + !byte $41,%01000000 + !byte $2D,%11100111 + !byte $01,%00011110 + !byte $2D,%11000101 + !byte $02,%01011100 + !byte $01,%01001000 + !byte $0D,%11001001 + !byte $2D,%00001000 + !byte $6A,%00100110 + !byte $06,%11011001 + !byte $0A,%01101000 + !byte $0A,%10001001; + !byte $2D,%00101000 + !byte $6D,%01000110 + !byte $05,%00011010 + !byte $08,%01001000 + !byte $6C,%01000110 + !byte $2C,%01100010 + !byte $2C,%10000011; + !byte $2D,%10100101 + !byte $37,%11010111 + !byte $08,%00111000 + !byte $01,%11111101 + !byte $07,%01111000 + !byte $07,%10011001; + !byte $67,%11000101 + !byte $2A,%10100001 + !byte $2D,%01001000 + !byte $3C,%01110110 + !byte $3C,%10010111; + !byte $0C,%10101001 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $62,%01000010 + !byte $61,%11100001 + !byte $04,%00101000 + !byte $3A,%10110111 + !byte $26,%00100000 + !byte $3F,%00110110 + !byte $60,%01100000 + !byte $60,%10000001; + !byte $03,%11011011 + !byte $2B,%11100001 + !byte $2D,%01000100 + !byte $02,%00111100 + !byte $03,%00101000 + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $6E,%01000110 + !byte $01,%11011101 + !byte $05,%00101000 + !byte $6B,%01000110 + !byte $41,%01100000 + !byte $41,%10000001; + !byte $04,%01011010 + !byte $2C,%01000010 + !byte $65,%01000100 + !byte $64,%00000100 + !byte $2D,%10101001 + !byte $27,%00100000 + !byte $10,%00001010 + !byte $3E,%01010110 + !byte $38,%11010111 + !byte $06,%00101000 + !byte $09,%01001000 + !byte $2D,%00100100 + !byte $63,%11000011 + !byte $00,%01001000 + !byte $02,%00101000 + !byte $66,%10100101 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $0F,%11101001 + !byte $2D,%00000100 + !byte $69,%00100110 + !byte $02,%00011100 + !byte $0E,%11001001 + !byte $2D,%11001001 + !byte $68,%00000110 + !byte $06,%10111001 + !byte $07,%00101000 + !byte $29,%01000000 + !byte $01,%10111101 + !byte $3B,%10110111 + !byte $61,%00000010 + !byte $05,%11111001 + !byte $2C,%00100010 + !byte $2D,%11100011 + !byte $62,%01100010 + !byte $62,%10000011; + !byte $3D,%01110110 + !byte $3D,%10010111; + !byte $03,%10111011 + !byte $2B,%11000001 + !byte $2A,%01100000 + !byte $2A,%10000001; + !byte $01,%00101000 + !byte $39,%11010111 + !byte $2D,%11101001 + !byte $6A,%01000110 + !byte $67,%11100101 + !byte $0D,%10101001 + !byte $60,%10100001 + !byte $00,%11011111 + !byte $00,%10111111 + !byte $00,%01111110 + !byte $00,%10011111; + !byte $65,%01100100 + !byte $65,%10000101; + !byte $01,%01111100 + !byte $01,%10011101; + !byte $07,%01011000 + !byte $08,%00101000 + !byte $04,%00111010 + !byte $64,%00100100 + !byte $0A,%01001000 + !byte $28,%00100000 + !byte $2D,%11000011 + !byte $00,%11111111 + !byte $3F,%01010110 + !byte $6C,%01100110 + !byte $6C,%10000111; + !byte $00,%01011110 + !byte $41,%10100001 + !byte $02,%11111011 + !byte $03,%00001000 + !byte $0C,%01101000 + !byte $0C,%10001001; + !byte $2C,%00000010 + !byte $66,%11000101 + !byte $40,%00000000 + !byte $04,%00001000 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $63,%11100011 + !byte $3C,%10110111 + !byte $61,%00100010 + !byte $03,%01111010 + !byte $03,%10011011; + !byte $05,%00001000 + !byte $2D,%10100011 + !byte $00,%00111110 + !byte $06,%00001000 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $00,%00101000 + !byte $3A,%11010111 + !byte $37,%11110111 + !byte $02,%00001000 + !byte $09,%00101000 + !byte $69,%01000110 + !byte $60,%11000001 + !byte $2B,%10100001 + !byte $3E,%01110110 + !byte $3E,%10010111; + !byte $40,%00100000 + !byte $01,%01011100 + !byte $00,%00011110 + !byte $62,%10100011 + !byte $06,%01111000 + !byte $06,%10011001; + !byte $68,%00100110 + !byte $67,%00000110 + !byte $05,%11011001 + !byte $10,%11101001 + !byte $2E,%00100110 + !byte $00,%11111101 + !byte $04,%00011010 + !byte $0B,%01001000 + !byte $64,%01000100 + !byte $6F,%01000110 + !byte $2E,%11100101 + !byte $2E,%00000110 + !byte $65,%10100101 + !byte $07,%00001000 + !byte $2C,%11100001 + !byte $2E,%01000110 + !byte $2E,%01100110 + !byte $2E,%10000111; + !byte $38,%11110111 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $63,%00000100 + !byte $2E,%11000101 + !byte $01,%00001000 + !byte $3D,%10110111 + !byte $42,%11100001 + !byte $02,%11011011 + !byte $0E,%10101001 + !byte $0F,%11001001 + !byte $2E,%10100101 + !byte $2E,%10100111 + !byte $6E,%01100110 + !byte $6E,%10000111; + !byte $6A,%01100110 + !byte $6A,%10000111; + !byte $07,%00111000 + !byte $2E,%11100111 + !byte $2A,%01000000 + !byte $3B,%11010111 + !byte $2E,%11000111 + !byte $01,%00111100 + !byte $40,%01000000 + !byte $00,%11011101 + !byte $03,%01011010 + !byte $2D,%01000010 + !byte $2E,%01100100 + !byte $2E,%10000101; + !byte $66,%11100101 + !byte $29,%00100000 + !byte $2E,%00001000 + !byte $61,%01000010 + !byte $0A,%00101000 + !byte $2E,%01000100 + !byte $60,%11100001 + !byte $08,%00001000 + !byte $62,%11000011 + !byte $39,%11110111 + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $3F,%01110110 + !byte $3F,%10010111; + !byte $05,%11100111 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $2E,%00101000 + !byte $03,%11100111 + !byte $04,%11100111 + !byte $2E,%00100100 + !byte $01,%00011100 + !byte $05,%10111001 + !byte $0C,%01001000 + !byte $2E,%00000100 + !byte $64,%01100100 + !byte $64,%10000101; + !byte $2C,%11000001 + !byte $2D,%00100010 + !byte $3C,%11010111 + !byte $68,%01000110 + !byte $00,%10111101 + !byte $2E,%01001000 + !byte $6C,%10100111 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $63,%00100100 + !byte $02,%11100111 + !byte $06,%11100111 + !byte $04,%11111001 + !byte $00,%00001000 + !byte $02,%10111011 + !byte $06,%01011000 + !byte $65,%11000101 + !byte $3E,%10110111 + !byte $09,%00001000 + !byte $3A,%11110111 + !byte $6B,%10100111 + !byte $67,%00100110 + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $2E,%11100011 + !byte $2E,%01101000 + !byte $2E,%10001001; + !byte $61,%01100010 + !byte $61,%10000011; + !byte $40,%01100000 + !byte $40,%10000001; + !byte $0B,%00101000 + !byte $6D,%10100111 + !byte $00,%01111100 + !byte $00,%10011101; + !byte $62,%11100011 + !byte $03,%00111010 + !byte $41,%11000001 + !byte $07,%11100111 + !byte $2E,%11000011 + !byte $37,%00011000 + !byte $66,%00000110 + !byte $60,%00000010 + !byte $01,%11111011 + !byte $07,%00011000 + !byte $2D,%00000010 + !byte $10,%11001001 + !byte $2E,%10101001 + !byte $01,%11100111 + !byte $6A,%10100111 + !byte $0F,%10101001 + !byte $2C,%10100001 + !byte $3D,%11010111 + !byte $5F,%10100001 + !byte $0E,%01101000 + !byte $0E,%10001001; + !byte $3B,%11110111 + !byte $38,%00011000 + !byte $02,%01111010 + !byte $02,%10011011; + !byte $2E,%10100011 + !byte $2E,%11001001 + !byte $08,%11100111 + !byte $2A,%00100000 + !byte $2B,%01000000 + !byte $65,%11100101 + !byte $00,%01011100 + !byte $0A,%00001000 + !byte $64,%10100101 + !byte $04,%11000111 + !byte $61,%10100011 + !byte $3F,%10110111 + !byte $63,%01000100 + !byte $60,%00100010 + !byte $03,%11000111 + !byte $05,%11000111 + !byte $2D,%11100001 + !byte $2E,%01100010 + !byte $2E,%10000011; + !byte $67,%01000110 + !byte $05,%01111000 + !byte $05,%10011001; + !byte $0D,%01001000 + !byte $68,%01100110 + !byte $68,%10000111; + !byte $04,%11011001 + !byte $69,%10100111 + !byte $03,%00011010 + !byte $06,%00111000 + !byte $62,%00000100 + !byte $2E,%11101001 + !byte $39,%00011000 + !byte $00,%11100111 + !byte $02,%11000111 + !byte $06,%11000111 + !byte $66,%00100110 + !byte $0C,%00101000 + !byte $01,%11011011 + !byte $09,%11100111 + !byte $3E,%11010111 + !byte $3C,%11110111 + !byte $00,%00111100 + !byte $5F,%11000001 + !byte $02,%01011010 + !byte $07,%11000111 + !byte $2F,%11000101 + !byte $2F,%11100101 + !byte $2F,%00000110 + !byte $6C,%11000111 + !byte $6B,%11000111 + !byte $2F,%00100110 + !byte $2F,%01000110 + !byte $2C,%01100000 + !byte $2C,%10000001; + !byte $2E,%01000010 + !byte $2F,%10100101 + !byte $64,%11000101 + !byte $01,%11000111 + !byte $0B,%00001000 + !byte $2D,%11000001 + !byte $3A,%00011000 + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $07,%11110111 + !byte $61,%11000011 + !byte $60,%01000010 + !byte $2F,%10100111 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $2F,%11000111 + !byte $3D,%11110111 + !byte $00,%00011100 + !byte $6A,%11000111 + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $2F,%01000100 + !byte $65,%00000110 + !byte $01,%10111011 + !byte $28,%00000000 + !byte $37,%00111000 + !byte $10,%10101001 + !byte $2E,%00100010 + !byte $2F,%00100100 + !byte $67,%01100110 + !byte $67,%10000111; + !byte $62,%00100100 + !byte $2F,%11100111 + !byte $5F,%11100001 + !byte $04,%10111001 + !byte $08,%11000111 + !byte $0E,%01001000 + !byte $2F,%00000100 + !byte $3F,%11010111 + !byte $40,%10100001 + !byte $03,%11111001 + !byte $6E,%10100111 + !byte $68,%10100111 + !byte $0A,%11100111 + !byte $03,%10100111 + !byte $04,%10100111 + !byte $3B,%00011000 + !byte $2F,%00001000 + !byte $05,%10100111 + !byte $29,%00000000 + !byte $05,%01011000 + !byte $0D,%00101000 + !byte $38,%00111000 + !byte $2F,%11100011 + !byte $66,%01000110 + !byte $02,%00111010 + !byte $6D,%11000111 + !byte $02,%10100111 + !byte $06,%10100111 + !byte $69,%11000111 + !byte $00,%11000111 + !byte $00,%11111011 + !byte $06,%00011000 + !byte $2B,%00100000 + !byte $63,%10100101 + !byte $0C,%00001000 + !byte $2D,%10100001 + !byte $2E,%00000010 + !byte $61,%11100011 + !byte $2F,%00101000 + !byte $64,%11100101 + !byte $60,%01100010 + !byte $60,%10000011; + !byte $2F,%11000011 + !byte $09,%11000111 + !byte $01,%01111010 + !byte $01,%10011011; + !byte $2C,%01000000 + !byte $3E,%11110111 + !byte $3C,%00011000 + !byte $65,%00100110 + !byte $62,%01000100 + !byte $2F,%01001000 + !byte $39,%00111000 + !byte $07,%10100111 + !byte $2F,%10100011 + !byte $2E,%11100001 + !byte $5F,%00000010 + !byte $01,%10100111 + !byte $0B,%11100111 + !byte $6B,%11100111 + !byte $03,%11011001 + !byte $2A,%00000000 + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $00,%11011011 + !byte $04,%01111000 + !byte $04,%10011001; + !byte $6A,%11100111 + !byte $67,%10100111 + !byte $02,%00011010 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $3A,%00111000 + !byte $61,%00000100 + !byte $60,%10100011 + !byte $66,%01100110 + !byte $66,%10000111; + !byte $63,%11000101 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $68,%11000111 + !byte $10,%01101000 + !byte $10,%10001001; + !byte $05,%00111000 + !byte $0F,%01001000 + !byte $3F,%11110111 + !byte $3D,%00011000 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $04,%01100110 + !byte $04,%10000111; + !byte $08,%10100111 + !byte $0A,%11000111 + !byte $2F,%10101001 + !byte $5E,%10100001 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $11,%10101001 + !byte $01,%01011010 + !byte $6C,%11100111 + !byte $64,%00000110 + !byte $62,%01100100 + !byte $62,%10000101; + !byte $5F,%00100010 + !byte $0E,%00101000 + !byte $2F,%11001001 + !byte $2E,%11000001 + !byte $0D,%00001000 + !byte $2F,%01000010 + !byte $3B,%00111000 + !byte $06,%01100110 + !byte $06,%10000111; + !byte $69,%11100111 + !byte $65,%01000110 + !byte $02,%01100110 + !byte $02,%10000111; + !byte $37,%01011000 + !byte $00,%10100111 + !byte $06,%11110111 + !byte $00,%10111011 + !byte $30,%11000101 + !byte $09,%10100111 + !byte $0C,%11100111 + !byte $2C,%00100000 + !byte $30,%11100101 + !byte $3E,%00011000 + !byte $61,%00100100 + !byte $60,%11000011 + !byte $03,%10111001 + !byte $30,%10100101 + !byte $30,%01100100 + !byte $30,%10000101; + !byte $2F,%11101001 + !byte $38,%01011000 + !byte $04,%01011000 + !byte $30,%00000110 + !byte $30,%00100110 + !byte $2F,%00100010 + !byte $02,%11111001 + !byte $30,%01000100 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $3C,%00111000 + !byte $5F,%01000010 + !byte $01,%01100110 + !byte $01,%10000111; + !byte $30,%01000110 + !byte $5E,%11000001 + !byte $64,%00100110 + !byte $0B,%11000111 + !byte $30,%01100110 + !byte $30,%10000111; + !byte $67,%11000111 + !byte $66,%10100111 + !byte $01,%00111010 + !byte $30,%00100100 + !byte $63,%11100101 + !byte $2D,%01000000 + !byte $30,%10100111 + !byte $2B,%00000000 + !byte $2E,%10100001 + !byte $30,%00000100 + !byte $39,%01011000 + !byte $05,%00011000 + !byte $30,%11000111 + !byte $68,%11100111 + !byte $62,%10100101 + !byte $2F,%00000010 + !byte $00,%01111010 + !byte $00,%10011011; + !byte $04,%01000110 + !byte $0A,%10100111 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $30,%11100011 + !byte $08,%01100110 + !byte $08,%10000111; + !byte $03,%01000110 + !byte $05,%01000110 + !byte $3F,%00011000 + !byte $3A,%01011000 + !byte $0E,%00001000 + !byte $5E,%11100001 + !byte $3D,%00111000 + !byte $60,%11100011 + !byte $30,%11100111 + !byte $10,%01001000 + !byte $30,%11000011 + !byte $03,%01111000 + !byte $03,%10011001; + !byte $02,%11011001 + !byte $61,%01000100 + !byte $00,%01100110 + !byte $00,%10000111; + !byte $0D,%11100111 + !byte $0F,%00101000 + !byte $02,%01000110 + !byte $06,%01000110 + !byte $30,%00001000 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $06,%11010111 + !byte $2F,%11100001 + !byte $01,%00011010 + !byte $63,%00000110 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $04,%00111000 + !byte $30,%10100011 + !byte $3B,%01011000 + !byte $62,%11000101 + !byte $64,%01000110 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $0C,%11000111 + !byte $30,%00101000 + !byte $2E,%01100000 + !byte $2E,%10000001; + !byte $07,%01000110 + !byte $6D,%11100111 + !byte $67,%11100111 + !byte $3E,%00111000 + !byte $00,%01011010 + !byte $66,%11000111 + !byte $60,%00000100 + !byte $01,%01000110 + !byte $37,%01111000 + !byte $37,%10011001; + !byte $30,%01100010 + !byte $30,%10000011; + !byte $30,%01001000 + !byte $61,%01100100 + !byte $61,%10000101; + !byte $5E,%00000010 + !byte $3C,%01011000 + !byte $5F,%10100011 + !byte $05,%11110111 + !byte $0B,%10100111 + !byte $2D,%00100000 + !byte $38,%01111000 + !byte $38,%10011001; + !byte $65,%10100111 + !byte $2F,%11000001 + !byte $02,%10111001 + !byte $08,%01000110 + !byte $30,%01000010 + !byte $01,%11111001 + !byte $03,%00100110 + !byte $2C,%00000000 + !byte $30,%01101000 + !byte $30,%10001001; + !byte $62,%11100101 + !byte $04,%00100110 + !byte $0A,%01100110 + !byte $0A,%10000111; + !byte $39,%01111000 + !byte $39,%10011001; + !byte $63,%00100110 + !byte $05,%00100110 + !byte $3F,%00111000 + !byte $64,%01100110 + !byte $64,%10000111; + !byte $03,%01011000 + !byte $60,%00100100 + !byte $0F,%00001000 + !byte $5E,%00100010 + !byte $00,%00111010 + !byte $02,%00100110 + !byte $0E,%11100111 + !byte $30,%00100010 + !byte $3D,%01011000 + !byte $06,%00100110 + !byte $3A,%01111000 + !byte $3A,%10011001; + !byte $61,%10100101 + !byte $30,%10101001 + !byte $10,%00101000 + !byte $2E,%01000000 + !byte $31,%01100100 + !byte $31,%10000101; + !byte $31,%10100101 + !byte $0D,%11000111 + !byte $11,%01001000 + !byte $31,%11000101 + !byte $00,%01000110 + !byte $2F,%10100001 + !byte $31,%11100101 + !byte $5F,%11000011 + !byte $09,%01000110 + !byte $31,%01000100 + !byte $31,%00000110 + !byte $04,%00011000 + !byte $66,%11100111 + !byte $0C,%10100111 + !byte $31,%00100100 + !byte $3E,%01011000 + !byte $07,%00100110 + !byte $30,%11001001 + !byte $31,%00100110 + !byte $30,%00000010 + !byte $31,%00000100 + !byte $31,%01000110 + !byte $01,%11011001 + !byte $01,%00100110 + !byte $3B,%01111000 + !byte $3B,%10011001; + !byte $65,%11000111 + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $31,%01100110 + !byte $31,%10000111; + !byte $63,%01000110 + !byte $00,%00011010 + !byte $31,%11100011 + !byte $5E,%01000010 + !byte $62,%00000110 + !byte $02,%01111000 + !byte $02,%10011001; + !byte $08,%00100110 + !byte $3C,%01111000 + !byte $3C,%10011001; + !byte $5D,%11000001 + !byte $31,%10100111 + !byte $60,%01000100 + !byte $31,%11000011 + !byte $5F,%11100011 + !byte $04,%00000110 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $30,%11100001 + !byte $64,%10100111 + !byte $03,%00000110 + !byte $30,%11101001 + !byte $05,%11010111 + !byte $37,%10111001 + !byte $05,%00000110 + !byte $31,%11000111 + !byte $61,%11000101 + !byte $0A,%01000110 + !byte $31,%10100011 + !byte $3F,%01011000 + !byte $03,%00111000 + !byte $38,%10111001 + !byte $2D,%00000000 + !byte $06,%00000110 + !byte $02,%00000110 + !byte $2E,%00100000 + !byte $31,%11100111 + !byte $5E,%01100010 + !byte $5E,%10000011; + !byte $0E,%11000111 + !byte $63,%01100110 + !byte $63,%10000111; + !byte $0F,%11100111 + !byte $39,%10111001 + !byte $04,%11110111 + !byte $10,%00001000 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $3D,%01111000 + !byte $3D,%10011001; + !byte $65,%11100111 + !byte $00,%00100110 + !byte $60,%01100100 + !byte $60,%10000101; + !byte $5D,%11100001 + !byte $30,%11000001 + !byte $5F,%00000100 + !byte $62,%00100110 + !byte $31,%00001000 + !byte $3A,%10111001 + !byte $09,%00100110 + !byte $0C,%01100110 + !byte $0C,%10000111; + !byte $0D,%10100111 + !byte $00,%11111001 + !byte $61,%11100101 + !byte $01,%10111001 + !byte $07,%00000110 + !byte $31,%01000010 + !byte $11,%00101000 + !byte $02,%01011000 + !byte $31,%00101000 + !byte $3E,%01111000 + !byte $3E,%10011001; + !byte $5E,%10100011 + !byte $64,%11000111 + !byte $01,%00000110 + !byte $0B,%01000110 + !byte $3B,%10111001 + !byte $2F,%01000000 + !byte $03,%00011000 + !byte $05,%10110111 + !byte $5F,%00100100 + !byte $31,%00100010 + !byte $5D,%00000010 + !byte $60,%10100101 + !byte $04,%11100101 + !byte $08,%00000110 + !byte $31,%01001000 + !byte $62,%01000110 + !byte $30,%10100001 + !byte $03,%11100101 + !byte $3C,%10111001 + !byte $05,%11100101 + !byte $0A,%00100110 + !byte $63,%10100111 + !byte $61,%00000110 + !byte $31,%00000010 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $06,%11100101 + !byte $3F,%01111000 + !byte $3F,%10011001; + !byte $04,%11010111 + !byte $02,%11100101 + !byte $32,%01000100 + !byte $00,%11011001 + !byte $32,%01100100 + !byte $32,%10000101; + !byte $32,%10100101 + !byte $5E,%11000011 + !byte $32,%11000101 + !byte $32,%11100101 + !byte $01,%01111000 + !byte $01,%10011001; + !byte $32,%00100100 + !byte $32,%00000110 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $3D,%10111001 + !byte $5D,%00100010 + !byte $0E,%10100111 + !byte $64,%11100111 + !byte $02,%00111000 + !byte $09,%00000110 + !byte $0C,%01000110 + !byte $10,%11100111 + !byte $32,%00000100 + !byte $32,%00100110 + !byte $38,%11011001 + !byte $07,%11100101 + !byte $00,%00000110 + !byte $0F,%11000111 + !byte $31,%10101001 + !byte $2E,%00000000 + !byte $30,%01100000 + !byte $30,%10000001; + !byte $31,%11100001 + !byte $32,%11100011 + !byte $5F,%01000100 + !byte $11,%00001000 + !byte $32,%01000110 + !byte $39,%11011001 + !byte $60,%11000101 + !byte $32,%11000011 + !byte $3E,%10111001 + !byte $3A,%11011001 + !byte $5E,%11100011 + !byte $01,%11100101 + !byte $32,%01100110 + !byte $32,%10000111; + !byte $62,%01100110 + !byte $62,%10000111; + !byte $0B,%00100110 + !byte $2F,%00100000 + !byte $5D,%01000010 + !byte $03,%11110111 + !byte $32,%10100011 + !byte $63,%11000111 + !byte $61,%00100110 + !byte $04,%11000101 + !byte $3B,%11011001 + !byte $05,%01110110 + !byte $05,%10010111; + !byte $08,%11100101 + !byte $32,%10100111 + !byte $31,%11001001 + !byte $05,%11000101 + !byte $03,%11000101 + !byte $31,%11000001 + !byte $01,%01011000 + !byte $32,%01100010 + !byte $32,%10000011; + !byte $00,%10111001 + !byte $0A,%00000110 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $06,%11000101 + !byte $31,%11101001 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $3F,%10111001 + !byte $32,%11000111 + !byte $60,%11100101 + !byte $5E,%00000100 + !byte $3C,%11011001 + !byte $0E,%01100110 + !byte $0E,%10000111; + !byte $62,%10100111 + !byte $02,%11000101 + !byte $32,%01000010 + !byte $32,%11100111 + !byte $02,%00011000 + !byte $09,%11100101 + !byte $0F,%10100111 + !byte $30,%01000000 + !byte $04,%10110111 + !byte $07,%11000101 + !byte $0D,%01000110 + !byte $61,%01000110 + !byte $3D,%11011001 + !byte $00,%11100101 + !byte $0C,%00100110 + !byte $32,%00001000 + !byte $5F,%10100101 + !byte $10,%11000111 + !byte $31,%10100001 + !byte $63,%11100111 + !byte $32,%00100010 + !byte $00,%01111000 + !byte $00,%10011001; + !byte $60,%00000110 + !byte $5C,%11100001 + !byte $01,%11000101 + !byte $03,%11010111 + !byte $0B,%00000110 + !byte $38,%11111001 + !byte $5D,%10100011 + !byte $32,%00101000 + !byte $5E,%00100100 + !byte $11,%11100111 + !byte $04,%10100101 + !byte $08,%11000101 + !byte $32,%00000010 + !byte $3E,%11011001 + !byte $39,%11111001 + !byte $05,%10100101 + !byte $3A,%11111001 + !byte $03,%10100101 + !byte $0A,%11100101 + !byte $2F,%00000000 + !byte $5C,%00000010 + !byte $01,%00111000 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $32,%01001000 + !byte $62,%11000111 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $33,%11000101 + !byte $5F,%11000101 + !byte $33,%00100100 + !byte $33,%01000100 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $3B,%11111001 + !byte $06,%10100101 + !byte $33,%10100101 + !byte $5D,%11000011 + !byte $33,%00000100 + !byte $33,%11100101 + !byte $60,%00100110 + !byte $3F,%11011001 + !byte $02,%11110111 + !byte $04,%01110110 + !byte $04,%10010111; + !byte $32,%11100001 + !byte $5E,%01000100 + !byte $02,%10100101 + !byte $33,%11100011 + !byte $33,%00000110 + !byte $30,%00100000 + !byte $07,%10100101 + !byte $33,%11000011 + !byte $3C,%11111001 + !byte $0E,%01000110 + !byte $33,%00100110 + !byte $09,%11000101 + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $0D,%00100110 + !byte $10,%10100111 + !byte $5C,%00100010 + !byte $32,%01101000 + !byte $32,%10001001; + !byte $33,%10100011 + !byte $32,%11000001 + !byte $33,%01000110 + !byte $3D,%11111001 + !byte $5D,%11100011 + !byte $00,%01011000 + !byte $0C,%00000110 + !byte $11,%11000111 + !byte $61,%10100111 + !byte $03,%10110111 + !byte $00,%11000101 + !byte $0B,%11100101 + !byte $5F,%11100101 + !byte $01,%00011000 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $32,%10101001 + !byte $5E,%01100100 + !byte $5E,%10000101; + !byte $33,%01100110 + !byte $33,%10000111; + !byte $62,%11100111 + !byte $01,%10100101 + !byte $08,%10100101 + !byte $31,%01000000 + !byte $3E,%11111001 + !byte $5C,%01000010 + !byte $60,%01000110 + !byte $33,%01000010 + !byte $33,%10100111 + !byte $04,%01100100 + !byte $04,%10000101; + !byte $05,%01100100 + !byte $05,%10000101; + !byte $0A,%11000101 + !byte $38,%00011010 + !byte $03,%01100100 + !byte $03,%10000101; + !byte $12,%11100111 + !byte $06,%01100100 + !byte $06,%10000101; + !byte $32,%11001001 + !byte $39,%00011010 + !byte $32,%10100001 + !byte $33,%11000111 + !byte $33,%00100010 + !byte $3A,%00011010 + !byte $02,%11010111 + !byte $5D,%00000100 + !byte $5F,%00000110 + !byte $00,%00111000 + !byte $61,%11000111 + !byte $02,%01100100 + !byte $02,%10000101; + !byte $3F,%11111001 + !byte $3B,%00011010 + !byte $5E,%10100101 + !byte $09,%10100101 + !byte $33,%11100111 + !byte $0D,%00000110 + !byte $30,%00000000 + !byte $60,%01100110 + !byte $60,%10000111; + !byte $5C,%01100010 + !byte $5C,%10000011; + !byte $0E,%00100110 + !byte $04,%01010110 + !byte $07,%01100100 + !byte $07,%10000101; + !byte $0C,%11100101 + !byte $3C,%00011010 + !byte $0F,%01000110 + !byte $33,%00000010 + !byte $32,%11101001 + !byte $5D,%00100100 + !byte $0B,%11000101 + !byte $10,%01100110 + !byte $10,%10000111; + !byte $33,%00001000 + !byte $03,%01110110 + !byte $03,%10010111; + !byte $3D,%00011010 + !byte $5C,%10100011 + !byte $01,%11110111 + !byte $08,%01100100 + !byte $08,%10000101; + !byte $00,%10100101 + !byte $32,%01100000 + !byte $32,%10000001; + !byte $5F,%00100110 + !byte $31,%00100000 + !byte $5E,%11000101 + !byte $33,%11100001 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $04,%01000100 + !byte $05,%01000100 + !byte $34,%01100100 + !byte $34,%10000101; + !byte $11,%10100111 + !byte $34,%00100100 + !byte $34,%01000100 + !byte $32,%00001010 + !byte $33,%00101000 + !byte $34,%10100101 + !byte $34,%11000101 + !byte $61,%11100111 + !byte $34,%00000100 + !byte $03,%01000100 + !byte $0A,%10100101 + !byte $3E,%00011010 + !byte $5D,%01000100 + !byte $06,%01000100 + !byte $34,%11100011 + !byte $34,%11100101 + !byte $60,%10100111 + !byte $02,%10110111 + !byte $12,%11000111 + !byte $33,%01001000 + !byte $5C,%11000011 + !byte $34,%11000011 + !byte $00,%00011000 + !byte $34,%00000110 + !byte $5E,%11100101 + !byte $09,%01100100 + !byte $09,%10000101; + !byte $5B,%00000010 + !byte $34,%10100011 + !byte $02,%01000100 + !byte $07,%01000100 + !byte $0D,%11100101 + !byte $38,%00111010 + !byte $0E,%00000110 + !byte $3F,%00011010 + !byte $39,%00111010 + !byte $5F,%01000110 + !byte $0F,%00100110 + !byte $33,%11000001 + !byte $34,%00100110 + !byte $04,%00110110 + !byte $3A,%00111010 + !byte $34,%01100010 + !byte $34,%10000011; + !byte $01,%11010111 + !byte $0C,%11000101 + !byte $10,%01000110 + !byte $32,%01000000 + !byte $34,%01000110 + !byte $33,%01101000 + !byte $33,%10001001; + !byte $3B,%00111010 + !byte $5C,%11100011 + !byte $60,%11000111 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $3C,%00111010 + !byte $34,%01100110 + !byte $34,%10000111; + !byte $5E,%00000110 + !byte $0B,%10100101 + !byte $11,%01100110 + !byte $11,%10000111; + !byte $34,%01000010 + !byte $5B,%00100010 + !byte $33,%10100001 + !byte $08,%01000100 + !byte $03,%01010110 + !byte $3D,%00111010 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $04,%00100100 + !byte $05,%00100100 + !byte $34,%00100010 + !byte $34,%10100111 + !byte $00,%11110111 + !byte $0A,%01100100 + !byte $0A,%10000101; + !byte $00,%01100100 + !byte $00,%10000101; + !byte $33,%10101001 + !byte $5C,%00000100 + !byte $5B,%01000010 + !byte $06,%00100100 + !byte $03,%00100100 + !byte $5D,%10100101 + !byte $01,%01000100 + !byte $12,%10100111 + !byte $34,%11000111 + !byte $3E,%00111010 + !byte $31,%00000000 + !byte $02,%01110110 + !byte $02,%10010111; + !byte $34,%00000010 + !byte $09,%01000100 + !byte $02,%00100100 + !byte $07,%00100100 + !byte $33,%01100000 + !byte $33,%10000001; + !byte $32,%00100000 + !byte $33,%11001001 + !byte $60,%11100111 + !byte $5E,%00100110 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $0D,%11000101 + !byte $3F,%00111010 + !byte $0E,%11100101 + !byte $34,%11100111 + !byte $5D,%11000101 + !byte $0C,%10100101 + !byte $0F,%00000110 + !byte $5C,%00100100 + !byte $5F,%10100111 + !byte $01,%10110111 + !byte $3A,%01011010 + !byte $39,%01011010 + !byte $34,%11100001 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $35,%00100100 + !byte $35,%01000100 + !byte $34,%00001000 + !byte $33,%11101001 + !byte $38,%01011010 + !byte $10,%00100110 + !byte $3B,%01011010 + !byte $08,%00100100 + !byte $03,%00110110 + !byte $35,%00000100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $3C,%01011010 + !byte $35,%10100101 + !byte $35,%11100011 + !byte $04,%00000100 + !byte $05,%00000100 + !byte $5B,%10100011 + !byte $35,%11000101 + !byte $0A,%01000100 + !byte $5E,%01000110 + !byte $34,%00101000 + !byte $3D,%01011010 + !byte $5C,%01000100 + !byte $00,%11010111 + !byte $11,%01000110 + !byte $35,%11000011 + !byte $35,%11100101 + !byte $02,%01010110 + !byte $01,%00100100 + !byte $03,%00000100 + !byte $34,%11000001 + !byte $35,%00000110 + !byte $06,%00000100 + !byte $35,%10100011 + !byte $5F,%11000111 + !byte $5D,%11100101 + !byte $33,%01000000 + !byte $3E,%01011010 + !byte $5B,%11000011 + !byte $33,%00001010 + !byte $12,%01100110 + !byte $12,%10000111; + !byte $35,%00100110 + !byte $09,%00100100 + !byte $0E,%11000101 + !byte $35,%01100010 + !byte $35,%10000011; + !byte $34,%01001000 + !byte $00,%01000100 + !byte $0D,%10100101 + !byte $5C,%01100100 + !byte $5C,%10000101; + !byte $01,%01110110 + !byte $01,%10010111; + !byte $07,%00000100 + !byte $0C,%01100100 + !byte $0C,%10000101; + !byte $0F,%11100101 + !byte $3F,%01011010 + !byte $35,%01000110 + !byte $35,%01000010 + !byte $02,%00000100 + !byte $10,%00000110 + !byte $0B,%01000100 + !byte $34,%10100001 + !byte $5E,%01100110 + !byte $5E,%10000111; + !byte $5D,%00000110 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $32,%00000000 + !byte $00,%10110111 + !byte $08,%00000100 + !byte $35,%00100010 + !byte $34,%01101000 + !byte $34,%10001001; + !byte $5B,%11100011 + !byte $11,%00100110 + !byte $5F,%11100111 + !byte $5C,%10100101 + !byte $0A,%00100100 + !byte $3A,%01111010 + !byte $3A,%10011011; + !byte $04,%11100011 + !byte $05,%11100011 + !byte $3B,%01111010 + !byte $3B,%10011011; + !byte $39,%01111010 + !byte $39,%10011011; + !byte $35,%00000010 + !byte $35,%10100111 + !byte $03,%00010110 + !byte $06,%11100011 + !byte $3C,%01111010 + !byte $3C,%10011011; + !byte $38,%01111010 + !byte $38,%10011011; + !byte $5A,%00100010 + !byte $5D,%00100110 + !byte $5E,%10100111 + !byte $34,%10101001 + !byte $3D,%01111010 + !byte $3D,%10011011; + !byte $5B,%00000100 + !byte $34,%01100000 + !byte $34,%10000001; + !byte $33,%00100000 + !byte $02,%00110110 + !byte $09,%00000100 + !byte $35,%11000111 + !byte $03,%11100011 + !byte $12,%01000110 + !byte $5A,%01000010 + !byte $07,%11100011 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $3E,%01111010 + !byte $3E,%10011011; + !byte $01,%00000100 + !byte $0C,%01000100 + !byte $35,%11100001 + !byte $35,%11100111 + !byte $0E,%10100101 + !byte $5C,%11000101 + !byte $01,%01010110 + !byte $0F,%11000101 + !byte $5D,%01000110 + !byte $5B,%00100100 + !byte $34,%11001001 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $36,%00000100 + !byte $3F,%01111010 + !byte $3F,%10011011; + !byte $5E,%11000111 + !byte $36,%00100100 + !byte $36,%01000100 + !byte $00,%00100100 + !byte $5A,%01100010 + !byte $5A,%10000011; + !byte $36,%11100011 + !byte $10,%11100101 + !byte $02,%11100011 + !byte $0B,%00100100 + !byte $36,%01100100 + !byte $36,%10000101; + !byte $36,%11000011 + !byte $36,%11000101 + !byte $5C,%11100101 + !byte $08,%11100011 + !byte $36,%10100101 + !byte $35,%00001000 + !byte $00,%01110110 + !byte $00,%10010111; + !byte $35,%11000001 + !byte $36,%10100011 + !byte $34,%01000000 + !byte $0A,%00000100 + !byte $05,%11000011 + !byte $36,%11100101 + !byte $04,%11000011 + !byte $11,%00000110 + !byte $5B,%01000100 + !byte $36,%01100010 + !byte $36,%10000011; + !byte $06,%11000011 + !byte $36,%00000110 + !byte $34,%11101001 + !byte $5A,%10100011 + !byte $3A,%10111011 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $03,%11110101 + !byte $3B,%10111011 + !byte $35,%00101000 + !byte $03,%11000011 + !byte $36,%01000010 + !byte $3C,%10111011 + !byte $5C,%00000110 + !byte $09,%11100011 + !byte $39,%10111011 + !byte $36,%00100110 + !byte $5E,%11100111 + !byte $12,%00100110 + !byte $38,%10111011 + !byte $02,%00010110 + !byte $0E,%01100100 + !byte $0E,%10000101; + !byte $3D,%10111011 + !byte $07,%11000011 + !byte $35,%10100001 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $0D,%01000100 + !byte $35,%01001000 + !byte $33,%00000000 + !byte $5A,%11000011 + !byte $0C,%00100100 + !byte $0F,%10100101 + !byte $3E,%10111011 + !byte $36,%00100010 + !byte $10,%11000101 + !byte $0B,%00000100 + !byte $36,%01000110 + !byte $34,%00001010 + !byte $3F,%10111011 + !byte $01,%00110110 + !byte $01,%11100011 + !byte $5D,%10100111 + !byte $36,%00000010 + !byte $36,%01100110 + !byte $36,%10000111; + !byte $5A,%11100011 + !byte $08,%11000011 + !byte $5B,%10100101 + !byte $13,%01000110 + !byte $0A,%11100011 + !byte $00,%01010110 + !byte $02,%11000011 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $5C,%00100110 + !byte $35,%01100000 + !byte $35,%10000001; + !byte $11,%11100101 + !byte $34,%00100000 + !byte $36,%10100111 + !byte $05,%10100011 + !byte $00,%00000100 + !byte $06,%10100011 + !byte $04,%10100011 + !byte $36,%11100001 + !byte $5B,%11000101 + !byte $5A,%00000100 + !byte $36,%11000111 + !byte $35,%10101001 + !byte $09,%11000011 + !byte $0C,%00000100 + !byte $07,%10100011 + !byte $0D,%00100100 + !byte $0E,%01000100 + !byte $12,%00000110 + !byte $5D,%11000111 + !byte $5C,%01000110 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $3C,%11011011 + !byte $59,%00100010 + !byte $3B,%11011011 + !byte $02,%11110101 + !byte $03,%10100011 + !byte $37,%01000100 + !byte $3A,%11011011 + !byte $01,%00010110 + !byte $37,%11100011 + !byte $3D,%11011011 + !byte $37,%00000100 + !byte $37,%00100100 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $37,%11000011 + !byte $37,%10100101 + !byte $0B,%11100011 + !byte $36,%11000001 + !byte $36,%11100111 + !byte $3E,%11011011 + !byte $39,%11011011 + !byte $5A,%00100100 + !byte $10,%10100101 + !byte $37,%10100011 + !byte $38,%11011011 + !byte $35,%01000000 + !byte $59,%01000010 + !byte $5B,%11100101 + !byte $3F,%11011011 + !byte $37,%11000101 + !byte $5D,%11100111 + !byte $5C,%01100110 + !byte $5C,%10000111; + !byte $08,%10100011 + !byte $00,%00110110 + !byte $13,%00100110 + !byte $36,%00001000 + !byte $0A,%11000011 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $5A,%01000100 + !byte $37,%11100101 + !byte $35,%11001001 + !byte $59,%01100010 + !byte $59,%10000011; + !byte $01,%11000011 + !byte $02,%10100011 + !byte $11,%11000101 + !byte $05,%01100010 + !byte $05,%10000011; + !byte $37,%01000010 + !byte $37,%00000110 + !byte $04,%01100010 + !byte $04,%10000011; + !byte $36,%10100001 + !byte $06,%01100010 + !byte $06,%10000011; + !byte $36,%00101000 + !byte $5B,%00000110 + !byte $37,%00100110 + !byte $35,%11101001 + !byte $09,%10100011 + !byte $12,%11100101 + !byte $37,%00100010 + !byte $34,%00000000 + !byte $0E,%00100100 + !byte $5C,%10100111 + !byte $59,%10100011 + !byte $0D,%00000100 + !byte $0F,%01000100 + !byte $07,%01100010 + !byte $07,%10000011; + !byte $5A,%01100100 + !byte $5A,%10000101; + !byte $02,%11010101 + !byte $0C,%11100011 + !byte $37,%01000110 + !byte $0B,%11000011 + !byte $10,%01100100 + !byte $10,%10000101; + !byte $03,%01100010 + !byte $03,%10000011; + !byte $5B,%00100110 + !byte $36,%01001000 + !byte $01,%11110101 + !byte $3C,%11111011 + !byte $59,%11000011 + !byte $3D,%11111011 + !byte $37,%00000010 + !byte $3B,%11111011 + !byte $0A,%10100011 + !byte $3A,%11111011 + !byte $5A,%10100101 + !byte $08,%01100010 + !byte $08,%10000011; + !byte $36,%01100000 + !byte $36,%10000001; + !byte $37,%01100110 + !byte $37,%10000111; + !byte $35,%00001010 + !byte $00,%00010110 + !byte $13,%00000110 + !byte $35,%00100000 + !byte $3E,%11111011 + !byte $00,%11100011 + !byte $5C,%11000111 + !byte $11,%10100101 + !byte $3F,%11111011 + !byte $37,%11100001 + !byte $39,%11111011 + !byte $36,%01101000 + !byte $36,%10001001; + !byte $59,%11100011 + !byte $38,%11111011 + !byte $37,%10100111 + !byte $05,%01000010 + !byte $5B,%01000110 + !byte $5A,%11000101 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $06,%01000010 + !byte $37,%11000111 + !byte $0D,%11100011 + !byte $0E,%00000100 + !byte $35,%00101010 + !byte $02,%01100010 + !byte $02,%10000011; + !byte $04,%01000010 + !byte $0C,%11000011 + !byte $38,%00000100 + !byte $38,%00100100 + !byte $59,%00000100 + !byte $07,%01000010 + !byte $0F,%00100100 + !byte $14,%00100110 + !byte $37,%11000001 + !byte $38,%11100011 + !byte $38,%01000100 + !byte $38,%01100100 + !byte $38,%10000101; + !byte $01,%10100011 + !byte $12,%11000101 + !byte $38,%11000011 + !byte $36,%10101001 + !byte $5C,%11100111 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $37,%11100111 + !byte $0B,%10100011 + !byte $38,%10100011 + !byte $38,%10100101 + !byte $59,%00100100 + !byte $5A,%11100101 + !byte $02,%10110101 + !byte $38,%11000101 + !byte $36,%01000000 + !byte $03,%01000010 + !byte $10,%01000100 + !byte $01,%11010101 + !byte $38,%01100010 + !byte $38,%10000011; + !byte $08,%01000010 + !byte $38,%11100101 + !byte $3C,%00011100 + !byte $13,%11100101 + !byte $0A,%01100010 + !byte $0A,%10000011; + !byte $11,%01100100 + !byte $11,%10000101; + !byte $3E,%00011100 + !byte $00,%11110101 + !byte $37,%10100001 + !byte $3D,%00011100 + !byte $38,%01000010 + !byte $37,%00001000 + !byte $3B,%00011100 + !byte $3A,%00011100 + !byte $59,%01000100 + !byte $38,%00000110 + !byte $36,%11001001 + !byte $5A,%00000110 + !byte $58,%01000010 + !byte $5B,%10100111 + !byte $3F,%00011100 + !byte $38,%00100010 + !byte $39,%00011100 + !byte $09,%01000010 + !byte $12,%10100101 + !byte $38,%00100110 + !byte $0E,%11100011 + !byte $05,%00100010 + !byte $06,%00100010 + !byte $35,%00000000 + !byte $0D,%11000011 + !byte $0F,%00000100 + !byte $14,%00000110 + !byte $37,%00101000 + !byte $07,%00100010 + !byte $5A,%00100110 + !byte $0C,%10100011 + !byte $58,%01100010 + !byte $58,%10000011; + !byte $38,%01000110 + !byte $59,%01100100 + !byte $59,%10000101; + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $10,%00100100 + !byte $38,%00000010 + !byte $04,%00100010 + !byte $38,%00011100 + !byte $36,%11101001 + !byte $58,%10100011 + !byte $5B,%11000111 + !byte $02,%01000010 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $38,%01100110 + !byte $38,%10000111; + !byte $36,%00100000 + !byte $0A,%01000010 + !byte $37,%01001000 + !byte $08,%00100010 + !byte $59,%10100101 + !byte $36,%00001010 + !byte $11,%01000100 + !byte $38,%11100001 + !byte $38,%10100111 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $13,%11000101 + !byte $58,%11000011 + !byte $00,%11000011 + !byte $01,%10110101 + !byte $5A,%01000110 + !byte $5B,%11100111 + !byte $03,%00100010 + !byte $00,%11010101 + !byte $3E,%00111100 + !byte $3C,%00111100 + !byte $3D,%00111100 + !byte $59,%11000101 + !byte $09,%00100010 + !byte $0C,%01100010 + !byte $0C,%10000011; + !byte $0D,%10100011 + !byte $38,%11000001 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $3F,%00111100 + !byte $0E,%11000011 + !byte $38,%11000111 + !byte $3B,%00111100 + !byte $0F,%11100011 + !byte $39,%11100011 + !byte $39,%00000100 + !byte $3A,%00111100 + !byte $39,%00100100 + !byte $39,%01000100 + !byte $58,%11100011 + !byte $12,%01100100 + !byte $12,%10000101; + !byte $39,%11000011 + !byte $05,%00000010 + !byte $06,%00000010 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $5A,%01100110 + !byte $5A,%10000111; + !byte $14,%11100101 + !byte $39,%10100101 + !byte $39,%00111100 + !byte $07,%00000010 + !byte $39,%10100011 + !byte $36,%00101010 + !byte $0B,%01000010 + !byte $37,%01000000 + !byte $58,%00000100 + !byte $04,%00000010 + !byte $59,%11100101 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $39,%11000101 + !byte $37,%10101001 + !byte $38,%11100111 + !byte $10,%00000100 + !byte $13,%10100101 + !byte $0A,%00100010 + !byte $39,%11100101 + !byte $08,%00000010 + !byte $11,%00100100 + !byte $58,%00100100 + !byte $39,%01000010 + !byte $5A,%10100111 + !byte $38,%00111100 + !byte $38,%10100001 + !byte $38,%00001000 + !byte $59,%00000110 + !byte $39,%00100010 + !byte $02,%00100010 + !byte $39,%00000110 + !byte $37,%11001001 + !byte $36,%01001010 + !byte $01,%01110100 + !byte $01,%10010101; + !byte $39,%00100110 + !byte $00,%10110101 + !byte $0F,%11000011 + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $58,%01000100 + !byte $0E,%10100011 + !byte $3E,%01011100 + !byte $3C,%01011100 + !byte $5A,%11000111 + !byte $09,%00000010 + !byte $12,%01000100 + !byte $39,%00000010 + !byte $03,%00000010 + !byte $0C,%01000010 + !byte $3D,%01011100 + !byte $59,%00100110 + !byte $36,%00000000 + !byte $3B,%01011100 + !byte $0B,%00100010 + !byte $39,%01000110 + !byte $38,%00101000 + !byte $3F,%01011100 + !byte $06,%11100001 + !byte $10,%11100011 + !byte $05,%11100001 + !byte $14,%11000101 + !byte $58,%01100100 + !byte $58,%10000101; + !byte $07,%11100001 + !byte $37,%11101001 + !byte $3A,%01011100 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $59,%01000110 + !byte $38,%01100000 + !byte $38,%10000001; + !byte $39,%11100001 + !byte $0A,%00000010 + !byte $37,%00100000 + !byte $5A,%11100111 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $58,%10100101 + !byte $04,%11100001 + !byte $08,%11100001 + !byte $38,%01001000 + !byte $13,%01100100 + !byte $13,%10000101; + !byte $39,%01011100 + !byte $01,%01000010 + !byte $11,%00000100 + !byte $39,%10100111 + !byte $57,%10100011 + !byte $58,%11000101 + !byte $0D,%01000010 + !byte $12,%00100100 + !byte $0C,%00100010 + !byte $39,%11000001 + !byte $3A,%11100011 + !byte $3A,%00000100 + !byte $3A,%00100100 + !byte $3A,%01000100 + !byte $59,%01100110 + !byte $59,%10000111; + !byte $0E,%01100010 + !byte $0E,%10000011; + !byte $3A,%11000011 + !byte $37,%00001010 + !byte $38,%01011100 + !byte $09,%11100001 + !byte $0F,%10100011 + !byte $39,%11000111 + !byte $38,%01101000 + !byte $38,%10001001; + !byte $14,%10100101 + !byte $3A,%01100100 + !byte $3A,%10000101; + !byte $3A,%10100011 + !byte $57,%11000011 + !byte $00,%01110100 + !byte $00,%10010101; + !byte $01,%01010100 + !byte $3A,%10100101 + !byte $3A,%01100010 + !byte $3A,%10000011; + !byte $3A,%11000101 + !byte $3E,%01111100 + !byte $3E,%10011101; + !byte $38,%01000000 + !byte $3F,%01111100 + !byte $3F,%10011101; + !byte $3C,%01111100 + !byte $3C,%10011101; + !byte $57,%11100011 + !byte $0B,%00000010 + !byte $10,%11000011 + !byte $3D,%01111100 + !byte $3D,%10011101; + !byte $59,%10100111 + !byte $58,%11100101 + !byte $03,%11100001 + !byte $06,%11000001 + !byte $02,%00000010 + !byte $11,%11100011 + !byte $3A,%01000010 + !byte $3A,%11100101 + !byte $37,%00101010 + !byte $3B,%01111100 + !byte $3B,%10011101; + !byte $05,%11000001 + !byte $39,%11100111 + !byte $38,%10101001 + !byte $07,%11000001 + !byte $57,%00000100 + !byte $13,%01000100 + !byte $0A,%11100001 + !byte $08,%11000001 + !byte $3A,%00000110 + !byte $39,%10100001 + !byte $3A,%01111100 + !byte $3A,%10011101; + !byte $58,%00000110 + !byte $3A,%00100010 + !byte $39,%00001000 + !byte $0E,%01000010 + !byte $57,%00100100 + !byte $04,%11000001 + !byte $0C,%00000010 + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $3A,%00100110 + !byte $59,%11000111 + !byte $0D,%00100010 + !byte $39,%01111100 + !byte $39,%10011101; + !byte $38,%11001001 + !byte $3A,%00000010 + !byte $58,%00100110 + !byte $15,%11000101 + !byte $12,%00000100 + !byte $37,%01001010 + !byte $09,%11000001 + !byte $14,%01100100 + !byte $14,%10000101; + !byte $3A,%01000110 + !byte $10,%10100011 + !byte $39,%00101000 + !byte $0B,%11100001 + !byte $57,%01000100 + !byte $38,%01111100 + !byte $38,%10011101; + !byte $00,%01010100 + !byte $01,%00110100 + !byte $13,%00100100 + !byte $3E,%10111101 + !byte $3D,%10111101 + !byte $3F,%10111101 + !byte $57,%01100100 + !byte $57,%10000101; + !byte $59,%11100111 + !byte $06,%10100001 + !byte $37,%00000000 + !byte $3A,%01100110 + !byte $3A,%10000111; + !byte $38,%11101001 + !byte $58,%01000110 + !byte $07,%10100001 + !byte $39,%01100000 + !byte $39,%10000001; + !byte $3A,%11100001 + !byte $3C,%10111101 + !byte $0A,%11000001 + !byte $39,%01001000 + !byte $11,%11000011 + !byte $05,%10100001 + !byte $3B,%10111101 + !byte $57,%10100101 + !byte $08,%10100001 + !byte $3B,%00000100 + !byte $3A,%10100111 + !byte $12,%11100011 + !byte $38,%00100000 + !byte $3B,%01000100 + !byte $58,%01100110 + !byte $58,%10000111; + !byte $0D,%00000010 + !byte $15,%10100101 + !byte $3B,%11000011 + !byte $3B,%11100011 + !byte $03,%11000001 + !byte $0E,%00100010 + !byte $3B,%00100100 + !byte $0C,%11100001 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $56,%01100010 + !byte $56,%10000011; + !byte $01,%00100010 + !byte $3B,%10100011 + !byte $3A,%11000001 + !byte $3A,%10111101 + !byte $0F,%01000010 + !byte $09,%10100001 + !byte $3B,%10100101 + !byte $57,%11000101 + !byte $38,%00001010 + !byte $10,%01100010 + !byte $10,%10000011; + !byte $3A,%11000111 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $0B,%11000001 + !byte $02,%11100001 + !byte $14,%01000100 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $58,%10100111 + !byte $56,%10100011 + !byte $3B,%11000101 + !byte $39,%10111101 + !byte $04,%10100001 + !byte $3A,%11100111 + !byte $3B,%01000010 + !byte $56,%11000011 + !byte $3B,%11100101 + !byte $57,%11100101 + !byte $11,%10100011 + !byte $39,%01000000 + !byte $00,%00110100 + !byte $13,%00000100 + !byte $07,%01100000 + !byte $07,%10000001; + !byte $3B,%00000110 + !byte $39,%10101001 + !byte $3D,%11011101 + !byte $3B,%00100010 + !byte $3E,%11011101 + !byte $06,%01100000 + !byte $06,%10000001; + !byte $0A,%10100001 + !byte $3F,%11011101 + !byte $0D,%11100001 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $38,%10111101 + !byte $0E,%00000010 + !byte $3A,%10100001 + !byte $57,%00000110 + !byte $56,%11100011 + !byte $38,%00101010 + !byte $08,%01100000 + !byte $08,%10000001; + !byte $3A,%00001000 + !byte $58,%11000111 + !byte $12,%11000011 + !byte $3C,%11011101 + !byte $3B,%00100110 + !byte $05,%01100000 + !byte $05,%10000001; + !byte $56,%00000100 + !byte $3B,%11011101 + !byte $0C,%11000001 + !byte $0F,%00100010 + !byte $14,%00100100 + !byte $57,%00100110 + !byte $3B,%00000010 + !byte $3B,%01000110 + !byte $39,%11001001 + !byte $58,%11100111 + !byte $56,%00100100 + !byte $09,%01100000 + !byte $09,%10000001; + !byte $10,%01000010 + !byte $3A,%11011101 + !byte $0B,%10100001 + !byte $3A,%00101000 + !byte $38,%01001010 + !byte $56,%01000100 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $13,%11100011 + !byte $3B,%11100001 + !byte $57,%01000110 + !byte $03,%10100001 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $3A,%01100000 + !byte $3A,%10000001; + !byte $04,%01100000 + !byte $04,%10000001; + !byte $39,%11011101 + !byte $3A,%01001000 + !byte $0A,%01100000 + !byte $0A,%10000001; + !byte $56,%01100100 + !byte $56,%10000101; + !byte $39,%11101001 + !byte $00,%00010100 + !byte $3C,%11100011 + !byte $3C,%00000100 + !byte $3B,%10100111 + !byte $3C,%00100100 + !byte $3E,%11111101 + !byte $07,%01000000 + !byte $3F,%11111101 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $0F,%00000010 + !byte $0E,%11100001 + !byte $12,%10100011 + !byte $3C,%11000011 + !byte $3D,%11111101 + !byte $06,%01000000 + !byte $0C,%10100001 + !byte $0D,%11000001 + !byte $3C,%01000100 + !byte $15,%01000100 + !byte $3C,%01100100 + !byte $3C,%10000101; + !byte $08,%01000000 + !byte $3C,%10100011 + !byte $56,%10100101 + !byte $3B,%11000001 + !byte $38,%01101010 + !byte $38,%10001011; + !byte $38,%11011101 + !byte $14,%00000100 + !byte $3B,%11000111 + !byte $10,%00100010 + !byte $3C,%10100101 + !byte $3C,%11111101 + !byte $3C,%01100010 + !byte $3C,%10000011; + !byte $3C,%11000101 + !byte $3A,%01101000 + !byte $3A,%10001001; + !byte $57,%10100111 + !byte $05,%01000000 + !byte $13,%11000011 + !byte $56,%11000101 + !byte $39,%00100000 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $39,%00001010 + !byte $09,%01000000 + !byte $3B,%11111101 + !byte $3C,%01000010 + !byte $3C,%11100101 + !byte $3B,%11100111 + !byte $11,%01000010 + !byte $02,%11000001 + !byte $56,%11100101 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $3C,%00100010 + !byte $3A,%11111101 + !byte $3C,%00000110 + !byte $57,%11000111 + !byte $0A,%01000000 + !byte $16,%01100100 + !byte $16,%10000101; + !byte $38,%00000000 + !byte $12,%01100010 + !byte $12,%10000011; + !byte $3A,%10101001 + !byte $55,%10100011 + !byte $3B,%10100001 + !byte $0D,%10100001 + !byte $3B,%00001000 + !byte $0E,%11000001 + !byte $56,%00000110 + !byte $55,%11000011 + !byte $15,%00100100 + !byte $3A,%01000000 + !byte $3F,%00011110 + !byte $39,%00101010 + !byte $0F,%11100001 + !byte $3C,%00100110 + !byte $3E,%00011110 + !byte $00,%11110011 + !byte $10,%00000010 + !byte $57,%11100111 + !byte $55,%11100011 + !byte $07,%00100000 + !byte $3C,%00000010 + !byte $3D,%00011110 + !byte $08,%00100000 + !byte $0C,%01100000 + !byte $0C,%10000001; + !byte $39,%11111101 + !byte $14,%11100011 + !byte $3C,%01000110 + !byte $56,%00100110 + !byte $06,%00100000 + !byte $3A,%11001001 + !byte $3C,%00011110 + !byte $3B,%00101000 + !byte $04,%01000000 + !byte $0B,%01000000 + !byte $55,%00000100 + !byte $09,%00100000 + !byte $13,%10100011 + !byte $11,%00100010 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $3C,%01100110 + !byte $3C,%10000111; + !byte $38,%11111101 + !byte $56,%01000110 + !byte $55,%00100100 + !byte $3B,%00011110 + !byte $16,%01000100 + !byte $3C,%11100001 + !byte $39,%01001010 + !byte $0E,%10100001 + !byte $55,%01000100 + !byte $05,%00100000 + !byte $12,%01000010 + !byte $3D,%00100100 + !byte $3D,%01000100 + !byte $0F,%11000001 + !byte $56,%01100110 + !byte $56,%10000111; + !byte $0A,%00100000 + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $15,%00000100 + !byte $3D,%11100011 + !byte $3D,%00000100 + !byte $3C,%10100111 + !byte $3B,%01001000 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $55,%01100100 + !byte $55,%10000101; + !byte $3A,%11101001 + !byte $3A,%00011110 + !byte $3D,%11000011 + !byte $0C,%01000000 + !byte $3D,%10100101 + !byte $14,%11000011 + !byte $3D,%10100011 + !byte $3C,%11000111 + !byte $3F,%00111110 + !byte $10,%11100001 + !byte $07,%00000000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $55,%10100101 + !byte $08,%00000000 + !byte $11,%00000010 + !byte $3C,%11000001 + !byte $56,%10100111 + !byte $00,%11010011 + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $3D,%11000101 + !byte $3E,%00111110 + !byte $3D,%11100101 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $39,%00011110 + !byte $0B,%00100000 + !byte $3D,%00111110 + !byte $13,%01100010 + !byte $13,%10000011; + !byte $06,%00000000 + !byte $3C,%11100111 + !byte $09,%00000000 + !byte $3D,%01000010 + !byte $55,%11000101 + !byte $16,%00100100 + !byte $3C,%00111110 + !byte $56,%11000111 + !byte $15,%11100011 + !byte $3A,%00001010 + !byte $3D,%00000110 + !byte $55,%11100101 + !byte $0F,%10100001 + !byte $3D,%00100010 + !byte $0D,%01000000 + !byte $14,%10100011 + !byte $3B,%10101001 + !byte $0E,%01100000 + !byte $0E,%10000001; + !byte $12,%00100010 + !byte $38,%00011110 + !byte $0A,%00000000 + !byte $10,%11000001 + !byte $3D,%00100110 + !byte $3C,%00001000 + !byte $3B,%00111110 + !byte $56,%11100111 + !byte $04,%00100000 + !byte $0C,%00100000 + !byte $55,%00000110 + !byte $3C,%10100001 + !byte $3D,%00000010 + !byte $13,%01000010 + !byte $39,%10101011 + !byte $05,%00000000 + !byte $3D,%01000110 + !byte $3A,%00101010 + !byte $3A,%00111110 + !byte $54,%10100011 + !byte $3A,%00100000 + !byte $55,%00100110 + !byte $0B,%00000000 + !byte $3C,%00101000 + !byte $3F,%01011110 + !byte $11,%11100001 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $3E,%01011110 + !byte $54,%11000011 + !byte $3B,%11001001 + !byte $54,%11100011 + !byte $12,%00000010 + !byte $3B,%01000000 + !byte $3D,%01011110 + !byte $16,%00000100 + !byte $39,%00111110 + !byte $55,%01000110 + !byte $54,%00000100 + !byte $15,%11000011 + !byte $0E,%01000000 + !byte $3E,%00000100 + !byte $3E,%00100100 + !byte $3D,%10100111 + !byte $3D,%11100001 + !byte $03,%01000000 + !byte $14,%01100010 + !byte $14,%10000011; + !byte $3E,%01100100 + !byte $3E,%10000101; + !byte $3C,%01011110 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $3E,%11000011 + !byte $3E,%11100011 + !byte $3C,%01001000 + !byte $3A,%01001010 + !byte $54,%00100100 + !byte $3E,%01000100 + !byte $0D,%00100000 + !byte $10,%10100001 + !byte $55,%01100110 + !byte $55,%10000111; + !byte $3B,%11101001 + !byte $3E,%10100101 + !byte $3B,%01011110 + !byte $38,%00111110 + !byte $3E,%10100011 + !byte $54,%01000100 + !byte $0C,%00000000 + !byte $3D,%11000111 + !byte $13,%00100010 + !byte $55,%10100111 + !byte $11,%11000001 + !byte $3E,%01100010 + !byte $3E,%10000011; + !byte $3E,%11000101 + !byte $3C,%01100000 + !byte $3C,%10000001; + !byte $54,%01100100 + !byte $54,%10000101; + !byte $3E,%11100101 + !byte $3C,%01101000 + !byte $3C,%10001001; + !byte $54,%10100101 + !byte $3A,%01101010 + !byte $3A,%10001011; + !byte $3D,%11100111 + !byte $3D,%11000001 + !byte $3F,%01111110 + !byte $3F,%10011111; + !byte $3E,%01000010 + !byte $3A,%01011110 + !byte $12,%11100001 + !byte $3E,%01111110 + !byte $3E,%10011111; + !byte $55,%11000111 + !byte $15,%10100011 + !byte $16,%11100011 + !byte $17,%00100100 + !byte $54,%11000101 + !byte $3E,%00000110 + !byte $0F,%01000000 + !byte $3B,%00001010 + !byte $0E,%00100000 + !byte $3E,%00100110 + !byte $0D,%00000000 + !byte $14,%01000010 + !byte $3E,%00100010 + !byte $3D,%01111110 + !byte $3D,%10011111; + !byte $3C,%10101001 + !byte $10,%01100000 + !byte $10,%10000001; + !byte $3D,%00001000 + !byte $54,%11100101 + !byte $55,%11100111 + !byte $04,%00000000 + !byte $11,%10100001 + !byte $3A,%10101011 + !byte $3C,%01111110 + !byte $3C,%10011111; + !byte $39,%01011110 + !byte $54,%00000110 + !byte $13,%00000010 + !byte $3E,%01000110 + !byte $3B,%00101010 + !byte $16,%11000011 + !byte $15,%01100010 + !byte $15,%10000011; + !byte $17,%00000100 + !byte $3E,%00000010 + !byte $3E,%01100110 + !byte $3E,%10000111; + !byte $3D,%00101000 + !byte $54,%00100110 + !byte $3D,%10100001 + !byte $3B,%01111110 + !byte $3B,%10011111; + !byte $14,%00100010 + !byte $3C,%11001001 + !byte $38,%01011110 + !byte $0E,%00000000 + !byte $12,%11000001 + !byte $0F,%00100000 + !byte $54,%01000110 + !byte $3E,%10100111 + !byte $3F,%10111111 + !byte $10,%01000000 + !byte $13,%11100001 + !byte $3F,%11100011 + !byte $3F,%00000100 + !byte $3D,%01001000 + !byte $3E,%10111111 + !byte $3A,%01111110 + !byte $3A,%10011111; + !byte $3F,%00100100 + !byte $3F,%01000100 + !byte $3B,%01001010 + !byte $53,%10100011 + !byte $3F,%11000011 + !byte $54,%01100110 + !byte $54,%10000111; + !byte $53,%11000011 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $3A,%11001011 + !byte $3F,%10100011 + !byte $3D,%10111111 + !byte $53,%11100011 + !byte $3E,%11100001 + !byte $3F,%10100101 + !byte $3F,%11000101 + !byte $3E,%11000111 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $16,%10100011 + !byte $3C,%11101001 + !byte $53,%00000100 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $53,%00100100 + !byte $15,%01000010 + !byte $17,%11100011 + !byte $39,%01111110 + !byte $39,%10011111; + !byte $54,%10100111 + !byte $12,%10100001 + !byte $3F,%11100101 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $3C,%10111111 + !byte $3C,%01000000 + !byte $53,%01000100 + !byte $14,%00000010 + !byte $3E,%11100111 + !byte $53,%01100100 + !byte $53,%10000101; + !byte $3F,%01000010 + !byte $3F,%00000110 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $54,%11000111 + !byte $0F,%00000000 + !byte $3C,%00001010 + !byte $3B,%10111111 + !byte $10,%00100000 + !byte $53,%10100101 + !byte $3F,%00100110 + !byte $3E,%11000001 + !byte $3E,%00001000 + !byte $38,%01111110 + !byte $38,%10011111; + !byte $54,%11100111 + !byte $53,%11000101 + !byte $13,%11000001 + !byte $3F,%11011111 + !byte $11,%01000000 + !byte $3E,%11011111 + !byte $3F,%00100010 + !byte $3D,%10101001 + !byte $3F,%01000110 + !byte $3A,%10111111 + !byte $53,%11100101 + !byte $17,%11000011 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $16,%01100010 + !byte $16,%10000011; + !byte $3D,%11011111 + !byte $12,%01100000 + !byte $12,%10000001; + !byte $3C,%00101010 + !byte $15,%00100010 + !byte $18,%00000100 + !byte $3B,%10101011 + !byte $53,%00000110 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $3E,%00101000 + !byte $3D,%11001001 + !byte $14,%11100001 + !byte $3F,%00000010 + !byte $37,%01111110 + !byte $37,%10011111; + !byte $3C,%11011111 + !byte $53,%00100110 + !byte $39,%10111111 + !byte $10,%00000000 + !byte $53,%01000110 + !byte $3F,%10100111 + !byte $13,%10100001 + !byte $3C,%01001010 + !byte $11,%00100000 + !byte $3E,%01001000 + !byte $3B,%11011111 + !byte $3F,%11111111 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $3E,%10100001 + !byte $3D,%11101001 + !byte $3F,%11000111 + !byte $16,%01000010 + !byte $17,%10100011 + !byte $3B,%11001011 + !byte $3E,%11111111 + !byte $15,%00000010 + !byte $38,%10111111 + !byte $18,%11100011 + !byte $12,%01000000 + !byte $3A,%11011111 + !byte $14,%11000001 + !byte $3F,%11100001 + !byte $52,%10100011 + !byte $53,%10100111 + !byte $3E,%01101000 + !byte $3E,%10001001; + !byte $52,%11100011 + !byte $3D,%11111111 + !byte $52,%11000011 + !byte $3D,%00001010 + !byte $3F,%11100111 + !byte $52,%00000100 + !byte $52,%00100100 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $53,%11000111 + !byte $3C,%11111111 + !byte $11,%00000000 + !byte $3C,%01101010 + !byte $3C,%10001011; + !byte $52,%01000100 + !byte $3B,%11101011 + !byte $52,%01100100 + !byte $52,%10000101; + !byte $15,%11100001 + !byte $16,%00100010 + !byte $37,%10111111 + !byte $53,%11100111 + !byte $39,%11011111 + !byte $3F,%00001000 + !byte $3E,%10101001 + !byte $52,%10100101 + !byte $14,%10100001 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $52,%11000101 + !byte $7F,%00000000 + !byte $12,%00100000 + !byte $18,%11000011 + !byte $3B,%11111111 + !byte $52,%11100101 + !byte $3D,%00101010 + !byte $3C,%10101011 + !byte $3F,%00101000 + !byte $3E,%11001001 + !byte $13,%01000000 + !byte $3F,%11000001 + !byte $7E,%00000000 + !byte $38,%11011111 + !byte $52,%00000110 + !byte $16,%00000010 + !byte $7D,%00000000 + !byte $3A,%11111111 + !byte $17,%01000010 + !byte $52,%00100110 + !byte $15,%11000001 + !byte $12,%00000000 + !byte $3F,%01001000 + !byte $3E,%11101001 + !byte $3C,%11001011 + !byte $7C,%00000000 + !byte $52,%01000110 + !byte $14,%01100000 + !byte $14,%10000001; + !byte $18,%10100011 + !byte $3D,%01001010 + !byte $52,%01100110 + !byte $52,%10000111; + !byte $39,%11111111 + !byte $37,%11011111 + !byte $52,%10100111 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $7F,%00100000 + !byte $7B,%00000000 + !byte $13,%00100000 + !byte $3E,%01100000 + !byte $3E,%10000001; + !byte $7E,%00100000 + !byte $17,%00100010 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $16,%11100001 + !byte $3F,%10101001 + !byte $15,%10100001 + !byte $3E,%00001010 + !byte $52,%11000111 + !byte $38,%11111111 + !byte $51,%11000011 + !byte $18,%01100010 + !byte $18,%10000011; + !byte $7D,%00100000 + !byte $51,%10100011 + !byte $51,%11100011 + !byte $52,%11100111 + !byte $3C,%11101011 + !byte $7A,%00000000 + !byte $51,%00000100 + !byte $14,%01000000 + !byte $51,%01000100 + !byte $51,%00100100 + !byte $3F,%10100001 + !byte $51,%01100100 + !byte $51,%10000101; + !byte $19,%11000011 + !byte $7C,%00100000 + !byte $51,%10100101 + !byte $3E,%00101010 + !byte $51,%11000101 + !byte $13,%00000000 + !byte $3F,%11001001 + !byte $3D,%10101011 + !byte $79,%00000000 + !byte $17,%00000010 + !byte $37,%11111111 + !byte $51,%11100101 + !byte $18,%01000010 + !byte $7F,%01000000 + !byte $16,%11000001 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $7B,%00100000 + !byte $7E,%01000000 + !byte $51,%00000110 + !byte $3C,%00001100 + !byte $14,%00100000 + !byte $3E,%01001010 + !byte $51,%00100110 + !byte $7D,%01000000 + !byte $3F,%11101001 + !byte $19,%10100011 + !byte $51,%01000110 + !byte $3D,%11001011 + !byte $7A,%00100000 + !byte $78,%00000000 + !byte $51,%01100110 + !byte $51,%10000111; + !byte $17,%11100001 + !byte $18,%00100010 + !byte $15,%01000000 + !byte $16,%10100001 + !byte $7C,%01000000 + !byte $51,%10100111 + !byte $19,%01100010 + !byte $19,%10000011; + !byte $3E,%01101010 + !byte $3E,%10001011; + !byte $51,%11000111 + !byte $14,%00000000 + !byte $3F,%00001010 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $79,%00100000 + !byte $3D,%11101011 + !byte $77,%00000000 + !byte $7E,%01100000 + !byte $7E,%10000001; + !byte $7B,%01000000 + !byte $51,%11100111 + !byte $16,%01100000 + !byte $16,%10000001; + !byte $3F,%00101010 + !byte $15,%00100000 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $17,%11000001 + !byte $18,%00000010 + !byte $50,%00000100 + !byte $50,%11100011 + !byte $7A,%01000000 + !byte $50,%01000100 + !byte $50,%11000011 + !byte $19,%01000010 + !byte $3E,%10101011 + !byte $78,%00100000 + !byte $50,%00100100 + !byte $50,%10100011 + !byte $50,%01100100 + !byte $50,%10000101; + !byte $50,%10100101 + !byte $3D,%00001100 + !byte $7C,%01100000 + !byte $7C,%10000001; + !byte $50,%11000101 + !byte $50,%11100101 + !byte $17,%10100001 + !byte $7F,%10100001 + !byte $16,%01000000 + !byte $3E,%11001011 + !byte $50,%00000110 + !byte $3F,%01001010 + !byte $79,%01000000 + !byte $7E,%10100001 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $50,%00100110 + !byte $15,%00000000 + !byte $1A,%10100011 + !byte $18,%11100001 + !byte $77,%00100000 + !byte $50,%01000110 + !byte $19,%00100010 + !byte $50,%01100110 + !byte $50,%10000111; + !byte $7D,%10100001 + !byte $7A,%01100000 + !byte $7A,%10000001; + !byte $50,%10100111 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $78,%01000000 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $3D,%00101100 + !byte $1A,%01100010 + !byte $1A,%10000011; + !byte $50,%11000111 + !byte $7C,%10100001 + !byte $16,%00100000 + !byte $7F,%11000001 + !byte $3E,%11101011 + !byte $50,%11100111 + !byte $18,%11000001 + !byte $19,%00000010 + !byte $7E,%11000001 + !byte $3F,%10101011 + !byte $7B,%10100001 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $1A,%01000010 + !byte $18,%10100001 + !byte $7D,%11000001 + !byte $77,%01000000 + !byte $3E,%00001100 + !byte $17,%01000000 + !byte $16,%00000000 + !byte $4F,%00000100 + !byte $4F,%01000100 + !byte $4F,%00100100 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $4F,%10100011 + !byte $4F,%11100011 + !byte $7A,%10100001 + !byte $4F,%10100101 + !byte $4F,%11000011 + !byte $78,%01100000 + !byte $78,%10000001; + !byte $7C,%11000001 + !byte $4F,%11100101 + !byte $19,%11100001 + !byte $4F,%11000101 + !byte $4F,%00000110 + !byte $7F,%11100001 + !byte $3F,%11001011 + !byte $1A,%00100010 + !byte $4F,%00100110 + !byte $4F,%01000110 + !byte $18,%01100000 + !byte $18,%10000001; + !byte $7E,%11100001 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $7B,%11000001 + !byte $79,%10100001 + !byte $17,%00100000 + !byte $3E,%00101100 + !byte $7D,%11100001 + !byte $3F,%11101011 + !byte $4F,%10100111 + !byte $19,%11000001 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $4F,%11000111 + !byte $4F,%11100111 + !byte $1A,%00000010 + !byte $7A,%11000001 + !byte $18,%01000000 + !byte $7F,%00000010 + !byte $7C,%11100001 + !byte $17,%00000000 + !byte $78,%10100001 + !byte $3E,%01001100 + !byte $19,%10100001 + !byte $76,%01100000 + !byte $76,%10000001; + !byte $7E,%00000010 + !byte $79,%11000001 + !byte $1B,%01000010 + !byte $3F,%00001100 + !byte $7B,%11100001 + !byte $1A,%11100001 + !byte $7D,%00000010 + !byte $77,%10100001 + !byte $4E,%10100101 + !byte $4E,%00100100 + !byte $18,%00100000 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $4E,%01100100 + !byte $4E,%10000101; + !byte $4E,%01000100 + !byte $1B,%00100010 + !byte $4E,%00000110 + !byte $4E,%00000100 + !byte $3E,%01101100 + !byte $3E,%10001101; + !byte $7A,%11100001 + !byte $4E,%11100101 + !byte $4E,%11100011 + !byte $4E,%11000101 + !byte $7F,%00100010 + !byte $7C,%00000010 + !byte $3F,%00101100 + !byte $4E,%00100110 + !byte $4E,%11000011 + !byte $4E,%10100011 + !byte $4E,%01000110 + !byte $4E,%01100110 + !byte $4E,%10000111; + !byte $78,%11000001 + !byte $1A,%11000001 + !byte $7E,%00100010 + !byte $4E,%10100111 + !byte $79,%11100001 + !byte $76,%10100001 + !byte $18,%00000000 + !byte $1B,%00000010 + !byte $7B,%00000010 + !byte $4E,%11000111 + !byte $19,%01000000 + !byte $7D,%00100010 + !byte $4E,%11100111 + !byte $77,%11000001 + !byte $1A,%10100001 + !byte $3F,%01001100 + !byte $7C,%00100010 + !byte $7A,%00000010 + !byte $7F,%01000010 + !byte $78,%11100001 + !byte $1B,%11100001 + !byte $7E,%01000010 + !byte $19,%00100000 + !byte $7B,%00100010 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $1A,%01100000 + !byte $1A,%10000001; + !byte $79,%00000010 + !byte $76,%11000001 + !byte $7D,%01000010 + !byte $4D,%10100101 + !byte $4D,%11100101 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $4D,%11000101 + !byte $1B,%11000001 + !byte $77,%11100001 + !byte $4D,%00100110 + !byte $4D,%00000110 + !byte $4D,%00100100 + !byte $1C,%00100010 + !byte $4D,%01000100 + !byte $7A,%00100010 + !byte $19,%00000000 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $4D,%00000100 + !byte $7C,%01000010 + !byte $4D,%01000110 + !byte $4D,%11000011 + !byte $1A,%01000000 + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $4D,%11100011 + !byte $4D,%10100111 + !byte $4D,%10100011 + !byte $7E,%01100010 + !byte $7E,%10000011; + !byte $78,%00000010 + !byte $4D,%11000111 + !byte $4D,%11100111 + !byte $3F,%10101101 + !byte $7B,%01000010 + !byte $1C,%00000010 + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $1B,%10100001 + !byte $79,%00100010 + !byte $76,%11100001 + !byte $1A,%00100000 + !byte $7A,%01000010 + !byte $77,%00000010 + !byte $7F,%10100011 + !byte $7C,%01100010 + !byte $7C,%10000011; + !byte $1C,%11100001 + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $7E,%10100011 + !byte $78,%00100010 + !byte $1A,%00000000 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $1C,%11000001 + !byte $7D,%10100011 + !byte $79,%01000010 + !byte $76,%00000010 + !byte $4C,%00100110 + !byte $4C,%11000101 + !byte $4C,%00000110 + !byte $4C,%10100101 + !byte $4C,%11100101 + !byte $4C,%01100100 + !byte $4C,%10000101; + !byte $4C,%01000100 + !byte $4C,%01100110 + !byte $4C,%10000111; + !byte $1B,%01000000 + !byte $4C,%01000110 + !byte $7F,%11000011 + !byte $4C,%10100111 + !byte $4C,%00100100 + !byte $7A,%01100010 + !byte $7A,%10000011; + !byte $77,%00100010 + !byte $4C,%00000100 + !byte $7C,%10100011 + !byte $4C,%11000111 + !byte $4C,%11100011 + !byte $1C,%10100001 + !byte $4C,%11100111 + !byte $1B,%00100000 + !byte $4C,%11000011 + !byte $1D,%00000010 + !byte $7E,%11000011 + !byte $78,%01000010 + !byte $4C,%10100011 + !byte $7B,%10100011 + !byte $7D,%11000011 + !byte $75,%00000010 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $1C,%01100000 + !byte $1C,%10000001; + !byte $76,%00100010 + !byte $1D,%11100001 + !byte $7F,%11100011 + !byte $1B,%00000000 + !byte $7A,%10100011 + !byte $77,%01000010 + !byte $7C,%11000011 + !byte $7E,%11100011 + !byte $78,%01100010 + !byte $78,%10000011; + !byte $1C,%01000000 + !byte $1D,%11000001 + !byte $7D,%11100011 + !byte $7B,%11000011 + !byte $4B,%01000110 + !byte $4B,%11100101 + !byte $4B,%11000101 + !byte $4B,%00100110 + !byte $4B,%00000110 + !byte $76,%01000010 + !byte $4B,%10100111 + !byte $79,%10100011 + !byte $75,%00100010 + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $4B,%10100101 + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $4B,%11000111 + !byte $4B,%01000100 + !byte $7F,%00000100 + !byte $7C,%11100011 + !byte $4B,%11100111 + !byte $4B,%00100100 + !byte $7A,%11000011 + !byte $1C,%00100000 + !byte $4B,%00000100 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $1D,%10100001 + !byte $7E,%00000100 + !byte $4B,%11100011 + !byte $4B,%11000011 + !byte $78,%10100011 + !byte $4B,%10100011 + !byte $7D,%00000100 + !byte $7B,%11100011 + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $1C,%00000000 + !byte $75,%01000010 + !byte $7F,%00100100 + !byte $79,%11000011 + !byte $1E,%11100001 + !byte $76,%01100010 + !byte $76,%10000011; + !byte $7C,%00000100 + !byte $7A,%11100011 + !byte $77,%10100011 + !byte $7E,%00100100 + !byte $1E,%11000001 + !byte $1D,%01000000 + !byte $7B,%00000100 + !byte $78,%11000011 + !byte $7D,%00100100 + !byte $4A,%01000110 + !byte $4A,%11100101 + !byte $1D,%00100000 + !byte $4A,%10100111 + !byte $4A,%00100110 + !byte $4A,%11000101 + !byte $4A,%01100110 + !byte $4A,%10000111; + !byte $4A,%00000110 + !byte $1E,%10100001 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $4A,%11000111 + !byte $4A,%10100101 + !byte $4A,%11100111 + !byte $4A,%01100100 + !byte $4A,%10000101; + !byte $7F,%01000100 + !byte $79,%11100011 + !byte $4A,%01000100 + !byte $76,%10100011 + !byte $7C,%00100100 + !byte $4A,%00100100 + !byte $7A,%00000100 + !byte $7E,%01000100 + !byte $77,%11000011 + !byte $4A,%00000100 + !byte $1D,%00000000 + !byte $4A,%11100011 + !byte $1E,%01100000 + !byte $1E,%10000001; + !byte $7B,%00100100 + !byte $78,%11100011 + !byte $7D,%01000100 + !byte $4A,%11000011 + !byte $4A,%10100011 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $79,%00000100 + !byte $75,%10100011 + !byte $1E,%01000000 + !byte $76,%11000011 + !byte $7C,%01000100 + !byte $7A,%00100100 + !byte $1F,%11000001 + !byte $7E,%01100100 + !byte $7E,%10000101; + !byte $77,%11100011 + !byte $49,%01100110 + !byte $49,%10000111; + !byte $49,%00000110 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $49,%11000111 + !byte $49,%01000110 + !byte $7B,%01000100 + !byte $78,%00000100 + !byte $49,%10100111 + !byte $49,%00100110 + !byte $1E,%00100000 + !byte $49,%11100111 + !byte $49,%11100101 + !byte $49,%11000101 + !byte $49,%10100101 + !byte $1F,%10100001 + !byte $7F,%10100101 + !byte $79,%00100100 + !byte $49,%01100100 + !byte $49,%10000101; + !byte $75,%11000011 + !byte $74,%10100011 + !byte $49,%01000100 + !byte $7C,%01100100 + !byte $7C,%10000101; + !byte $7A,%01000100 + !byte $49,%00100100 + !byte $76,%11100011 + !byte $1E,%00000000 + !byte $7E,%10100101 + !byte $49,%00000100 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $77,%00000100 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $7D,%10100101 + !byte $49,%11100011 + !byte $78,%00100100 + !byte $49,%11000011 + !byte $7F,%11000101 + !byte $49,%10100011 + !byte $1F,%01000000 + !byte $79,%01000100 + !byte $74,%11000011 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $7C,%10100101 + !byte $7E,%11000101 + !byte $7A,%01100100 + !byte $7A,%10000101; + !byte $75,%11100011 + !byte $76,%00000100 + !byte $77,%00100100 + !byte $48,%10100111 + !byte $48,%00100110 + !byte $48,%11100111 + !byte $48,%01100110 + !byte $48,%10000111; + !byte $1F,%00100000 + !byte $48,%11000111 + !byte $48,%01000110 + !byte $7D,%11000101 + !byte $7B,%10100101 + !byte $48,%00000110 + !byte $48,%11100101 + !byte $48,%11000101 + !byte $78,%01000100 + !byte $48,%10100101 + !byte $20,%10100001 + !byte $7F,%11100101 + !byte $48,%01100100 + !byte $48,%10000101; + !byte $79,%01100100 + !byte $79,%10000101; + !byte $48,%01000100 + !byte $1F,%00000000 + !byte $7A,%10100101 + !byte $7C,%11000101 + !byte $7E,%11100101 + !byte $74,%11100011 + !byte $48,%00100100 + !byte $75,%00000100 + !byte $76,%00100100 + !byte $20,%01100000 + !byte $20,%10000001; + !byte $48,%00000100 + !byte $7D,%11100101 + !byte $77,%01000100 + !byte $7B,%11000101 + !byte $48,%11100011 + !byte $78,%01100100 + !byte $78,%10000101; + !byte $48,%11000011 + !byte $79,%10100101 + !byte $7F,%00000110 + !byte $20,%01000000 + !byte $48,%10100011 + !byte $7C,%11100101 + !byte $7E,%00000110 + !byte $7A,%11000101 + !byte $75,%00100100 + !byte $47,%10100111 + !byte $48,%01100010 + !byte $48,%10000011; + !byte $74,%00000100 + !byte $47,%01100110 + !byte $47,%10000111; + !byte $47,%11000111 + !byte $47,%01000110 + !byte $76,%01000100 + !byte $47,%00100110 + !byte $47,%11100111 + !byte $20,%00100000 + !byte $47,%11100101 + !byte $7D,%00000110 + !byte $47,%00000110 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $78,%10100101 + !byte $7B,%11100101 + !byte $47,%11000101 + !byte $7F,%00100110 + !byte $79,%11000101 + !byte $47,%10100101 + !byte $47,%01100100 + !byte $47,%10000101; + !byte $20,%00000000 + !byte $7C,%00000110 + !byte $47,%01000100 + !byte $7E,%00100110 + !byte $7A,%11100101 + !byte $75,%01000100 + !byte $47,%00100100 + !byte $76,%01100100 + !byte $76,%10000101; + !byte $74,%00100100 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $73,%00000100 + !byte $77,%10100101 + !byte $7D,%00100110 + !byte $47,%00000100 + !byte $7B,%00000110 + !byte $78,%11000101 + !byte $47,%11100011 + !byte $79,%11100101 + !byte $47,%11000011 + !byte $21,%01000000 + !byte $7F,%01000110 + !byte $7C,%00100110 + !byte $7A,%00000110 + !byte $47,%10100011 + !byte $7E,%01000110 + !byte $74,%01000100 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $46,%11100111 + !byte $46,%01100110 + !byte $46,%10000111; + !byte $76,%10100101 + !byte $46,%11000111 + !byte $46,%01000110 + !byte $46,%10100111 + !byte $73,%00100100 + !byte $77,%11000101 + !byte $46,%00100110 + !byte $21,%00100000 + !byte $46,%00000110 + !byte $46,%11100101 + !byte $47,%01100010 + !byte $47,%10000011; + !byte $78,%11100101 + !byte $7D,%01000110 + !byte $7B,%00100110 + !byte $21,%00000000 + !byte $46,%11000101 + !byte $46,%10100101 + !byte $79,%00000110 + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $7C,%01000110 + !byte $46,%01100100 + !byte $46,%10000101; + !byte $7E,%01100110 + !byte $7E,%10000111; + !byte $46,%01000100 + !byte $74,%01100100 + !byte $74,%10000101; + !byte $75,%10100101 + !byte $7A,%00100110 + !byte $46,%00100100 + !byte $76,%11000101 + !byte $73,%01000100 + !byte $77,%11100101 + !byte $46,%00000100 + !byte $7B,%01000110 + !byte $78,%00000110 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $46,%11100011 + !byte $7F,%10100111 + !byte $22,%01000000 + !byte $79,%00100110 + !byte $46,%11000011 + !byte $7C,%01100110 + !byte $7C,%10000111; + !byte $45,%10100111 + !byte $7E,%10100111 + !byte $45,%11100111 + !byte $45,%01100110 + !byte $45,%10000111; + !byte $45,%11000111 + !byte $7A,%01000110 + !byte $45,%00100110 + !byte $45,%01000110 + !byte $76,%11100101 + !byte $74,%10100101 + !byte $45,%00000110 + !byte $75,%11000101 + !byte $46,%10100011 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $77,%00000110 + !byte $22,%00100000 + !byte $45,%11100101 + !byte $7D,%10100111 + !byte $46,%01100010 + !byte $46,%10000011; + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $45,%11000101 + !byte $78,%00100110 + !byte $22,%00000000 + !byte $45,%10100101 + !byte $7F,%11000111 + !byte $79,%01000110 + !byte $7C,%10100111 + !byte $46,%01000010 + !byte $45,%01100100 + !byte $45,%10000101; + !byte $45,%01000100 + !byte $7A,%01100110 + !byte $7A,%10000111; + !byte $7E,%11000111 + !byte $45,%00100100 + !byte $7B,%10100111 + !byte $75,%11100101 + !byte $76,%00000110 + !byte $7D,%11000111 + !byte $45,%00000100 + !byte $77,%00100110 + !byte $74,%11000101 + !byte $78,%01000110 + !byte $73,%10100101 + !byte $72,%01100100 + !byte $72,%10000101; + !byte $45,%11100011 + !byte $7F,%11100111 + !byte $23,%01000000 + !byte $44,%11000111 + !byte $7C,%11000111 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $44,%10100111 + !byte $44,%11100111 + !byte $44,%01100110 + !byte $44,%10000111; + !byte $7A,%10100111 + !byte $44,%01000110 + !byte $45,%11000011 + !byte $7E,%11100111 + !byte $44,%00100110 + !byte $44,%00000110 + !byte $23,%00100000 + !byte $74,%11100101 + !byte $7D,%11100111 + !byte $44,%11100101 + !byte $45,%10100011 + !byte $75,%00000110 + !byte $76,%00100110 + !byte $73,%11000101 + !byte $77,%01000110 + !byte $7B,%11000111 + !byte $44,%11000101 + !byte $72,%10100101 + !byte $78,%01100110 + !byte $78,%10000111; + !byte $45,%01100010 + !byte $45,%10000011; + !byte $44,%10100101 + !byte $79,%10100111 + !byte $23,%00000000 + !byte $44,%01100100 + !byte $44,%10000101; + !byte $45,%01000010 + !byte $7C,%11100111 + !byte $7A,%11000111 + !byte $44,%01000100 + !byte $75,%00100110 + !byte $76,%01000110 + !byte $44,%00100100 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $74,%00000110 + !byte $73,%11100101 + !byte $78,%10100111 + !byte $7B,%11100111 + !byte $72,%11000101 + !byte $44,%00000100 + !byte $43,%11100111 + !byte $79,%11000111 + !byte $43,%01100110 + !byte $43,%10000111; + !byte $43,%11000111 + !byte $43,%10100111 + !byte $44,%11100011 + !byte $43,%01000110 + !byte $7A,%11100111 + !byte $43,%00100110 + !byte $44,%11000011 + !byte $43,%00000110 + !byte $75,%01000110 + !byte $77,%10100111 + !byte $74,%00100110 + !byte $43,%11100101 + !byte $76,%01100110 + !byte $76,%10000111; + !byte $24,%00100000 + !byte $44,%10100011 + !byte $78,%11000111 + !byte $73,%00000110 + !byte $43,%11000101 + !byte $43,%10100101 + !byte $44,%01100010 + !byte $44,%10000011; + !byte $72,%11100101 + !byte $24,%00000000 + !byte $79,%11100111 + !byte $43,%01100100 + !byte $43,%10000101; + !byte $43,%01000100 + !byte $44,%01000010 + !byte $76,%10100111 + !byte $77,%11000111 + !byte $43,%00100100 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $74,%01000110 + !byte $44,%00100010 + !byte $73,%00100110 + !byte $78,%11100111 + !byte $72,%00000110 + !byte $42,%11100111 + !byte $42,%11000111 + !byte $43,%00000100 + !byte $42,%10100111 + !byte $42,%01100110 + !byte $42,%10000111; + !byte $43,%11100011 + !byte $71,%11100101 + !byte $42,%01000110 + !byte $42,%00100110 + !byte $42,%00000110 + !byte $43,%11000011 + !byte $74,%01100110 + !byte $74,%10000111; + !byte $42,%11100101 + !byte $75,%10100111 + !byte $76,%11000111 + !byte $73,%01000110 + !byte $43,%10100011 + !byte $42,%11000101 + !byte $25,%00100000 + !byte $77,%11100111 + !byte $72,%00100110 + !byte $42,%10100101 + !byte $42,%01100100 + !byte $42,%10000101; + !byte $25,%00000000 + !byte $71,%00000110 + !byte $43,%01100010 + !byte $43,%10000011; + !byte $43,%01000010 + !byte $74,%10100111 + !byte $42,%01000100 + !byte $75,%11000111 + !byte $76,%11100111 + !byte $42,%00100100 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $41,%11100111 + !byte $41,%11000111 + !byte $41,%10100111 + !byte $42,%00000100 + !byte $43,%00100010 + !byte $72,%01000110 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $41,%01000110 + !byte $41,%00100110 + !byte $42,%11100011 + !byte $41,%00000110 + !byte $71,%00100110 + !byte $43,%00000010 + !byte $75,%11100111 + !byte $41,%11100101 + !byte $42,%11000011 + !byte $74,%11000111 + !byte $41,%11000101 + !byte $73,%10100111 + !byte $42,%10100011 + !byte $41,%10100101 + !byte $72,%01100110 + !byte $72,%10000111; + !byte $71,%01000110 + !byte $42,%01100010 + !byte $42,%10000011; + !byte $41,%01100100 + !byte $41,%10000101; + !byte $41,%01000100 + !byte $26,%00000000 + !byte $74,%11100111 + !byte $41,%00100100 + !byte $42,%01000010 + !byte $70,%00100110 + !byte $73,%11000111 + !byte $40,%10100111 + !byte $40,%11100111 + !byte $40,%11000111 + !byte $40,%01100110 + !byte $40,%10000111; + !byte $72,%10100111 + !byte $42,%00100010 + !byte $40,%01000110 + !byte $41,%00000100 + !byte $40,%00100110 + !byte $41,%11100011 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $40,%00000110 + !byte $42,%00000010 + !byte $40,%11100101 + !byte $73,%11100111 + !byte $41,%11000011 + !byte $70,%01000110 + !byte $40,%11000101 + !byte $40,%10100101 + !byte $72,%11000111 + !byte $41,%10100011 + !byte $40,%01100100 + !byte $40,%10000101; + !byte $71,%10100111 + !byte $27,%00000000 + !byte $40,%01000100 + !byte $70,%01100110 + !byte $70,%10000111; + !byte $41,%01100010 + !byte $41,%10000011; + !byte $41,%01000010 + !byte $40,%00100100 + !byte $40,%00000100 + !byte $72,%11100111 + !byte $71,%11000111 + !byte $41,%00100010 + !byte $40,%11100011 + !byte $41,%00000010 + !byte $70,%10100111 + !byte $40,%11000011 + !byte $41,%11100001 + !byte $40,%10100011 + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $71,%11100111 + !byte $40,%01100010 + !byte $40,%10000011; + !byte $70,%11000111 + !byte $6F,%10100111 + !byte $40,%01000010 + !byte $40,%00100010 + !byte $70,%11100111 + !byte $40,%00000010 + !byte $40,%11100001 + !byte $6F,%11000111 + !byte $40,%11000001 + !byte $6F,%11100111 + !byte $6E,%11000111 + !byte $6E,%11100111 + !byte $00,%10100011 + !byte $00,%01100010 + !byte $00,%10000011; + !byte $00,%01000010 + !byte $00,%00100010 + !byte $00,%00000010 + !byte $01,%00000010 + !byte $00,%11100001 + !byte $01,%11100001 + !byte $00,%11000001 + !byte $01,%11000001 + !byte $00,%10100001 + !byte $01,%10100001 + !byte $00,%01100000 + !byte $00,%10000001; + !byte $02,%10100001 + !byte $39,%00000000 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $00,%01000000 + !byte $02,%01100000 + !byte $02,%10000001; + !byte $01,%01000000 + !byte $00,%00100000 + !byte $02,%01000000 + !byte $3A,%00000000 + !byte $01,%00100000 + !byte $00,%00000000 + !byte $02,%00100000 + !byte $01,%00000000 + !byte $02,%00000000 + !byte $03,%00100000 + !byte $3B,%00000000 + !byte $3B,%00100000 + !byte $03,%00000000 + !byte $3C,%00000000 + !byte $3C,%00100000 + !byte $3D,%00000000 + !byte $3D,%00100000 + !byte $3D,%01000000 + !byte $3E,%00000000 + !byte $3E,%00100000 + !byte $3E,%01000000 + !byte $3F,%00000000 + !byte $3F,%00100000 + !byte $3F,%01000000 + !byte $3F,%01100000 + !byte $3F,%10000001; diff --git a/src/fx/fx.hgr.flower.radial.in.a b/src/fx/fx.hgr.flower.radial.in.a new file mode 100644 index 0000000..7bf8fac --- /dev/null +++ b/src/fx/fx.hgr.flower.radial.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER.RAD.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_REVERSE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/FLOWER.RAD.DATA" diff --git a/src/fx/fx.hgr.flower.radial.ripple.a b/src/fx/fx.hgr.flower.radial.ripple.a new file mode 100644 index 0000000..25e5600 --- /dev/null +++ b/src/fx/fx.hgr.flower.radial.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER.RAD.RIP",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_RIPPLE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/FLOWER.RAD.DATA" diff --git a/src/fx/fx.hgr.flower.ripple.a b/src/fx/fx.hgr.flower.ripple.a new file mode 100644 index 0000000..26c1828 --- /dev/null +++ b/src/fx/fx.hgr.flower.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FLOWER.RIPPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_RIPPLE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 14 + !text "FX/FLOWER.DATA" diff --git a/src/fx/fx.hgr.fourspiral.a b/src/fx/fx.hgr.fourspiral.a new file mode 100644 index 0000000..139dc30 --- /dev/null +++ b/src/fx/fx.hgr.fourspiral.a @@ -0,0 +1,94 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/FOURSPIRAL",plain +*=$6000 + + lda #$13 + sta $FB + lda #$17 + sta $FD + lda #$00 + sta $FA + sta $FC +@outerloop + lda $FC + sta $FE + lda $FA + sta $FF + lda #$00 + sta $F9 +@loop lda $FE + ldy $FF + jsr HGRHalfBlockCopy + lda #$27 + sec + sbc $FF + tay + lda $FE + jsr HGRHalfBlockCopy + lda #$2F + sec + sbc $FE + pha + jsr HGRHalfBlockCopy + pla + ldy $FF + jsr HGRHalfBlockCopy + lda #$28 + jsr WaitForKeyWithTimeout + bmi @exit + ldx $F9 + bne @a + inc $FF + lda $FB + cmp $FF + bcs @loop + inc $FC + inc $F9 + lda $FC + sta $FE + lda $FB + sta $FF +@a dex + bne @b + inc $FE + lda $FD + cmp $FE + bcs @loop + dec $FB + inc $F9 + lda $FD + sta $FE + lda $FB + sta $FF +@b dex + bne @c + dec $FF + lda $FF + cmp $FA + bpl @loop + lda $FD + cmp $FC + beq @exit + dec $FD + inc $F9 + lda $FD + sta $FE + lda $FA + sta $FF +@c dex + bne @loop + dec $FE + lda $FE + cmp $FC + bpl @loop + inc $FA + beq @exit + jmp @outerloop +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.foursquare.white.a b/src/fx/fx.hgr.foursquare.white.a new file mode 100644 index 0000000..d403570 --- /dev/null +++ b/src/fx/fx.hgr.foursquare.white.a @@ -0,0 +1,165 @@ +;license:MIT +;(c) 2018-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/FOURSQUARE",plain +*=$6000 + + lda #23 + sta $FD + lda #Coordinates + sta $FF + ldy #0 + sty $F7 + ldx #11 + stx $F8 + txa + inx + stx $F9 + ldx #19 + stx $FA + inx + stx $FB + ldx #39 + stx $FC +- lda $F7 + ldx $F8 + jsr @box2 + lda $F9 + ldx $FD + jsr @box2 + lda #$FF + jsr stainc + jsr stainc + dec $F8 + inc $F9 + dec $FA + inc $FB + dec $FC + dec $FD + inc $F7 + lda $F7 + cmp #6 + bne - + + lda #$80 + sta Coordinates+$798 + + lda #Coordinates + sta $FF + ldy #$00 +@loop1 + lda ($FE),y + bpl @copy + lda #$18 + jsr WaitForKeyWithTimeout + bmi @exit + bpl @next ; always branches +@copy + tax + iny + lda ($fe),y + tay + txa + jsr HGRBlockToWhite +@next + inc $FE + bne + + inc $FF ++ inc $FE + bne + + inc $FF ++ ldy #$00 + lda ($FE),y + cmp #$80 + bne @loop1 + +@loop2 + dec $FE + lda $FE + cmp #$FF + bne + + dec $FF ++ dec $FE + lda $FE + cmp #$FF + bne + + dec $FF ++ ldy #$00 + lda ($FE),y + cmp #$80 + beq @exit + lda ($FE),y + bpl @copy2 + lda #$18 + jsr WaitForKeyWithTimeout + bmi @exit + bpl @loop2 ; always branches +@copy2 + tax + iny + lda ($fe),y + tay + txa + jsr HGRBlockCopy + beq @loop2 ; always branches +@exit rts + +@box2 sta $F4 + stx $F5 + jsr @box1 + ldx $F4 +- inx + cpx $F5 + bcs + + jsr txasta + lda $F7 + jsr statxa + lda $FA + jsr statxa + lda $FB + jsr statxa + lda $FC + jsr stainc + bne - ; always branches ++ txa + + ; fall through + +@box1 ldx $FA + stx $F6 + ldx $F7 + jsr + + ldx $FC + stx $F6 + ldx $FB ++ +- jsr stainc + pha + txa + jsr stainc + pla + cpx $F6 + inx + bcc - + rts + +statxa jsr stainc +txasta txa +stainc sta ($FE), y + iny + bne + + inc $FF ++ rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_BLOCK_COPY_ROUTINES + + !byte $80,$80 +Coordinates diff --git a/src/fx/fx.hgr.full.of.stars.a b/src/fx/fx.hgr.full.of.stars.a new file mode 100644 index 0000000..5bdd677 --- /dev/null +++ b/src/fx/fx.hgr.full.of.stars.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/FULL.OF.STARS",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + !source "src/fx/fx.hgr.radial.common.a" + +!if * and 1 { + !byte 0 +} +Coordinates + !source "src/fx/fx.hgr.full.of.stars.data.a" +EndCoordinates + !byte $80 diff --git a/src/fx/fx.hgr.full.of.stars.data.a b/src/fx/fx.hgr.full.of.stars.data.a new file mode 100644 index 0000000..145d24c --- /dev/null +++ b/src/fx/fx.hgr.full.of.stars.data.a @@ -0,0 +1,6720 @@ + !byte $18,%00000101 + !byte $0E,%11010011 + !byte $48,%11001110 + !byte $50,%00000000 + !byte $18,%00100101 + !byte $0E,%00001010 + !byte $48,%00001111 + !byte $52,%00000000 + !byte $18,%11000100 + !byte $0C,%11010011 + !byte $46,%11001110 + !byte $50,%11001001 + !byte $1A,%00000101 + !byte $0C,%00001010 + !byte $46,%00001111 + !byte $50,%00100000 + !byte $18,%01000101 + !byte $0E,%10110011 + !byte $48,%10101110 + !byte $54,%00000000 + !byte $18,%10100100 + !byte $0E,%00101010 + !byte $48,%00101111 + !byte $52,%00100000 + !byte $16,%01000101 + !byte $10,%11010011 + !byte $46,%10001110 + !byte $52,%11001001 + !byte $16,%10100100 + !byte $10,%00001010 + !byte $46,%10101110 + !byte $50,%01000000 + !byte $16,%00100101 + !byte $0A,%11010011 + !byte $46,%00101111 + !byte $50,%10101001 + !byte $16,%11000100 + !byte $0A,%00001010 + !byte $46,%01001111 + !byte $56,%00000000 + !byte $1A,%00100101 + !byte $10,%10110011 + !byte $46,%01101110 + !byte $30,%10000000 + !byte $1A,%11000100 + !byte $10,%00101010 + !byte $46,%01101111 + !byte $30,%00100000 + !byte $18,%10000100 + !byte $0C,%10110011 + !byte $44,%00001111 + !byte $30,%10100000 + !byte $18,%01100101 + !byte $0C,%00101010 + !byte $4A,%10001110 + !byte $30,%10101000 + !byte $1C,%00000101 + !byte $0E,%10010011 + !byte $44,%11001110 + !byte $30,%01100000 + !byte $16,%00000101 + !byte $0E,%01001010 + !byte $4A,%01001111 + !byte $30,%01100001 + !byte $16,%10000100 + !byte $08,%11010011 + !byte $46,%01001110 + !byte $30,%00101000 + !byte $14,%10000100 + !byte $08,%00001010 + !byte $46,%10001111 + !byte $30,%00101001 + !byte $14,%01100101 + !byte $10,%01001010 + !byte $4A,%10101110 + !byte $30,%00000000 + !byte $16,%01100101 + !byte $10,%10010011 + !byte $48,%01001111 + !byte $30,%01000000 + !byte $18,%01100100 + !byte $0A,%10110011 + !byte $4A,%00101111 + !byte $30,%11000000 + !byte $18,%10000101 + !byte $0A,%00101010 + !byte $48,%10001110 + !byte $30,%00000001 + !byte $14,%10000101 + !byte $0C,%01001010 + !byte $46,%00101110 + !byte $30,%00100001 + !byte $14,%01100100 + !byte $0C,%10010011 + !byte $46,%10101111 + !byte $30,%01000001 + !byte $1A,%11000101 + !byte $2E,%11010011 + !byte $4A,%01101110 + !byte $30,%10000001 + !byte $1A,%10100101 + !byte $2E,%10010011 + !byte $4A,%01101111 + !byte $30,%10100001 + !byte $1A,%10000101 + !byte $2E,%00010011 + !byte $42,%11001110 + !byte $30,%11000001 + !byte $1A,%01100101 + !byte $2E,%10010010 + !byte $42,%00001111 + !byte $30,%00000010 + !byte $1A,%01000101 + !byte $2E,%10110010 + !byte $44,%10101110 + !byte $30,%11000111 + !byte $1A,%10100100 + !byte $2E,%01010010 + !byte $44,%00101111 + !byte $30,%00001000 + !byte $1A,%10000100 + !byte $2E,%10101010 + !byte $4A,%11001110 + !byte $30,%01001000 + !byte $1A,%01100100 + !byte $2E,%10110011 + !byte $4C,%01001110 + !byte $30,%01101000 + !byte $1A,%01000100 + !byte $2E,%01110011 + !byte $4C,%10001111 + !byte $30,%10001000 + !byte $1A,%00100100 + !byte $2E,%01010011 + !byte $4A,%00001111 + !byte $30,%11001000 + !byte $1C,%00100101 + !byte $2E,%00110011 + !byte $4C,%01101111 + !byte $30,%00001001 + !byte $1E,%00000101 + !byte $2E,%11010010 + !byte $4C,%01101110 + !byte $30,%01001001 + !byte $1C,%11000100 + !byte $2E,%01110010 + !byte $46,%00001110 + !byte $30,%01101001 + !byte $1A,%00000110 + !byte $2E,%00110010 + !byte $46,%11001111 + !byte $30,%10001001 + !byte $1A,%00000100 + !byte $2E,%00010010 + !byte $48,%01101110 + !byte $30,%10101001 + !byte $14,%01000101 + !byte $2E,%11010001 + !byte $48,%01101111 + !byte $30,%11001001 + !byte $14,%10100100 + !byte $2E,%10110001 + !byte $40,%11001110 + !byte $54,%00100000 + !byte $1A,%11000011 + !byte $2E,%00101100 + !byte $40,%00001111 + !byte $54,%11001001 + !byte $18,%10100101 + !byte $2E,%00001100 + !byte $4A,%01001110 + !byte $30,%00100010 + !byte $1A,%00100110 + !byte $2E,%11001011 + !byte $4A,%10001111 + !byte $52,%01000000 + !byte $18,%01000100 + !byte $2E,%10101011 + !byte $42,%10101110 + !byte $4E,%00000000 + !byte $12,%10100101 + !byte $2E,%10001011 + !byte $42,%00101111 + !byte $52,%10101001 + !byte $12,%01000100 + !byte $2E,%01101011 + !byte $4C,%10001110 + !byte $50,%01100000 + !byte $16,%10000101 + !byte $2E,%01001011 + !byte $4C,%00101110 + !byte $50,%10001001 + !byte $16,%01100100 + !byte $2E,%00101011 + !byte $4C,%01001111 + !byte $58,%00000000 + !byte $1E,%00100101 + !byte $2E,%00001011 + !byte $46,%11001101 + !byte $56,%00100000 + !byte $20,%00000101 + !byte $2E,%11001010 + !byte $4C,%10101111 + !byte $56,%11001001 + !byte $1E,%11000100 + !byte $2E,%10001010 + !byte $46,%00010000 + !byte $4E,%11001001 + !byte $14,%00100101 + !byte $2E,%01101010 + !byte $44,%10001110 + !byte $4E,%00100000 + !byte $14,%11000100 + !byte $2E,%01001010 + !byte $44,%01001111 + !byte $30,%01000010 + !byte $14,%10100101 + !byte $2E,%00101010 + !byte $48,%10001111 + !byte $30,%10100111 + !byte $14,%01000100 + !byte $2E,%00001010 + !byte $4E,%00101110 + !byte $54,%01000000 + !byte $1A,%10100011 + !byte $10,%01101010 + !byte $4E,%10101111 + !byte $54,%10101001 + !byte $1A,%01000110 + !byte $0E,%01110011 + !byte $44,%10001101 + !byte $52,%01100000 + !byte $1C,%01000101 + !byte $0E,%01101010 + !byte $44,%10101101 + !byte $52,%10001001 + !byte $12,%10000101 + !byte $10,%01110011 + !byte $44,%11001101 + !byte $5A,%00000000 + !byte $1C,%10100100 + !byte $06,%11010011 + !byte $44,%00001110 + !byte $4E,%10101001 + !byte $18,%11000101 + !byte $06,%00001010 + !byte $44,%00101110 + !byte $4E,%01000000 + !byte $12,%11000101 + !byte $12,%00001010 + !byte $44,%01001110 + !byte $50,%10000000 + !byte $12,%01100100 + !byte $12,%11010011 + !byte $44,%01101110 + !byte $50,%01101001 + !byte $18,%00100100 + !byte $08,%10110011 + !byte $44,%01101111 + !byte $58,%00100000 + !byte $12,%00100100 + !byte $08,%00101010 + !byte $44,%10001111 + !byte $58,%11001001 + !byte $14,%00000101 + !byte $0A,%01001010 + !byte $44,%10101111 + !byte $56,%10101001 + !byte $10,%00000110 + !byte $2E,%10010001 + !byte $44,%11001111 + !byte $56,%01000000 + !byte $10,%00000100 + !byte $2E,%01001100 + !byte $44,%00010000 + !byte $54,%01100000 + !byte $20,%00100101 + !byte $10,%10001010 + !byte $44,%01010000 + !byte $30,%01100010 + !byte $1A,%01100110 + !byte $0A,%10010011 + !byte $4E,%00001110 + !byte $30,%10000111 + !byte $1A,%10000011 + !byte $10,%01010011 + !byte $48,%01001110 + !byte $4E,%10001001 + !byte $22,%00000101 + !byte $0C,%01101010 + !byte $44,%00110000 + !byte $4E,%01100000 + !byte $20,%11000100 + !byte $12,%10110011 + !byte $44,%01110000 + !byte $54,%10001001 + !byte $16,%10100101 + !byte $0C,%01110011 + !byte $4E,%11001111 + !byte $5C,%00000000 + !byte $16,%01000100 + !byte $12,%00101010 + !byte $44,%01101101 + !byte $52,%10000000 + !byte $12,%10000100 + !byte $04,%11010011 + !byte $3E,%11001110 + !byte $4C,%00000000 + !byte $12,%01100101 + !byte $04,%00001010 + !byte $3E,%00001111 + !byte $52,%01101001 + !byte $18,%00000110 + !byte $0E,%01010011 + !byte $4C,%00101111 + !byte $5A,%11001001 + !byte $18,%00000100 + !byte $0E,%10001010 + !byte $4C,%10101110 + !byte $5A,%00100000 + !byte $1E,%01000101 + !byte $06,%10110011 + !byte $46,%00110000 + !byte $32,%01000000 + !byte $1E,%10100100 + !byte $06,%00101010 + !byte $46,%10101101 + !byte $32,%00000000 + !byte $10,%11000101 + !byte $10,%10101010 + !byte $44,%10010000 + !byte $32,%00000001 + !byte $10,%00100100 + !byte $10,%00110011 + !byte $44,%01001101 + !byte $32,%01100001 + !byte $14,%11000101 + !byte $08,%10010011 + !byte $40,%10101110 + !byte $50,%01001001 + !byte $14,%00100100 + !byte $08,%01001010 + !byte $40,%00101111 + !byte $32,%10000000 + !byte $1C,%10000100 + !byte $12,%01001010 + !byte $4E,%01001110 + !byte $32,%00100001 + !byte $1C,%01100101 + !byte $12,%10010011 + !byte $48,%10101111 + !byte $32,%10000001 + !byte $12,%00000110 + !byte $2E,%01110001 + !byte $4A,%00101110 + !byte $32,%01000010 + !byte $1A,%10000110 + !byte $0A,%01110011 + !byte $4A,%10101111 + !byte $32,%11001000 + !byte $1A,%01100011 + !byte $0A,%01101010 + !byte $4E,%10001111 + !byte $50,%10100000 + !byte $12,%00000100 + !byte $2E,%01101100 + !byte $48,%00101110 + !byte $32,%00100000 + !byte $12,%01000101 + !byte $02,%11010011 + !byte $42,%10001110 + !byte $32,%01100000 + !byte $12,%10100100 + !byte $02,%00001010 + !byte $42,%01001111 + !byte $32,%10100000 + !byte $18,%11000011 + !byte $0C,%01010011 + !byte $50,%11001101 + !byte $32,%11000000 + !byte $10,%00100110 + !byte $0C,%10001010 + !byte $4C,%11001111 + !byte $32,%01000001 + !byte $18,%00100110 + !byte $04,%10110011 + !byte $4C,%00001110 + !byte $32,%10100001 + !byte $22,%00100101 + !byte $04,%00101010 + !byte $50,%00010000 + !byte $32,%11000001 + !byte $22,%11000100 + !byte $0E,%10101010 + !byte $44,%00101101 + !byte $32,%00000010 + !byte $24,%00000101 + !byte $12,%01101010 + !byte $44,%10110000 + !byte $32,%00100010 + !byte $10,%11000011 + !byte $0E,%00110011 + !byte $4C,%11001110 + !byte $32,%10100111 + !byte $1C,%11000110 + !byte $12,%01110011 + !byte $4C,%00001111 + !byte $32,%11000111 + !byte $1C,%10100110 + !byte $06,%01001010 + !byte $46,%01010000 + !byte $32,%00001000 + !byte $1C,%10000110 + !byte $06,%10010011 + !byte $4E,%11001101 + !byte $32,%00101000 + !byte $1C,%01100110 + !byte $14,%00001010 + !byte $3C,%11001110 + !byte $32,%01001000 + !byte $1C,%01000110 + !byte $10,%00010011 + !byte $3C,%00001111 + !byte $32,%01101000 + !byte $1C,%00100110 + !byte $10,%11001010 + !byte $4E,%00010000 + !byte $32,%10001000 + !byte $1C,%00000110 + !byte $14,%11010011 + !byte $46,%10001101 + !byte $32,%10101000 + !byte $1C,%11000101 + !byte $2C,%10110011 + !byte $4E,%01101110 + !byte $32,%00001001 + !byte $1C,%10100101 + !byte $08,%01110011 + !byte $48,%11001111 + !byte $32,%00101001 + !byte $1C,%10000101 + !byte $08,%01101010 + !byte $4E,%01101111 + !byte $32,%01001001 + !byte $1C,%01100100 + !byte $2C,%00110011 + !byte $48,%00001110 + !byte $32,%01101001 + !byte $1C,%01000100 + !byte $2C,%10110010 + !byte $50,%10101101 + !byte $32,%10001001 + !byte $1C,%00100100 + !byte $2C,%10101011 + !byte $50,%00110000 + !byte $32,%10101001 + !byte $1C,%00000100 + !byte $00,%11010011 + !byte $3E,%10101110 + !byte $32,%11001001 + !byte $1C,%11000011 + !byte $2C,%01101010 + !byte $3E,%00101111 + !byte $58,%01000000 + !byte $1C,%10100011 + !byte $2C,%00101010 + !byte $50,%00001110 + !byte $58,%10101001 + !byte $1C,%10000011 + !byte $2C,%11010011 + !byte $50,%11001111 + !byte $4E,%01101001 + !byte $1C,%01100011 + !byte $2C,%10010011 + !byte $40,%10001110 + !byte $32,%10000111 + !byte $1C,%00100011 + !byte $2C,%01110011 + !byte $44,%00001101 + !byte $4E,%10000000 + !byte $10,%10100101 + !byte $2C,%01010011 + !byte $40,%01001111 + !byte $56,%01100000 + !byte $10,%01000100 + !byte $2C,%00010011 + !byte $44,%11010000 + !byte $32,%01100010 + !byte $1C,%01000011 + !byte $2C,%11010010 + !byte $4A,%00001110 + !byte $56,%10001001 + !byte $1C,%00000111 + !byte $2C,%10010010 + !byte $4A,%11001111 + !byte $4C,%11001001 + !byte $20,%10100100 + !byte $2C,%01110010 + !byte $46,%01101101 + !byte $5E,%00000000 + !byte $1C,%00000011 + !byte $2C,%01010010 + !byte $46,%01110000 + !byte $4C,%00100000 + !byte $0E,%01000110 + !byte $2C,%00110010 + !byte $42,%01101110 + !byte $30,%10000010 + !byte $20,%01000101 + !byte $2C,%00010010 + !byte $42,%01101111 + !byte $30,%01100111 + !byte $16,%11000101 + !byte $2C,%11010001 + !byte $52,%10001101 + !byte $54,%01101001 + !byte $16,%00100100 + !byte $2C,%10110001 + !byte $52,%01010000 + !byte $54,%10000000 + !byte $0E,%10100011 + !byte $2C,%10010001 + !byte $4E,%10001110 + !byte $5C,%00100000 + !byte $0E,%00100110 + !byte $2C,%01110001 + !byte $4C,%11001101 + !byte $5C,%11001001 + !byte $0E,%11000011 + !byte $2C,%01101100 + !byte $4C,%00010000 + !byte $52,%10100000 + !byte $1A,%01000011 + !byte $2C,%01001100 + !byte $4E,%01001111 + !byte $52,%01001001 + !byte $1A,%10100110 + !byte $2C,%00101100 + !byte $48,%00010000 + !byte $5A,%01000000 + !byte $1E,%01100101 + !byte $2C,%00001100 + !byte $48,%11001101 + !byte $4E,%10100000 + !byte $1E,%10000100 + !byte $2C,%11001011 + !byte $3A,%11001110 + !byte $4E,%01001001 + !byte $1C,%00100111 + !byte $2C,%10001011 + !byte $3A,%00001111 + !byte $5A,%10101001 + !byte $1C,%11000010 + !byte $2C,%01101011 + !byte $50,%00101110 + !byte $50,%11000000 + !byte $12,%00100101 + !byte $2C,%01001011 + !byte $50,%10101111 + !byte $50,%00101001 + !byte $14,%00000110 + !byte $2C,%00101011 + !byte $4E,%10101101 + !byte $4C,%01000000 + !byte $14,%00000100 + !byte $2C,%00001011 + !byte $3C,%00101111 + !byte $4C,%10101001 + !byte $18,%10100011 + !byte $2C,%11001010 + !byte $4E,%00110000 + !byte $58,%01100000 + !byte $12,%11000100 + !byte $2C,%10101010 + !byte $3C,%10101110 + !byte $58,%10001001 + !byte $18,%01000110 + !byte $2C,%10001010 + !byte $44,%11001100 + !byte $32,%10000010 + !byte $10,%10000101 + !byte $2C,%01001010 + !byte $44,%00010001 + !byte $32,%01100111 + !byte $12,%00100110 + !byte $2C,%00001010 + !byte $52,%00110000 + !byte $56,%10000000 + !byte $24,%00100101 + !byte $00,%00001010 + !byte $52,%10101101 + !byte $56,%01101001 + !byte $12,%11000011 + !byte $0A,%01010011 + !byte $50,%10001101 + !byte $4E,%11000000 + !byte $10,%01100100 + !byte $2E,%01010001 + !byte $3E,%10001110 + !byte $5E,%00100000 + !byte $1C,%10100010 + !byte $2E,%10001100 + !byte $46,%01001101 + !byte $5E,%11001001 + !byte $24,%11000100 + !byte $0A,%10001010 + !byte $3E,%01001111 + !byte $4E,%00101001 + !byte $26,%00000101 + !byte $12,%10001010 + !byte $50,%01010000 + !byte $30,%10100010 + !byte $1C,%01000111 + !byte $02,%00101010 + !byte $46,%10010000 + !byte $4C,%10001001 + !byte $0E,%00000110 + !byte $12,%01010011 + !byte $4E,%10101110 + !byte $54,%10100000 + !byte $10,%10100011 + !byte $02,%10110011 + !byte $4E,%00101111 + !byte $30,%01000111 + !byte $10,%01000110 + !byte $0C,%00110011 + !byte $48,%00110000 + !byte $54,%01001001 + !byte $0E,%00000100 + !byte $0C,%10101010 + !byte $40,%01101110 + !byte $5C,%01000000 + !byte $22,%01000101 + !byte $04,%10010011 + !byte $40,%01101111 + !byte $5C,%10101001 + !byte $22,%10100100 + !byte $14,%00101010 + !byte $52,%01110000 + !byte $4C,%01100000 + !byte $1A,%11000110 + !byte $14,%10110011 + !byte $48,%10101101 + !byte $52,%00101001 + !byte $1A,%00100011 + !byte $04,%01001010 + !byte $52,%01101101 + !byte $52,%11000000 + !byte $0C,%01100110 + !byte $0E,%00010011 + !byte $42,%10001100 + !byte $4A,%00000000 + !byte $12,%00000101 + !byte $0E,%11001010 + !byte $42,%10101100 + !byte $5A,%01100000 + !byte $18,%01100110 + !byte $06,%01110011 + !byte $42,%11001100 + !byte $5A,%10001001 + !byte $20,%10000100 + !byte $06,%01101010 + !byte $42,%00001101 + !byte $50,%00000001 + !byte $0E,%10000011 + !byte $10,%11010010 + !byte $42,%00101101 + !byte $50,%00001001 + !byte $18,%10000011 + !byte $10,%00001011 + !byte $42,%01001101 + !byte $4E,%00001001 + !byte $20,%01100101 + !byte $12,%10101010 + !byte $42,%01101101 + !byte $4E,%00000001 + !byte $0C,%10000011 + !byte $2C,%01010001 + !byte $42,%10001101 + !byte $58,%10000000 + !byte $0E,%01100110 + !byte $08,%01010011 + !byte $42,%10101101 + !byte $58,%01101001 + !byte $16,%00000110 + !byte $2C,%10001100 + !byte $42,%11001101 + !byte $4C,%10000000 + !byte $16,%00000100 + !byte $08,%10001010 + !byte $42,%00001110 + !byte $4C,%01101001 + !byte $10,%10000100 + !byte $12,%00110011 + !byte $42,%00101110 + !byte $32,%10100010 + !byte $10,%01100101 + !byte $14,%01001010 + !byte $42,%01001110 + !byte $4A,%11001001 + !byte $0C,%10000110 + !byte $00,%10110011 + !byte $42,%10001111 + !byte $5E,%01000000 + !byte $1E,%10000101 + !byte $00,%00101010 + !byte $42,%10101111 + !byte $56,%10100000 + !byte $1E,%01100100 + !byte $00,%11001110 + !byte $42,%11001111 + !byte $56,%01001001 + !byte $0C,%01100011 + !byte $00,%00001111 + !byte $42,%00010000 + !byte $32,%01000111 + !byte $1C,%01100111 + !byte $2E,%10101100 + !byte $42,%00110000 + !byte $5E,%10101001 + !byte $1C,%10000010 + !byte $14,%10010011 + !byte $42,%01010000 + !byte $54,%11000000 + !byte $0E,%11000101 + !byte $2E,%00110001 + !byte $42,%01110000 + !byte $4A,%00100000 + !byte $14,%11000011 + !byte $0A,%00110011 + !byte $42,%10010000 + !byte $34,%01100000 + !byte $14,%00100110 + !byte $0A,%10101010 + !byte $42,%10110000 + !byte $34,%00000001 + !byte $26,%11000100 + !byte $02,%10010011 + !byte $42,%11010000 + !byte $34,%01100001 + !byte $0E,%00100100 + !byte $02,%01001010 + !byte $42,%00110001 + !byte $34,%00100010 + !byte $28,%00000101 + !byte $0C,%11001010 + !byte $42,%01010001 + !byte $34,%10000010 + !byte $1A,%00000011 + !byte $0C,%00010011 + !byte $42,%00010001 + !byte $34,%11001000 + !byte $26,%00100101 + !byte $12,%11001010 + !byte $42,%01110001 + !byte $34,%11001001 + !byte $1A,%00000111 + !byte $04,%01110011 + !byte $42,%01101100 + !byte $30,%11000010 + !byte $12,%01000110 + !byte $04,%01101010 + !byte $50,%01001110 + !byte $30,%00100111 + !byte $24,%01000101 + !byte $12,%00010011 + !byte $4A,%11001101 + !byte $54,%00101001 + !byte $24,%10100100 + !byte $0E,%11010010 + !byte $38,%00001111 + !byte $34,%00000000 + !byte $12,%10100011 + !byte $00,%00101111 + !byte $4A,%00010000 + !byte $34,%00100000 + !byte $0C,%10100011 + !byte $0E,%00001011 + !byte $50,%10001111 + !byte $34,%01000000 + !byte $0C,%01000110 + !byte $00,%10101110 + !byte $44,%10101100 + !byte $34,%10000000 + !byte $18,%10000110 + !byte $14,%01110011 + !byte $38,%11001110 + !byte $34,%10100000 + !byte $18,%01100011 + !byte $14,%01101010 + !byte $44,%00110001 + !byte $34,%11000000 + !byte $10,%10100100 + !byte $06,%01010011 + !byte $52,%11001101 + !byte $34,%00100001 + !byte $10,%01000101 + !byte $06,%10001010 + !byte $54,%01001101 + !byte $34,%01000001 + !byte $10,%01100110 + !byte $10,%00101011 + !byte $4C,%10101101 + !byte $34,%10000001 + !byte $22,%01100101 + !byte $10,%10110010 + !byte $4C,%00110000 + !byte $34,%10100001 + !byte $10,%10000011 + !byte $16,%00001010 + !byte $52,%00010000 + !byte $34,%11000001 + !byte $16,%11000011 + !byte $2C,%00110001 + !byte $42,%01001100 + !byte $34,%00000010 + !byte $22,%10000100 + !byte $16,%11010011 + !byte $42,%10010001 + !byte $34,%01000010 + !byte $16,%00100110 + !byte $2C,%10101100 + !byte $46,%10110000 + !byte $34,%01100010 + !byte $0A,%10100110 + !byte $08,%10101010 + !byte $3A,%10101110 + !byte $34,%01100111 + !byte $0A,%01000011 + !byte $08,%00110011 + !byte $3A,%00101111 + !byte $34,%10000111 + !byte $1C,%01100010 + !byte $00,%10010011 + !byte $54,%10010000 + !byte $34,%10100111 + !byte $1C,%10000111 + !byte $12,%00001011 + !byte $46,%00101101 + !byte $34,%11000111 + !byte $0E,%10100101 + !byte $00,%01001010 + !byte $4E,%10001101 + !byte $34,%00001000 + !byte $20,%10000101 + !byte $0A,%00010011 + !byte $4E,%11001110 + !byte $34,%00101000 + !byte $20,%01100100 + !byte $2E,%00010001 + !byte $4E,%00001111 + !byte $34,%01001000 + !byte $0E,%01100011 + !byte $2E,%11001100 + !byte $48,%01010000 + !byte $34,%01101000 + !byte $0E,%01000100 + !byte $12,%11010010 + !byte $54,%01101101 + !byte $34,%10001000 + !byte $0E,%10000110 + !byte $14,%10001010 + !byte $3C,%10001110 + !byte $34,%10101000 + !byte $1A,%11000010 + !byte $0A,%11001010 + !byte $3C,%01001111 + !byte $34,%00001001 + !byte $1A,%00100111 + !byte $02,%01110011 + !byte $4E,%01010000 + !byte $34,%00101001 + !byte $0C,%00100110 + !byte $02,%01101010 + !byte $54,%01110000 + !byte $34,%01001001 + !byte $28,%00100101 + !byte $00,%10001110 + !byte $48,%10001101 + !byte $34,%01101001 + !byte $2A,%00000101 + !byte $00,%01001111 + !byte $42,%10110001 + !byte $34,%10001001 + !byte $28,%11000100 + !byte $0C,%11010010 + !byte $42,%00101100 + !byte $34,%10101001 + !byte $0C,%01000011 + !byte $14,%01010011 + !byte $50,%01101111 + !byte $4E,%11001000 + !byte $0C,%11000011 + !byte $0C,%00001011 + !byte $50,%01101110 + !byte $5C,%01100000 + !byte $18,%10100110 + !byte $16,%10110011 + !byte $50,%01101101 + !byte $5C,%10001001 + !byte $18,%01000011 + !byte $16,%00101010 + !byte $3E,%01101110 + !byte $4E,%00100001 + !byte $1E,%10100101 + !byte $04,%10001010 + !byte $3E,%01101111 + !byte $52,%00000001 + !byte $1E,%01000100 + !byte $2A,%11010011 + !byte $50,%01110000 + !byte $52,%00001001 + !byte $0C,%10100110 + !byte $2A,%01010010 + !byte $44,%01010001 + !byte $4C,%01001001 + !byte $14,%01000110 + !byte $2A,%00101010 + !byte $44,%10001100 + !byte $5A,%10000000 + !byte $26,%10100100 + !byte $2A,%10110011 + !byte $36,%11001110 + !byte $4C,%10100000 + !byte $14,%10100011 + !byte $2A,%01110011 + !byte $52,%00001110 + !byte $5A,%01101001 + !byte $0A,%01100011 + !byte $2A,%01010011 + !byte $36,%00001111 + !byte $50,%00100001 + !byte $10,%00100101 + !byte $2A,%00110011 + !byte $52,%10010000 + !byte $4A,%10101001 + !byte $10,%11000100 + !byte $2A,%00010010 + !byte $52,%11001111 + !byte $4A,%01000000 + !byte $0A,%10000110 + !byte $2A,%01001011 + !byte $46,%11010000 + !byte $50,%11001000 + !byte $26,%01000101 + !byte $2A,%10101010 + !byte $40,%01001110 + !byte $5E,%00000101 + !byte $1E,%00001000 + !byte $2A,%01101010 + !byte $40,%10001111 + !byte $58,%01001001 + !byte $1E,%11000111 + !byte $04,%01010011 + !byte $52,%01001101 + !byte $34,%10100010 + !byte $1E,%10100111 + !byte $2A,%10010011 + !byte $46,%00001101 + !byte $34,%01000111 + !byte $1E,%10000111 + !byte $2A,%00010011 + !byte $4A,%10101101 + !byte $58,%10100000 + !byte $1E,%01100111 + !byte $2A,%11010010 + !byte $4A,%00110000 + !byte $4E,%10101000 + !byte $1E,%01000111 + !byte $2A,%10110010 + !byte $38,%10101110 + !byte $32,%11000010 + !byte $1E,%00100111 + !byte $2A,%10010010 + !byte $54,%01010000 + !byte $32,%00100111 + !byte $1E,%00000111 + !byte $2A,%01110010 + !byte $48,%01110000 + !byte $56,%00101001 + !byte $1E,%11000110 + !byte $2A,%00110010 + !byte $54,%10001101 + !byte $4E,%01000001 + !byte $1E,%10100110 + !byte $2A,%11010001 + !byte $38,%00101111 + !byte $56,%11000000 + !byte $1E,%10000110 + !byte $2A,%10110001 + !byte $42,%00001100 + !byte $5E,%01100000 + !byte $1E,%01100110 + !byte $2A,%10010001 + !byte $54,%10110000 + !byte $5E,%10001001 + !byte $1E,%01000110 + !byte $2A,%01110001 + !byte $48,%01101101 + !byte $30,%00000111 + !byte $1E,%00100110 + !byte $2A,%01010001 + !byte $54,%00101101 + !byte $54,%00001001 + !byte $1E,%00000110 + !byte $2A,%10001100 + !byte $4C,%10001101 + !byte $4C,%11000000 + !byte $1E,%11000101 + !byte $2A,%01101100 + !byte $3A,%01001111 + !byte $4C,%00101001 + !byte $1E,%00100100 + !byte $2A,%01001100 + !byte $4C,%01010000 + !byte $54,%00000001 + !byte $1E,%00000100 + !byte $2A,%00101100 + !byte $42,%11010001 + !byte $30,%00000011 + !byte $1E,%11000011 + !byte $2A,%00001100 + !byte $56,%00101101 + !byte $5C,%10000000 + !byte $1E,%10100011 + !byte $2A,%11001011 + !byte $50,%10001110 + !byte $5E,%00100101 + !byte $1E,%10000011 + !byte $2A,%10101011 + !byte $3A,%10001110 + !byte $4A,%01100000 + !byte $1E,%01100011 + !byte $2A,%10001011 + !byte $50,%01001111 + !byte $5C,%01101001 + !byte $1E,%01000011 + !byte $2A,%01101011 + !byte $44,%01101100 + !byte $4A,%10001001 + !byte $1E,%00100011 + !byte $2A,%00101011 + !byte $56,%10110000 + !byte $5E,%11000100 + !byte $1E,%00000011 + !byte $2A,%00001011 + !byte $56,%00001101 + !byte $52,%11001000 + !byte $1E,%11000010 + !byte $2A,%11001010 + !byte $56,%11010000 + !byte $52,%00100001 + !byte $1E,%10100010 + !byte $2A,%10001010 + !byte $52,%00101110 + !byte $48,%00000000 + !byte $1E,%01000010 + !byte $2A,%01001010 + !byte $44,%01110001 + !byte $5A,%10100000 + !byte $1E,%00100010 + !byte $2A,%00001010 + !byte $4E,%01101101 + !byte $5A,%01001001 + !byte $16,%10100011 + !byte $0E,%10110010 + !byte $3C,%01101110 + !byte $50,%01000001 + !byte $0A,%00100011 + !byte $0E,%00101011 + !byte $3C,%01101111 + !byte $50,%10101000 + !byte $16,%01000110 + !byte $06,%00110011 + !byte $4E,%01110000 + !byte $58,%11000000 + !byte $1E,%10000010 + !byte $2A,%00110001 + !byte $52,%10101111 + !byte $58,%00101001 + !byte $1E,%00000010 + !byte $2A,%10101100 + !byte $46,%11001100 + !byte $34,%11000010 + !byte $0A,%11000110 + !byte $06,%10101010 + !byte $46,%00010001 + !byte $34,%00100111 + !byte $1E,%01100010 + !byte $12,%00101011 + !byte $54,%10101101 + !byte $4C,%00000001 + !byte $1C,%01000010 + !byte $12,%10110010 + !byte $34,%11001110 + !byte $4C,%00001001 + !byte $12,%10000011 + !byte $10,%10010010 + !byte $50,%01001101 + !byte $4E,%10001000 + !byte $1C,%10100111 + !byte $10,%01001011 + !byte $3E,%01001110 + !byte $4A,%01101001 + !byte $12,%01100110 + !byte $00,%01101111 + !byte $34,%00001111 + !byte $4E,%01100001 + !byte $24,%01100101 + !byte $08,%00010011 + !byte $3E,%10001111 + !byte $5E,%10100100 + !byte $24,%10000100 + !byte $2C,%00010001 + !byte $50,%10010000 + !byte $56,%00000001 + !byte $0E,%01100100 + !byte $2C,%11001100 + !byte $54,%00110000 + !byte $56,%00001001 + !byte $0E,%10000101 + !byte $14,%00110011 + !byte $48,%10010000 + !byte $5E,%01000101 + !byte $1E,%00101000 + !byte $00,%01101110 + !byte $48,%01001101 + !byte $32,%00000011 + !byte $1E,%11000001 + !byte $14,%10101010 + !byte $36,%10101110 + !byte $32,%00000111 + !byte $1A,%10100010 + !byte $08,%11001010 + !byte $56,%01001101 + !byte $4A,%10000000 + !byte $1A,%01000111 + !byte $00,%01101010 + !byte $36,%00101111 + !byte $48,%11001001 + !byte $0C,%00000110 + !byte $00,%01110011 + !byte $42,%11001011 + !byte $5E,%10000000 + !byte $10,%10000110 + !byte $02,%00001111 + !byte $50,%10101110 + !byte $5E,%01101001 + !byte $22,%10000101 + !byte $0A,%00001011 + !byte $56,%10010000 + !byte $30,%00100011 + !byte $22,%01100100 + !byte $16,%10010011 + !byte $50,%00101111 + !byte $30,%11000110 + !byte $10,%01100011 + !byte $2E,%11010000 + !byte $42,%00010010 + !byte $48,%00100000 + !byte $0C,%00000100 + !byte $2E,%00001101 + !byte $40,%00101110 + !byte $54,%00100001 + !byte $08,%00000111 + !byte $16,%01001010 + !byte $40,%10101111 + !byte $54,%11001000 + !byte $18,%11000110 + !byte $0A,%11010010 + !byte $52,%10110000 + !byte $5C,%10100000 + !byte $18,%00100011 + !byte $02,%11001110 + !byte $52,%00101101 + !byte $5C,%01001001 + !byte $2A,%11000100 + !byte $02,%01010011 + !byte $4A,%10001101 + !byte $4C,%11001000 + !byte $08,%00000011 + !byte $02,%10001010 + !byte $4A,%01010000 + !byte $52,%10101000 + !byte $2C,%00000101 + !byte $12,%10010010 + !byte $44,%10010001 + !byte $4C,%00100001 + !byte $0A,%10000011 + !byte $0C,%10110010 + !byte $38,%01001111 + !byte $52,%01000001 + !byte $10,%00000101 + !byte $0C,%00101011 + !byte $44,%01001100 + !byte $5E,%10000100 + !byte $0A,%01100110 + !byte $12,%01001011 + !byte $52,%01001110 + !byte $5A,%11000000 + !byte $0E,%10100110 + !byte $14,%11001010 + !byte $38,%10001110 + !byte $5A,%00101001 + !byte $20,%10100101 + !byte $04,%00110011 + !byte $58,%11001100 + !byte $4A,%01001001 + !byte $20,%01000100 + !byte $04,%10101010 + !byte $54,%00001101 + !byte $4A,%10100000 + !byte $0E,%01000011 + !byte $00,%10001111 + !byte $58,%00010001 + !byte $5E,%01100101 + !byte $1E,%01001000 + !byte $00,%01001110 + !byte $52,%10001111 + !byte $48,%10101001 + !byte $16,%10000011 + !byte $0E,%10010010 + !byte $54,%11010000 + !byte $50,%01100001 + !byte $2A,%00100101 + !byte $14,%00010011 + !byte $46,%10101100 + !byte $50,%10001000 + !byte $16,%01100110 + !byte $16,%01101010 + !byte $46,%00110001 + !byte $36,%00100000 + !byte $1E,%10100001 + !byte $0E,%01001011 + !byte $54,%11001101 + !byte $36,%11001001 + !byte $1C,%11000111 + !byte $06,%11001010 + !byte $4C,%01101101 + !byte $36,%01000000 + !byte $28,%01000101 + !byte $02,%10101110 + !byte $4C,%01110000 + !byte $36,%00000001 + !byte $0E,%01100101 + !byte $2A,%00010001 + !byte $54,%00010000 + !byte $36,%11000001 + !byte $08,%11000110 + !byte $2A,%11001100 + !byte $3A,%01101110 + !byte $34,%00000111 + !byte $0C,%11000110 + !byte $02,%00101111 + !byte $3A,%01101111 + !byte $36,%10100000 + !byte $28,%10100100 + !byte $06,%00010011 + !byte $48,%10110000 + !byte $36,%11000000 + !byte $08,%00100011 + !byte $16,%01110011 + !byte $56,%11001100 + !byte $36,%10000001 + !byte $0E,%10000100 + !byte $10,%01101011 + !byte $56,%00010001 + !byte $36,%01101000 + !byte $1C,%00100010 + !byte $10,%01110010 + !byte $48,%00101101 + !byte $36,%01101001 + !byte $0C,%00100011 + !byte $18,%00001010 + !byte $32,%11001110 + !byte $34,%00000011 + !byte $14,%01100110 + !byte $2C,%11010000 + !byte $4E,%01001101 + !byte $36,%00000000 + !byte $26,%10000100 + !byte $2C,%00001101 + !byte $4E,%10010000 + !byte $36,%01100000 + !byte $14,%10000011 + !byte $08,%11010010 + !byte $42,%10101011 + !byte $36,%10000000 + !byte $1A,%10000010 + !byte $08,%00001011 + !byte $42,%00110010 + !byte $36,%00100001 + !byte $1A,%01100111 + !byte $18,%11010011 + !byte $40,%01101011 + !byte $36,%01000001 + !byte $0A,%00000111 + !byte $12,%01101011 + !byte $40,%10001011 + !byte $36,%01100001 + !byte $26,%01100101 + !byte $12,%01110010 + !byte $40,%11001011 + !byte $36,%10100001 + !byte $0C,%11000101 + !byte $00,%10001010 + !byte $40,%00101100 + !byte $36,%00000010 + !byte $0C,%00100100 + !byte $2E,%00101101 + !byte $40,%01001100 + !byte $36,%00100010 + !byte $18,%00000111 + !byte $00,%01010011 + !byte $40,%01101100 + !byte $36,%01000010 + !byte $18,%00000011 + !byte $2E,%10110000 + !byte $40,%10001100 + !byte $36,%01100010 + !byte $0A,%00000011 + !byte $14,%11010010 + !byte $40,%10101100 + !byte $36,%10000010 + !byte $0A,%01000110 + !byte $14,%00001011 + !byte $40,%11001100 + !byte $36,%10100010 + !byte $12,%10000110 + !byte $00,%10101111 + !byte $40,%00001101 + !byte $36,%11000010 + !byte $12,%01100011 + !byte $0A,%10110010 + !byte $40,%00101101 + !byte $36,%00100111 + !byte $1E,%01101000 + !byte $0A,%00101011 + !byte $40,%01001101 + !byte $36,%01000111 + !byte $24,%10000101 + !byte $00,%00101110 + !byte $40,%01101101 + !byte $36,%01100111 + !byte $24,%01100100 + !byte $02,%10101010 + !byte $40,%10001101 + !byte $36,%10000111 + !byte $1E,%10000001 + !byte $16,%10001010 + !byte $40,%10101101 + !byte $36,%10100111 + !byte $0A,%10100011 + !byte $02,%00110011 + !byte $40,%11001101 + !byte $36,%11000111 + !byte $16,%10000110 + !byte $02,%01001111 + !byte $40,%00001110 + !byte $36,%00001000 + !byte $1C,%00001000 + !byte $02,%10001110 + !byte $40,%11001111 + !byte $36,%00101000 + !byte $16,%01100011 + !byte $16,%01010011 + !byte $40,%00010000 + !byte $36,%01001000 + !byte $2C,%00100101 + !byte $0C,%01001011 + !byte $40,%00110000 + !byte $36,%10001000 + !byte $08,%00100111 + !byte $0C,%10010010 + !byte $40,%01010000 + !byte $36,%10101000 + !byte $2E,%00000101 + !byte $04,%00010011 + !byte $40,%01110000 + !byte $36,%11001000 + !byte $08,%11000010 + !byte $18,%00101010 + !byte $40,%10110000 + !byte $36,%00001001 + !byte $0E,%01000101 + !byte $04,%11001010 + !byte $40,%00010001 + !byte $36,%00101001 + !byte $10,%10100110 + !byte $18,%10110011 + !byte $40,%01010001 + !byte $36,%01001001 + !byte $22,%10100101 + !byte $12,%10001011 + !byte $40,%01110001 + !byte $36,%10001001 + !byte $2C,%11000100 + !byte $0E,%01101011 + !byte $40,%10010001 + !byte $36,%10101001 + !byte $22,%01000100 + !byte $0E,%01110010 + !byte $40,%10110001 + !byte $58,%00000001 + !byte $10,%01000011 + !byte $2A,%00001101 + !byte $40,%01010010 + !byte $58,%00001001 + !byte $1C,%00000010 + !byte $12,%01010010 + !byte $40,%01110010 + !byte $5C,%00000101 + !byte $08,%10100110 + !byte $06,%00001011 + !byte $50,%11001110 + !byte $48,%01000000 + !byte $08,%01000011 + !byte $06,%11010010 + !byte $3C,%01001110 + !byte $4E,%10000001 + !byte $0E,%10100100 + !byte $2A,%11010000 + !byte $32,%00001111 + !byte $4E,%01101000 + !byte $1A,%10000111 + !byte $14,%00101011 + !byte $3C,%10001111 + !byte $32,%00100011 + !byte $06,%00100111 + !byte $00,%11001111 + !byte $50,%00001111 + !byte $4C,%10101000 + !byte $06,%01000111 + !byte $00,%00001110 + !byte $40,%10101011 + !byte $32,%11000110 + !byte $2A,%01000101 + !byte $14,%10110010 + !byte $40,%00001100 + !byte $5E,%10100000 + !byte $2A,%10100100 + !byte $10,%01010010 + !byte $40,%10010000 + !byte $56,%00100001 + !byte $0C,%01000100 + !byte $10,%10001011 + !byte $40,%11010001 + !byte $56,%11001000 + !byte $1A,%01100010 + !byte $2C,%00101101 + !byte $40,%00010010 + !byte $4C,%01000001 + !byte $06,%10100010 + !byte $08,%10110010 + !byte $40,%00110010 + !byte $5E,%01001001 + !byte $0C,%10100101 + !byte $2C,%10110000 + !byte $56,%01101101 + !byte $5E,%01100100 + !byte $0E,%11000110 + !byte $08,%00101011 + !byte $56,%01110000 + !byte $5E,%10000101 + !byte $20,%11000101 + !byte $16,%10101010 + !byte $40,%11010000 + !byte $54,%01000001 + !byte $20,%00100100 + !byte $02,%01101111 + !byte $40,%00110001 + !byte $30,%01000011 + !byte $06,%11000010 + !byte $02,%01101110 + !byte $58,%10101100 + !byte $30,%10100110 + !byte $0E,%00100011 + !byte $16,%00110011 + !byte $34,%00101111 + !byte $4A,%11000000 + !byte $18,%00100111 + !byte $28,%00101010 + !byte $58,%00001101 + !byte $5C,%11000000 + !byte $18,%11000010 + !byte $28,%01110011 + !byte $40,%01001011 + !byte $54,%10101000 + !byte $28,%01100101 + !byte $28,%10110010 + !byte $44,%10110001 + !byte $4A,%00101001 + !byte $28,%10000100 + !byte $00,%00110011 + !byte $58,%00110001 + !byte $48,%10001001 + !byte $1E,%10001000 + !byte $00,%10101010 + !byte $44,%00101100 + !byte $5C,%00101001 + !byte $1E,%01100001 + !byte $28,%10010011 + !byte $40,%10010010 + !byte $5C,%11000100 + !byte $0A,%00100110 + !byte $28,%01010011 + !byte $52,%01101110 + !byte $5C,%00100101 + !byte $0C,%00000011 + !byte $28,%00110010 + !byte $50,%00101101 + !byte $52,%10001000 + !byte $0C,%00000111 + !byte $28,%11010001 + !byte $3E,%00101110 + !byte $48,%01100000 + !byte $16,%01000011 + !byte $28,%10101011 + !byte $3E,%10101111 + !byte $5A,%00000001 + !byte $0A,%11000011 + !byte $28,%11001010 + !byte $58,%11010000 + !byte $52,%01100001 + !byte $16,%10100110 + !byte $28,%10001010 + !byte $34,%10101110 + !byte $5A,%00001001 + !byte $14,%10000110 + !byte $28,%11010011 + !byte $50,%10110000 + !byte $36,%00000011 + !byte $26,%10000101 + !byte $28,%10110011 + !byte $52,%01101111 + !byte $36,%00000111 + !byte $14,%01100011 + !byte $28,%00110011 + !byte $46,%10001100 + !byte $4C,%01100001 + !byte $08,%01100011 + !byte $28,%00010011 + !byte $36,%10001110 + !byte $46,%00000000 + !byte $26,%01100100 + !byte $28,%11010010 + !byte $46,%01010001 + !byte $4C,%10001000 + !byte $0E,%11000100 + !byte $28,%10010010 + !byte $52,%00001101 + !byte $50,%10000001 + !byte $1C,%11000001 + !byte $28,%01110010 + !byte $36,%01001111 + !byte $50,%01101000 + !byte $1C,%00101000 + !byte $28,%01010010 + !byte $54,%00001110 + !byte $4A,%00001001 + !byte $0E,%00100101 + !byte $28,%00010010 + !byte $54,%11001111 + !byte $58,%00100001 + !byte $08,%10000110 + !byte $28,%10110001 + !byte $52,%11010000 + !byte $34,%00100011 + !byte $0A,%00100111 + !byte $28,%10010001 + !byte $48,%11010000 + !byte $34,%11000110 + !byte $0A,%11000010 + !byte $28,%01110001 + !byte $4A,%01110000 + !byte $58,%11001000 + !byte $2E,%00100101 + !byte $28,%01010001 + !byte $40,%00101011 + !byte $5E,%01000100 + !byte $2E,%11000100 + !byte $28,%00110001 + !byte $4A,%01101101 + !byte $5E,%10100101 + !byte $1A,%01000010 + !byte $28,%00010001 + !byte $48,%00001101 + !byte $4E,%10100001 + !byte $12,%01000011 + !byte $28,%11001100 + !byte $40,%10110010 + !byte $4E,%01001000 + !byte $12,%10100110 + !byte $28,%10101100 + !byte $42,%01010010 + !byte $4A,%00000001 + !byte $1A,%10100111 + !byte $28,%10001100 + !byte $5A,%10001100 + !byte $48,%01101001 + !byte $24,%10100101 + !byte $28,%01101100 + !byte $38,%01101110 + !byte $32,%01000011 + !byte $24,%01000100 + !byte $28,%01001100 + !byte $38,%01101111 + !byte $32,%10100110 + !byte $06,%00000011 + !byte $28,%00101100 + !byte $56,%10001101 + !byte $48,%10000000 + !byte $0C,%10000101 + !byte $28,%00001100 + !byte $56,%01010000 + !byte $5C,%10100100 + !byte $0C,%01100100 + !byte $28,%11001011 + !byte $42,%10001011 + !byte $56,%01000001 + !byte $2C,%01000101 + !byte $28,%10001011 + !byte $54,%00010001 + !byte $56,%10101000 + !byte $08,%01000111 + !byte $28,%01101011 + !byte $5A,%01010001 + !byte $5C,%01000101 + !byte $08,%10100010 + !byte $28,%01001011 + !byte $30,%00001111 + !byte $5E,%00101001 + !byte $06,%00000111 + !byte $28,%00101011 + !byte $54,%11001100 + !byte $5E,%11000000 + !byte $2C,%10100100 + !byte $28,%00001011 + !byte $44,%00001100 + !byte $30,%01100011 + !byte $18,%10100010 + !byte $28,%10101010 + !byte $4C,%01001101 + !byte $30,%10000110 + !byte $18,%01000111 + !byte $28,%01101010 + !byte $30,%11001110 + !byte $46,%00100000 + !byte $1E,%01000001 + !byte $28,%01001010 + !byte $3A,%01001110 + !byte $54,%01100001 + !byte $10,%11000110 + !byte $28,%00001010 + !byte $4C,%10010000 + !byte $54,%10001000 + !byte $22,%11000101 + !byte $0A,%10010010 + !byte $44,%11010001 + !byte $46,%11001001 + !byte $22,%00100100 + !byte $04,%00001111 + !byte $3A,%10001111 + !byte $4C,%10000001 + !byte $10,%00100011 + !byte $2E,%10010000 + !byte $52,%10001110 + !byte $5C,%00000001 + !byte $04,%10000010 + !byte $2E,%01001101 + !byte $52,%01001111 + !byte $5C,%00001001 + !byte $0A,%00000110 + !byte $18,%01001010 + !byte $58,%00101101 + !byte $4C,%01101000 + !byte $0A,%00000100 + !byte $04,%11001110 + !byte $58,%10110000 + !byte $4A,%00100001 + !byte $1E,%10101000 + !byte $18,%10010011 + !byte $56,%10101100 + !byte $5E,%00100100 + !byte $04,%01100111 + !byte $0A,%01001011 + !byte $32,%10101110 + !byte $52,%10000001 + !byte $06,%01100111 + !byte $12,%10101011 + !byte $56,%00110001 + !byte $52,%01101000 + !byte $06,%10000010 + !byte $12,%00110010 + !byte $46,%01110001 + !byte $5E,%11000101 + !byte $16,%11000110 + !byte $02,%11001010 + !byte $4E,%00101101 + !byte $4A,%11001000 + !byte $2A,%01100101 + !byte $02,%00010011 + !byte $3C,%10101111 + !byte $5A,%00100001 + !byte $2A,%10000100 + !byte $00,%00010000 + !byte $4E,%10110000 + !byte $5A,%11001000 + !byte $16,%00100011 + !byte $0C,%01110010 + !byte $46,%01101100 + !byte $36,%00100011 + !byte $20,%00001001 + !byte $00,%11001101 + !byte $32,%00101111 + !byte $36,%11000110 + !byte $20,%11001000 + !byte $14,%01001011 + !byte $54,%00101110 + !byte $48,%01001001 + !byte $20,%01101000 + !byte $0C,%01101011 + !byte $5A,%10101100 + !byte $48,%10100000 + !byte $20,%00101000 + !byte $14,%10010010 + !byte $3C,%00101110 + !byte $5C,%10000100 + !byte $20,%00001000 + !byte $04,%00001011 + !byte $5A,%00110001 + !byte $50,%10100001 + !byte $20,%11000111 + !byte $28,%11010000 + !byte $54,%10101111 + !byte $5C,%01100101 + !byte $20,%10100111 + !byte $28,%00001101 + !byte $40,%00001011 + !byte $50,%01001000 + !byte $20,%10000111 + !byte $04,%11010010 + !byte $58,%10001100 + !byte $34,%01000011 + !byte $20,%01100111 + !byte $02,%10001111 + !byte $34,%10001110 + !byte $34,%10100110 + !byte $20,%01000111 + !byte $02,%01001110 + !byte $34,%01001111 + !byte $58,%10101000 + !byte $20,%00100111 + !byte $16,%00010011 + !byte $40,%11010010 + !byte $46,%01000000 + !byte $20,%00000111 + !byte $16,%11001010 + !byte $48,%00010001 + !byte $46,%10101001 + !byte $20,%11000110 + !byte $0E,%01010010 + !byte $48,%11001100 + !byte $58,%01000001 + !byte $20,%10100110 + !byte $0E,%10001011 + !byte $42,%01101011 + !byte $5A,%00000101 + !byte $20,%10000110 + !byte $06,%10110010 + !byte $58,%01010001 + !byte $4C,%01001000 + !byte $20,%01100110 + !byte $2A,%10110000 + !byte $42,%01110010 + !byte $4E,%11000001 + !byte $20,%01000110 + !byte $2A,%00101101 + !byte $50,%00001101 + !byte $4E,%00101000 + !byte $20,%00100110 + !byte $18,%01101010 + !byte $3E,%00001110 + !byte $4C,%10100001 + !byte $20,%00000110 + !byte $06,%00101011 + !byte $3E,%11001111 + !byte $32,%01100011 + !byte $20,%00000100 + !byte $04,%00101111 + !byte $56,%00110000 + !byte $32,%10000110 + !byte $20,%11000011 + !byte $04,%10101110 + !byte $50,%11010000 + !byte $4A,%10101000 + !byte $20,%10100011 + !byte $18,%01110011 + !byte $56,%10101101 + !byte $5E,%00000100 + !byte $20,%10000011 + !byte $10,%00110010 + !byte $4A,%01001101 + !byte $56,%01100001 + !byte $20,%01100011 + !byte $10,%10101011 + !byte $4A,%10010000 + !byte $56,%10001000 + !byte $20,%01000011 + !byte $2C,%10010000 + !byte $5A,%01101100 + !byte $5E,%00000110 + !byte $20,%00000011 + !byte $08,%10010010 + !byte $5A,%01110001 + !byte $4A,%01000001 + !byte $20,%11000010 + !byte $2C,%01001101 + !byte $36,%01101110 + !byte $5E,%00001001 + !byte $20,%10000010 + !byte $08,%01001011 + !byte $36,%01101111 + !byte $5E,%00000001 + !byte $20,%11000001 + !byte $00,%11001010 + !byte $44,%11001011 + !byte $30,%10000011 + !byte $20,%00100001 + !byte $00,%10101101 + !byte $52,%00010001 + !byte $38,%01100000 + !byte $20,%00000001 + !byte $1A,%00001010 + !byte $58,%10010000 + !byte $30,%01100110 + !byte $08,%10000011 + !byte $1A,%11010011 + !byte $44,%00010010 + !byte $54,%01101000 + !byte $20,%10101000 + !byte $14,%01101011 + !byte $52,%11001100 + !byte $38,%00100000 + !byte $20,%10001000 + !byte $00,%00110000 + !byte $52,%10101110 + !byte $38,%10000000 + !byte $20,%00100011 + !byte $14,%01110010 + !byte $52,%00101111 + !byte $38,%10100000 + !byte $20,%10100010 + !byte $00,%00010011 + !byte $58,%01001101 + !byte $38,%01100001 + !byte $20,%01000010 + !byte $12,%00010010 + !byte $46,%10010001 + !byte $38,%11000000 + !byte $20,%00000010 + !byte $12,%11001011 + !byte $38,%10001111 + !byte $48,%00101001 + !byte $20,%10100001 + !byte $16,%00001011 + !byte $46,%01001100 + !byte $54,%10000001 + !byte $20,%01100001 + !byte $0A,%01110010 + !byte $5A,%11001100 + !byte $48,%11000000 + !byte $1C,%10100001 + !byte $2E,%01110000 + !byte $38,%01001110 + !byte $38,%00000000 + !byte $0E,%00000011 + !byte $02,%00101110 + !byte $40,%00010011 + !byte $38,%00000010 + !byte $20,%01001000 + !byte $02,%11010010 + !byte $54,%01001110 + !byte $38,%00001000 + !byte $20,%01000001 + !byte $2E,%01101101 + !byte $5C,%01001100 + !byte $38,%10001001 + !byte $08,%01100110 + !byte $0A,%01101011 + !byte $54,%10101100 + !byte $5C,%01100100 + !byte $20,%01100010 + !byte $02,%10101111 + !byte $30,%00101111 + !byte $5C,%10000101 + !byte $20,%00100010 + !byte $16,%11010010 + !byte $5A,%00010001 + !byte $38,%01000000 + !byte $20,%10000001 + !byte $02,%00001011 + !byte $54,%10001111 + !byte $38,%00000001 + !byte $0E,%00000101 + !byte $18,%10001010 + !byte $5C,%10010001 + !byte $38,%00100001 + !byte $0E,%00000111 + !byte $04,%01001111 + !byte $4C,%00101101 + !byte $38,%01000001 + !byte $20,%00101001 + !byte $0C,%01010010 + !byte $54,%00110001 + !byte $38,%10000001 + !byte $1C,%01001000 + !byte $18,%01010011 + !byte $40,%11001010 + !byte $38,%10100001 + !byte $20,%11000000 + !byte $04,%10001110 + !byte $48,%00110001 + !byte $38,%11000001 + !byte $28,%01100100 + !byte $0C,%10001011 + !byte $5C,%01101100 + !byte $38,%00100010 + !byte $04,%10000111 + !byte $04,%10110010 + !byte $3A,%00101110 + !byte $38,%01000010 + !byte $28,%10000101 + !byte $28,%10110000 + !byte $4C,%10110000 + !byte $38,%01100010 + !byte $04,%01100010 + !byte $28,%00101101 + !byte $42,%01001011 + !byte $38,%10000010 + !byte $1A,%11000111 + !byte $04,%00101011 + !byte $30,%10101110 + !byte $38,%10100010 + !byte $1A,%00100010 + !byte $1A,%10110011 + !byte $3A,%10101111 + !byte $38,%11000010 + !byte $06,%11000110 + !byte $00,%01010000 + !byte $56,%00010000 + !byte $38,%00000011 + !byte $0C,%10000100 + !byte $0E,%00110010 + !byte $48,%10101100 + !byte $38,%00100011 + !byte $0C,%00100111 + !byte $0E,%10101011 + !byte $42,%10010010 + !byte $38,%00000111 + !byte $0C,%11000010 + !byte $00,%10001101 + !byte $56,%11001101 + !byte $38,%00100111 + !byte $06,%00100011 + !byte $1A,%00101010 + !byte $56,%10001100 + !byte $38,%01000111 + !byte $0C,%01100101 + !byte $14,%10001011 + !byte $5C,%01110001 + !byte $38,%01100111 + !byte $14,%10100110 + !byte $06,%10010010 + !byte $32,%10001110 + !byte $38,%10000111 + !byte $14,%01000011 + !byte $14,%01010010 + !byte $32,%01001111 + !byte $38,%10100111 + !byte $26,%10100101 + !byte $2A,%10010000 + !byte $56,%01010001 + !byte $38,%11000111 + !byte $26,%01000100 + !byte $2A,%01001101 + !byte $4A,%00101101 + !byte $38,%00101000 + !byte $18,%01100111 + !byte $06,%01001011 + !byte $4A,%10110000 + !byte $38,%01001000 + !byte $18,%10000010 + !byte $16,%00101011 + !byte $44,%00110010 + !byte $38,%01101000 + !byte $1E,%00100001 + !byte $02,%11001111 + !byte $4E,%00001101 + !byte $38,%10001000 + !byte $04,%01000111 + !byte $02,%00001110 + !byte $4E,%11010000 + !byte $38,%10101000 + !byte $0A,%10100010 + !byte $16,%10110010 + !byte $3C,%00001110 + !byte $38,%11001000 + !byte $20,%01001001 + !byte $10,%11001011 + !byte $3C,%11001111 + !byte $38,%00001001 + !byte $20,%10100000 + !byte $10,%00010010 + !byte $44,%10101011 + !byte $38,%00101001 + !byte $1E,%11001000 + !byte $2C,%01110000 + !byte $52,%11001110 + !byte $38,%01001001 + !byte $0A,%11000101 + !byte $2C,%01101101 + !byte $58,%01101101 + !byte $38,%01101001 + !byte $0A,%01000111 + !byte $08,%01110010 + !byte $58,%01110001 + !byte $38,%10101001 + !byte $04,%10100010 + !byte $08,%01101011 + !byte $52,%00001111 + !byte $38,%11001001 + !byte $0A,%00100100 + !byte $04,%01101110 + !byte $58,%01101100 + !byte $5C,%00100001 + !byte $16,%00000111 + !byte $18,%00110011 + !byte $34,%01101110 + !byte $5C,%11001000 + !byte $16,%00000011 + !byte $04,%01101111 + !byte $58,%01110000 + !byte $38,%11000110 + !byte $12,%11000110 + !byte $12,%11010001 + !byte $5A,%00001101 + !byte $46,%01100000 + !byte $2E,%01000101 + !byte $00,%00001011 + !byte $34,%01101111 + !byte $46,%10001001 + !byte $2E,%10100100 + !byte $00,%11010010 + !byte $50,%11001100 + !byte $52,%10100001 + !byte $12,%00100011 + !byte $12,%00001100 + !byte $46,%00101100 + !byte $5A,%00100101 + !byte $1C,%01101000 + !byte $18,%10101010 + !byte $46,%10110001 + !byte $5A,%11000100 + !byte $24,%11000101 + !byte $0A,%01010010 + !byte $54,%01101110 + !byte $52,%01001000 + !byte $24,%00100100 + !byte $2E,%01010000 + !byte $3E,%11001101 + !byte $36,%01000011 + !byte $08,%10100011 + !byte $2E,%10001101 + !byte $3E,%00010000 + !byte $36,%10100110 + !byte $08,%01000110 + !byte $1A,%01001010 + !byte $50,%00010001 + !byte $4C,%11000001 + !byte $2C,%10000100 + !byte $06,%00001111 + !byte $5A,%11010000 + !byte $5A,%01000001 + !byte $1C,%10000001 + !byte $00,%01110000 + !byte $40,%00110011 + !byte $5A,%10101000 + !byte $08,%10000010 + !byte $0A,%10001011 + !byte $54,%01101111 + !byte $4C,%00101000 + !byte $02,%10100111 + !byte $1A,%10010011 + !byte $5A,%01001100 + !byte $50,%11000001 + !byte $08,%01100111 + !byte $06,%11001110 + !byte $40,%10101010 + !byte $4A,%10001000 + !byte $22,%00000110 + !byte $14,%10101011 + !byte $5A,%10010001 + !byte $5E,%11000011 + !byte $2C,%01100101 + !byte $02,%10110010 + !byte $48,%10001100 + !byte $50,%00101000 + !byte $22,%00000100 + !byte $00,%01101101 + !byte $5C,%10001100 + !byte $5E,%00100110 + !byte $10,%00000011 + !byte $14,%00110010 + !byte $36,%01001110 + !byte $4A,%01100001 + !byte $02,%01000010 + !byte $02,%00101011 + !byte $36,%10001111 + !byte $44,%00000000 + !byte $1A,%00000010 + !byte $0C,%00110010 + !byte $48,%01010001 + !byte $34,%01100011 + !byte $10,%00000111 + !byte $0C,%10101011 + !byte $42,%00101011 + !byte $34,%10000110 + !byte $1A,%00001000 + !byte $16,%10010010 + !byte $52,%10101100 + !byte $58,%10001000 + !byte $20,%01101001 + !byte $04,%10010010 + !byte $52,%00110001 + !byte $48,%00000001 + !byte $06,%10100110 + !byte $16,%01001011 + !byte $42,%10110010 + !byte $5C,%10100101 + !byte $06,%01000011 + !byte $02,%00010000 + !byte $56,%00001110 + !byte $58,%01100001 + !byte $0C,%10100100 + !byte $28,%01001101 + !byte $5C,%01010001 + !byte $48,%00001001 + !byte $06,%01100010 + !byte $02,%11001101 + !byte $56,%11001111 + !byte $5C,%01000100 + !byte $0C,%01000101 + !byte $28,%10010000 + !byte $3E,%01101010 + !byte $4E,%00000010 + !byte $2A,%10000101 + !byte $04,%01001011 + !byte $3E,%10001010 + !byte $32,%10000011 + !byte $2A,%01100100 + !byte $26,%01110011 + !byte $3E,%10101010 + !byte $4E,%00001000 + !byte $20,%10000000 + !byte $26,%11010010 + !byte $3E,%00101011 + !byte $32,%01100110 + !byte $06,%10000111 + !byte $26,%01110010 + !byte $3E,%01001011 + !byte $5A,%10100100 + !byte $0E,%00100111 + !byte $26,%10010001 + !byte $3E,%10001011 + !byte $56,%10000001 + !byte $18,%10000111 + !byte $26,%11001010 + !byte $3E,%10101011 + !byte $56,%01101000 + !byte $1E,%00001001 + !byte $26,%11010011 + !byte $3E,%00001100 + !byte $46,%01101001 + !byte $18,%01100010 + !byte $26,%10110011 + !byte $3E,%00101100 + !byte $46,%10000000 + !byte $1E,%00000001 + !byte $26,%10010011 + !byte $3E,%01001100 + !byte $4C,%00001000 + !byte $04,%00100111 + !byte $26,%01010011 + !byte $3E,%01101100 + !byte $5E,%11001000 + !byte $0E,%11000010 + !byte $26,%10110010 + !byte $3E,%10001100 + !byte $5A,%01000101 + !byte $0A,%01000100 + !byte $26,%01010010 + !byte $3E,%10101100 + !byte $5E,%00100001 + !byte $0A,%10100101 + !byte $26,%10110001 + !byte $3E,%11001100 + !byte $4C,%00000010 + !byte $28,%01000100 + !byte $26,%10001010 + !byte $3E,%00001101 + !byte $30,%10100011 + !byte $04,%11000010 + !byte $26,%00001010 + !byte $3E,%00101101 + !byte $30,%01000110 + !byte $16,%11000010 + !byte $0E,%00010010 + !byte $3E,%01001101 + !byte $5E,%01000110 + !byte $28,%10100101 + !byte $26,%00110011 + !byte $3E,%01101101 + !byte $44,%00100000 + !byte $16,%00100111 + !byte $26,%00010011 + !byte $3E,%10001101 + !byte $4A,%01101000 + !byte $04,%10100111 + !byte $26,%10010010 + !byte $3E,%10101101 + !byte $54,%10100001 + !byte $04,%01000010 + !byte $26,%00110010 + !byte $3E,%00110000 + !byte $54,%01001000 + !byte $1C,%10001000 + !byte $26,%00010010 + !byte $3E,%01010000 + !byte $44,%11001001 + !byte $1C,%01100001 + !byte $26,%11010001 + !byte $3E,%01110000 + !byte $5C,%10101000 + !byte $08,%00100110 + !byte $26,%01110001 + !byte $3E,%10010000 + !byte $5C,%01000001 + !byte $02,%10000111 + !byte $26,%01010001 + !byte $3E,%10110000 + !byte $5E,%10100011 + !byte $0C,%10100010 + !byte $26,%00110001 + !byte $3E,%11010000 + !byte $38,%01000011 + !byte $02,%01100010 + !byte $26,%00010001 + !byte $3E,%00010001 + !byte $38,%10100110 + !byte $0C,%01000111 + !byte $26,%11010000 + !byte $3E,%00110001 + !byte $4A,%10000001 + !byte $02,%11000111 + !byte $26,%10110000 + !byte $3E,%01010001 + !byte $52,%11000001 + !byte $08,%11000011 + !byte $26,%00101101 + !byte $3E,%10010001 + !byte $48,%11001000 + !byte $14,%11000110 + !byte $26,%00001101 + !byte $3E,%10110001 + !byte $52,%00101000 + !byte $14,%00100011 + !byte $26,%11001100 + !byte $3E,%11010001 + !byte $5C,%11000101 + !byte $26,%11000101 + !byte $26,%10101100 + !byte $3E,%01010010 + !byte $48,%00100001 + !byte $26,%00100100 + !byte $26,%10001100 + !byte $3E,%01110010 + !byte $36,%01100011 + !byte $02,%00100010 + !byte $26,%01101100 + !byte $3E,%10010010 + !byte $36,%10000110 + !byte $1A,%00101000 + !byte $26,%01001100 + !byte $3E,%00010011 + !byte $5C,%00100100 + !byte $20,%01100000 + !byte $26,%00101100 + !byte $3E,%01010011 + !byte $5A,%01100001 + !byte $1A,%11000001 + !byte $26,%00001100 + !byte $3E,%01110011 + !byte $5A,%10001000 + !byte $0C,%00100101 + !byte $26,%11001011 + !byte $5E,%10110001 + !byte $46,%10100000 + !byte $0A,%01100111 + !byte $26,%10101011 + !byte $4A,%00001101 + !byte $50,%00000010 + !byte $20,%10001001 + !byte $26,%10001011 + !byte $3E,%11001010 + !byte $5A,%01100101 + !byte $2E,%10000100 + !byte $26,%01101011 + !byte $3E,%00001011 + !byte $5A,%10000100 + !byte $0C,%11000100 + !byte $26,%01001011 + !byte $3E,%01101011 + !byte $34,%01100110 + !byte $06,%10000110 + !byte $26,%00101011 + !byte $3E,%11001011 + !byte $50,%00001000 + !byte $0A,%10000010 + !byte $26,%00001011 + !byte $3E,%00010010 + !byte $46,%01001001 + !byte $06,%01100011 + !byte $26,%10101010 + !byte $3E,%10110010 + !byte $4C,%11000111 + !byte $12,%00000111 + !byte $26,%01101010 + !byte $38,%00101110 + !byte $34,%10000011 + !byte $2E,%01100101 + !byte $26,%01001010 + !byte $38,%10101111 + !byte $4C,%00100010 + !byte $24,%00000100 + !byte $26,%00101010 + !byte $3E,%01110001 + !byte $58,%10000001 + !byte $12,%00000011 + !byte $04,%01001110 + !byte $3E,%00110011 + !byte $58,%01101000 + !byte $04,%00000111 + !byte $18,%00010011 + !byte $4A,%11010000 + !byte $44,%10101001 + !byte $18,%01000010 + !byte $04,%10001111 + !byte $3E,%00110010 + !byte $4E,%00100010 + !byte $24,%00000110 + !byte $0E,%11001011 + !byte $54,%10001100 + !byte $58,%00000101 + !byte $18,%10100111 + !byte $06,%01110010 + !byte $3E,%01001010 + !byte $44,%01000000 + !byte $0A,%10000101 + !byte $2A,%01101101 + !byte $3E,%11010010 + !byte $4A,%01001000 + !byte $1E,%11000000 + !byte $2A,%01110000 + !byte $5C,%00101100 + !byte $5E,%10000011 + !byte $04,%00000011 + !byte $18,%11001010 + !byte $5C,%10110001 + !byte $32,%01000110 + !byte $0A,%01100100 + !byte $06,%00101111 + !byte $3E,%10010011 + !byte $4E,%11000111 + !byte $1E,%00101001 + !byte $06,%01101011 + !byte $44,%01010010 + !byte $5E,%01100110 + !byte $08,%10000111 + !byte $1A,%01110011 + !byte $58,%10001101 + !byte $4A,%10100001 + !byte $08,%01100010 + !byte $14,%11001011 + !byte $58,%01010000 + !byte $32,%10100011 + !byte $00,%00001000 + !byte $10,%11010001 + !byte $44,%10001011 + !byte $56,%01001000 + !byte $2C,%01100100 + !byte $1A,%01101010 + !byte $5E,%00101100 + !byte $5E,%01000001 + !byte $10,%00100111 + !byte $00,%10010000 + !byte $54,%01010001 + !byte $56,%10100001 + !byte $2C,%10000101 + !byte $10,%00001100 + !byte $30,%10001110 + !byte $5C,%00000100 + !byte $16,%01000111 + !byte $00,%01001101 + !byte $30,%01001111 + !byte $5C,%00000110 + !byte $16,%10100010 + !byte $06,%10101110 + !byte $4C,%00001101 + !byte $5E,%10101000 + !byte $22,%00100110 + !byte $2C,%01010000 + !byte $4C,%11010000 + !byte $48,%01000001 + !byte $22,%11000011 + !byte $2C,%10001101 + !byte $46,%11010001 + !byte $48,%10101000 + !byte $10,%11000010 + !byte $14,%00010010 + !byte $3A,%00001110 + !byte $30,%00100110 + !byte $08,%00000100 + !byte $08,%10001011 + !byte $3A,%11001111 + !byte $54,%00101000 + !byte $02,%01100111 + !byte $1C,%11010011 + !byte $5E,%00001100 + !byte $54,%11000001 + !byte $00,%00000010 + !byte $08,%01010010 + !byte $5E,%11010001 + !byte $30,%11000011 + !byte $02,%10000010 + !byte $1C,%00001010 + !byte $46,%00001100 + !byte $5A,%10000101 + !byte $1C,%01000001 + !byte $00,%00101011 + !byte $56,%01101100 + !byte $5A,%01100100 + !byte $1C,%10101000 + !byte $02,%00110000 + !byte $54,%01001111 + !byte $5C,%10001000 + !byte $08,%00000110 + !byte $12,%10110001 + !byte $40,%01010011 + !byte $46,%00101001 + !byte $00,%11000111 + !byte $12,%00101100 + !byte $5A,%00101101 + !byte $5C,%01100001 + !byte $06,%10100111 + !byte $02,%10101101 + !byte $32,%01101110 + !byte $38,%01100011 + !byte $2A,%10100101 + !byte $00,%10110010 + !byte $32,%01101111 + !byte $38,%10000110 + !byte $2A,%01000100 + !byte $2E,%10101101 + !byte $5A,%10110000 + !byte $46,%11000000 + !byte $06,%01000010 + !byte $16,%01110010 + !byte $54,%10001110 + !byte $4C,%01000010 + !byte $00,%00100010 + !byte $0A,%00110010 + !byte $56,%01110001 + !byte $4C,%10100111 + !byte $0E,%01000111 + !byte $16,%01101011 + !byte $3E,%00101010 + !byte $5E,%01100011 + !byte $0E,%10100010 + !byte $2E,%00110000 + !byte $40,%10001010 + !byte $52,%00000010 + !byte $1A,%01001000 + !byte $04,%00101110 + !byte $3E,%10110011 + !byte $52,%00001000 + !byte $0C,%00000101 + !byte $18,%11010010 + !byte $4E,%11001100 + !byte $44,%10001001 + !byte $06,%10000011 + !byte $26,%01001101 + !byte $3C,%11001101 + !byte $4A,%00101000 + !byte $1A,%10100001 + !byte $0A,%10101011 + !byte $4E,%00010001 + !byte $58,%11000100 + !byte $06,%01100110 + !byte $02,%10010010 + !byte $48,%01110001 + !byte $36,%10000011 + !byte $20,%01000000 + !byte $02,%01001011 + !byte $3C,%00010000 + !byte $58,%00100101 + !byte $28,%11000101 + !byte $04,%10101111 + !byte $48,%01101100 + !byte $4A,%11000001 + !byte $28,%00100100 + !byte $26,%10010000 + !byte $56,%00101110 + !byte $5A,%10000001 + !byte $04,%00100010 + !byte $18,%00001011 + !byte $5C,%10101100 + !byte $36,%01100110 + !byte $04,%11000111 + !byte $0C,%00010010 + !byte $56,%10101111 + !byte $5E,%10000110 + !byte $20,%10101001 + !byte $00,%10110000 + !byte $58,%01001100 + !byte $44,%01100000 + !byte $18,%11000111 + !byte $0C,%11001011 + !byte $34,%10001111 + !byte $5A,%01101000 + !byte $0C,%01100111 + !byte $1A,%10001010 + !byte $58,%10010001 + !byte $50,%11000111 + !byte $18,%00100010 + !byte $14,%00001100 + !byte $42,%00001011 + !byte $42,%00000000 + !byte $04,%11000110 + !byte $1A,%01010011 + !byte $42,%11010010 + !byte $5C,%11000011 + !byte $0C,%10000010 + !byte $06,%01001111 + !byte $4A,%00010001 + !byte $50,%00100010 + !byte $0A,%01100101 + !byte $28,%01110000 + !byte $34,%01001110 + !byte $34,%10100011 + !byte $14,%00000111 + !byte $28,%01101101 + !byte $5C,%00110001 + !byte $3A,%00100001 + !byte $04,%00100011 + !byte $04,%01101011 + !byte $4A,%11001100 + !byte $3A,%10101001 + !byte $1E,%01001001 + !byte $00,%00101101 + !byte $50,%10101100 + !byte $3A,%11001001 + !byte $02,%00000010 + !byte $06,%10001110 + !byte $58,%10101101 + !byte $5C,%00100110 + !byte $0A,%10000100 + !byte $04,%01110010 + !byte $50,%00110001 + !byte $48,%01100001 + !byte $1E,%10100000 + !byte $14,%11010001 + !byte $44,%01110010 + !byte $3A,%10100000 + !byte $26,%00000100 + !byte $0E,%00001100 + !byte $44,%01101011 + !byte $3A,%01100001 + !byte $14,%00000011 + !byte $02,%10001101 + !byte $3E,%11010011 + !byte $3A,%11001000 + !byte $16,%01100111 + !byte $06,%01010010 + !byte $5E,%01001100 + !byte $58,%01001000 + !byte $26,%00000110 + !byte $0E,%11010001 + !byte $5A,%00101100 + !byte $3A,%11000000 + !byte $16,%10000010 + !byte $1C,%10110011 + !byte $36,%10101111 + !byte $3A,%10000010 + !byte $02,%00001000 + !byte $1C,%00101010 + !byte $5E,%10010001 + !byte $34,%01000110 + !byte $08,%11000101 + !byte $16,%10001011 + !byte $58,%00110000 + !byte $3A,%01100000 + !byte $0A,%10000111 + !byte $2A,%01010000 + !byte $3E,%00001010 + !byte $3A,%01000001 + !byte $0A,%01100010 + !byte $2A,%10001101 + !byte $36,%00101110 + !byte $3A,%10100001 + !byte $1C,%11001000 + !byte $16,%01010010 + !byte $5A,%10110001 + !byte $3A,%11000001 + !byte $02,%01000111 + !byte $02,%01010000 + !byte $46,%11001011 + !byte $3A,%01100010 + !byte $22,%11001001 + !byte $06,%10001011 + !byte $46,%00010010 + !byte $3A,%00101001 + !byte $22,%10101001 + !byte $10,%10110001 + !byte $52,%10001100 + !byte $3A,%10001001 + !byte $22,%10001001 + !byte $04,%00001110 + !byte $52,%01010001 + !byte $48,%10001000 + !byte $22,%01101001 + !byte $18,%10110010 + !byte $40,%01101010 + !byte $58,%10100001 + !byte $22,%01001001 + !byte $10,%00101100 + !byte $5A,%01001101 + !byte $3A,%00000000 + !byte $22,%11001000 + !byte $04,%11001111 + !byte $5A,%10010000 + !byte $3A,%00100000 + !byte $22,%10101000 + !byte $08,%00110010 + !byte $54,%10101110 + !byte $3A,%01000000 + !byte $22,%10001000 + !byte $2C,%00110000 + !byte $5C,%11010001 + !byte $3A,%10000000 + !byte $22,%01001000 + !byte $2C,%10101101 + !byte $54,%00101111 + !byte $3A,%00000001 + !byte $22,%00101000 + !byte $18,%00101011 + !byte $40,%01110011 + !byte $3A,%10000001 + !byte $22,%00001000 + !byte $08,%10101011 + !byte $38,%00001110 + !byte $3A,%00000010 + !byte $22,%11000111 + !byte $12,%01001100 + !byte $38,%11001111 + !byte $3A,%00100010 + !byte $22,%10100111 + !byte $00,%01001011 + !byte $5C,%00001100 + !byte $3A,%01000010 + !byte $22,%10000111 + !byte $06,%01101110 + !byte $54,%01101100 + !byte $3A,%10100010 + !byte $22,%01100111 + !byte $14,%00101100 + !byte $48,%10010001 + !byte $3A,%11000010 + !byte $22,%01000111 + !byte $06,%01101111 + !byte $48,%01001100 + !byte $3A,%00000011 + !byte $22,%00100111 + !byte $12,%10010001 + !byte $56,%01001110 + !byte $3A,%00100011 + !byte $22,%00000111 + !byte $2E,%00010000 + !byte $42,%00010011 + !byte $3A,%01000011 + !byte $22,%11000110 + !byte $00,%11010000 + !byte $5C,%11001100 + !byte $3A,%10100110 + !byte $22,%10100110 + !byte $00,%10010010 + !byte $30,%01101110 + !byte $3A,%11000110 + !byte $22,%10000110 + !byte $00,%00001101 + !byte $30,%01101111 + !byte $3A,%00000111 + !byte $22,%01100110 + !byte $1A,%00110011 + !byte $54,%01110001 + !byte $3A,%00100111 + !byte $22,%01000110 + !byte $1A,%10101010 + !byte $5C,%00010001 + !byte $3A,%01000111 + !byte $22,%10100011 + !byte $2E,%11001101 + !byte $42,%11001010 + !byte $3A,%01100111 + !byte $22,%10000011 + !byte $14,%10110001 + !byte $4C,%11001100 + !byte $3A,%10000111 + !byte $22,%01100011 + !byte $0A,%00010010 + !byte $4C,%00010001 + !byte $3A,%10100111 + !byte $22,%01000011 + !byte $0A,%11001011 + !byte $56,%10001111 + !byte $3A,%11000111 + !byte $22,%00000011 + !byte $1C,%10010011 + !byte $3A,%11001101 + !byte $3A,%00001000 + !byte $22,%11000010 + !byte $02,%01110010 + !byte $3A,%00010000 + !byte $3A,%00101000 + !byte $22,%10100010 + !byte $1C,%01001010 + !byte $5E,%00010010 + !byte $3A,%01001000 + !byte $22,%10000010 + !byte $08,%00001111 + !byte $4A,%10101100 + !byte $3A,%01101000 + !byte $22,%01100010 + !byte $02,%01110000 + !byte $4A,%00110001 + !byte $3A,%10001000 + !byte $22,%00100010 + !byte $26,%01110000 + !byte $5E,%01101100 + !byte $3A,%10101000 + !byte $22,%00000010 + !byte $26,%01101101 + !byte $5E,%11001011 + !byte $3A,%00001001 + !byte $22,%11000001 + !byte $02,%01101101 + !byte $44,%01001011 + !byte $3A,%01001001 + !byte $22,%10100001 + !byte $08,%11001110 + !byte $44,%10010010 + !byte $3A,%01101001 + !byte $22,%01000001 + !byte $16,%00110010 + !byte $56,%01001100 + !byte $4E,%01000010 + !byte $22,%00100001 + !byte $16,%10101011 + !byte $58,%00010000 + !byte $5A,%01000100 + !byte $22,%11000000 + !byte $02,%01101011 + !byte $32,%10001111 + !byte $32,%11000011 + !byte $22,%01100000 + !byte $0C,%00001100 + !byte $5E,%01110001 + !byte $4E,%10100111 + !byte $22,%00100000 + !byte $0C,%11010001 + !byte $58,%11001101 + !byte $5A,%10100101 + !byte $22,%00000000 + !byte $28,%01010000 + !byte $32,%01001110 + !byte $46,%00000001 + !byte $2E,%10000101 + !byte $28,%10001101 + !byte $56,%10010001 + !byte $32,%00100110 + !byte $08,%00100100 + !byte $04,%10001011 + !byte $4E,%10101100 + !byte $46,%00001001 + !byte $22,%00001001 + !byte $04,%11001101 + !byte $3C,%10101101 + !byte $56,%11000001 + !byte $22,%01101000 + !byte $04,%00010000 + !byte $3C,%00110000 + !byte $56,%00101000 + !byte $02,%10100010 + !byte $04,%01010010 + !byte $4E,%00110001 + !byte $5E,%01100001 + !byte $22,%00100011 + !byte $18,%10010010 + !byte $46,%10101011 + !byte $58,%10100100 + !byte $22,%01000010 + !byte $18,%01001011 + !byte $58,%00101100 + !byte $5E,%01000011 + !byte $22,%10100000 + !byte $0E,%10110001 + !byte $46,%00110010 + !byte $44,%10000000 + !byte $1C,%00100001 + !byte $0E,%00101100 + !byte $40,%10010011 + !byte $3A,%01100011 + !byte $22,%10000001 + !byte $06,%10001111 + !byte $54,%11001110 + !byte $44,%01101001 + !byte $22,%01100001 + !byte $06,%01001110 + !byte $58,%10110001 + !byte $4A,%00001000 + !byte $22,%10000000 + !byte $00,%11001100 + !byte $54,%00001111 + !byte $4C,%01100010 + !byte $22,%01000000 + !byte $1A,%00010011 + !byte $5A,%01101101 + !byte $30,%00000100 + !byte $12,%00100111 + !byte $2A,%00110000 + !byte $34,%00101110 + !byte $3A,%10000110 + !byte $24,%00100110 + !byte $2A,%10101101 + !byte $34,%10101111 + !byte $4C,%10000111 + !byte $2E,%01100100 + !byte $1A,%11001010 + !byte $5A,%01110000 + !byte $5E,%10001000 + !byte $12,%11000010 + !byte $00,%00010001 + !byte $40,%01001010 + !byte $5E,%10100110 + !byte $22,%00101001 + !byte $06,%00110010 + !byte $50,%01010001 + !byte $58,%01000101 + !byte $22,%00000001 + !byte $06,%10101011 + !byte $50,%10001100 + !byte $30,%00000110 + !byte $24,%11000011 + !byte $14,%01001100 + !byte $42,%00110011 + !byte $54,%00000010 + !byte $00,%00101000 + !byte $14,%10010001 + !byte $48,%10110001 + !byte $54,%00001000 + !byte $1A,%10000001 + !byte $1C,%01110011 + !byte $5C,%11010000 + !byte $4A,%00000010 + !byte $00,%11000001 + !byte $02,%10010000 + !byte $42,%10101010 + !byte $48,%01101000 + !byte $00,%10100111 + !byte $10,%10010001 + !byte $56,%01101110 + !byte $5C,%10100011 + !byte $00,%01000010 + !byte $2C,%11001101 + !byte $56,%01101111 + !byte $5C,%01000110 + !byte $1A,%01101000 + !byte $10,%01001100 + !byte $48,%00101100 + !byte $42,%11001001 + !byte $06,%01000110 + !byte $1C,%01101010 + !byte $5C,%00001101 + !byte $38,%10000011 + !byte $06,%10100011 + !byte $16,%11001011 + !byte $36,%00001110 + !byte $42,%00100000 + !byte $20,%11001001 + !byte $08,%00101111 + !byte $5A,%11010001 + !byte $5C,%10000001 + !byte $08,%10100111 + !byte $02,%01001101 + !byte $5A,%00001100 + !byte $5C,%01101000 + !byte $20,%00100000 + !byte $08,%10101110 + !byte $36,%11001111 + !byte $38,%01100110 + !byte $2C,%01000100 + !byte $08,%00010010 + !byte $4A,%01010001 + !byte $52,%11000111 + !byte $08,%01000010 + !byte $2C,%00010000 + !byte $52,%01101100 + !byte $48,%10000001 + !byte $10,%01000111 + !byte $08,%11001011 + !byte $52,%01110001 + !byte $52,%00100010 + !byte $2C,%10100101 + !byte $16,%00010010 + !byte $4A,%10001100 + !byte $5A,%00100100 + !byte $10,%10100010 + !byte $1E,%11010011 + !byte $5E,%10001100 + !byte $46,%00100001 + !byte $04,%01000011 + !byte $1E,%00001010 + !byte $5C,%00010010 + !byte $5A,%10100001 + !byte $18,%00001000 + !byte $00,%01101011 + !byte $5E,%01010001 + !byte $36,%10100011 + !byte $18,%00000010 + !byte $24,%10110011 + !byte $44,%00101011 + !byte $36,%01000110 + !byte $2A,%11000101 + !byte $24,%01010010 + !byte $58,%00001110 + !byte $5A,%01001000 + !byte $06,%00100010 + !byte $24,%00110001 + !byte $58,%11001111 + !byte $46,%11001000 + !byte $1E,%10000000 + !byte $04,%00110000 + !byte $44,%10110010 + !byte $5A,%11000101 + !byte $1E,%01101001 + !byte $12,%01110001 + !byte $5C,%11001011 + !byte $50,%01000010 + !byte $0A,%01000101 + !byte $12,%01101100 + !byte $38,%00010000 + !byte $50,%10100111 + !byte $04,%10100110 + !byte $04,%10101101 + !byte $38,%11001101 + !byte $58,%10000100 + !byte $06,%11000111 + !byte $24,%11010011 + !byte $54,%01001100 + !byte $5E,%00100011 + !byte $2A,%00100100 + !byte $24,%00110011 + !byte $54,%10010001 + !byte $34,%11000011 + !byte $0A,%10100100 + !byte $24,%01001011 + !byte $46,%10001011 + !byte $44,%10100000 + !byte $16,%01100010 + !byte $24,%00001011 + !byte $46,%01010010 + !byte $34,%00100110 + !byte $02,%00100111 + !byte $24,%10101010 + !byte $30,%01001110 + !byte $58,%00101000 + !byte $0E,%01100111 + !byte $00,%01110010 + !byte $30,%10001111 + !byte $5E,%11000110 + !byte $0E,%10000010 + !byte $2E,%00001110 + !byte $5A,%01010000 + !byte $58,%01100101 + !byte $1C,%00001001 + !byte $24,%10010011 + !byte $5A,%10001101 + !byte $58,%11000001 + !byte $04,%00001000 + !byte $24,%01110011 + !byte $3A,%10101101 + !byte $4A,%11000111 + !byte $02,%11000010 + !byte $24,%01010011 + !byte $4C,%00110001 + !byte $4A,%00100010 + !byte $16,%10000111 + !byte $24,%00010011 + !byte $5E,%00110010 + !byte $44,%01001001 + !byte $08,%10100101 + !byte $24,%11010010 + !byte $40,%00101010 + !byte $42,%10101001 + !byte $28,%00000110 + !byte $24,%10110010 + !byte $4C,%10101100 + !byte $4E,%01100010 + !byte $08,%01000100 + !byte $24,%10010010 + !byte $40,%10110011 + !byte $56,%00000101 + !byte $1C,%00000001 + !byte $24,%01110010 + !byte $5E,%10101011 + !byte $42,%01000000 + !byte $14,%11000010 + !byte $24,%00110010 + !byte $3A,%00110000 + !byte $5C,%10000011 + !byte $28,%00000100 + !byte $24,%00010010 + !byte $56,%00101100 + !byte $4E,%10000111 + !byte $04,%00000010 + !byte $24,%11010001 + !byte $48,%11010001 + !byte $5C,%01100110 + !byte $14,%00100111 + !byte $24,%10110001 + !byte $56,%10110001 + !byte $48,%01001000 + !byte $0C,%10000111 + !byte $24,%10010001 + !byte $48,%00001100 + !byte $56,%00000010 + !byte $06,%00100110 + !byte $24,%01110001 + !byte $5C,%00101101 + !byte $56,%00001000 + !byte $00,%10000111 + !byte $24,%01010001 + !byte $42,%01010011 + !byte $48,%10100001 + !byte $0C,%01100010 + !byte $24,%00010001 + !byte $56,%10001110 + !byte $32,%00000100 + !byte $1A,%01100001 + !byte $24,%11010000 + !byte $32,%10101111 + !byte $32,%00000110 + !byte $1A,%10001000 + !byte $24,%10110000 + !byte $42,%10001010 + !byte $5A,%00000100 + !byte $02,%11000001 + !byte $24,%10010000 + !byte $4E,%10001100 + !byte $4C,%10000010 + !byte $00,%01100010 + !byte $24,%01110000 + !byte $32,%00101110 + !byte $3A,%10000011 + !byte $06,%11000011 + !byte $24,%01101101 + !byte $56,%01001111 + !byte $3A,%01100110 + !byte $26,%11000011 + !byte $24,%01001101 + !byte $3C,%10001101 + !byte $4C,%01100111 + !byte $02,%00101000 + !byte $24,%00101101 + !byte $3C,%01010000 + !byte $5E,%01101000 + !byte $26,%00100110 + !byte $24,%00001101 + !byte $4E,%01010001 + !byte $5A,%00000110 + !byte $20,%00000000 + !byte $24,%11001100 + !byte $5C,%10110000 + !byte $46,%10101000 + !byte $18,%11000001 + !byte $24,%10101100 + !byte $3C,%00001010 + !byte $30,%11000101 + !byte $0A,%01000010 + !byte $24,%10001100 + !byte $3C,%00101010 + !byte $46,%01000001 + !byte $18,%00101000 + !byte $24,%01101100 + !byte $3C,%01101010 + !byte $5E,%10000001 + !byte $04,%10000110 + !byte $24,%01001100 + !byte $3C,%10001010 + !byte $30,%00100100 + !byte $2E,%10100101 + !byte $24,%00101100 + !byte $3C,%10101010 + !byte $54,%00100010 + !byte $04,%01100011 + !byte $24,%00001100 + !byte $3C,%00001011 + !byte $54,%11000111 + !byte $0A,%10100111 + !byte $24,%11001011 + !byte $3C,%01001011 + !byte $5C,%10100001 + !byte $1E,%10001001 + !byte $24,%10101011 + !byte $3C,%10001011 + !byte $38,%01000110 + !byte $0A,%00100101 + !byte $24,%10001011 + !byte $3C,%10101011 + !byte $5C,%01001000 + !byte $2E,%01000100 + !byte $24,%01101011 + !byte $3C,%11001011 + !byte $5E,%00000011 + !byte $0A,%11000100 + !byte $24,%00101011 + !byte $3C,%00001100 + !byte $38,%10100011 + !byte $00,%01001000 + !byte $24,%11001010 + !byte $3C,%00101100 + !byte $44,%11000000 + !byte $24,%01000110 + !byte $24,%10001010 + !byte $3C,%01001100 + !byte $44,%00101001 + !byte $24,%10100011 + !byte $24,%01101010 + !byte $3C,%01101100 + !byte $58,%01100100 + !byte $12,%10100010 + !byte $24,%01001010 + !byte $3C,%10001100 + !byte $5E,%00000111 + !byte $00,%10100001 + !byte $24,%00101010 + !byte $3C,%10101100 + !byte $58,%10000101 + !byte $1E,%01100000 + !byte $24,%00001010 + !byte $3C,%11001100 + !byte $4A,%01000010 + !byte $12,%01000111 + !byte $18,%01101011 + !byte $3C,%00001101 + !byte $4A,%10100111 + !byte $16,%01000010 + !byte $0A,%00001100 + !byte $3C,%00101101 + !byte $52,%01000010 + !byte $16,%10100111 + !byte $0A,%11010001 + !byte $3C,%01001101 + !byte $5A,%11000001 + !byte $08,%10000101 + !byte $2E,%11001111 + !byte $3C,%01101101 + !byte $42,%10001001 + !byte $02,%00000111 + !byte $18,%01110010 + !byte $3C,%01110000 + !byte $56,%11000100 + !byte $08,%11000111 + !byte $02,%01010010 + !byte $3C,%10010000 + !byte $36,%00100110 + !byte $08,%00100010 + !byte $02,%10001011 + !byte $3C,%10110000 + !byte $52,%10100111 + !byte $02,%00000011 + !byte $1A,%00001011 + !byte $3C,%11010000 + !byte $42,%01100000 + !byte $1C,%00101001 + !byte $06,%10101111 + !byte $3C,%00010001 + !byte $5C,%01100011 + !byte $2C,%00100100 + !byte $00,%00110001 + !byte $3C,%00110001 + !byte $5C,%10000110 + !byte $1C,%11000000 + !byte $26,%01010000 + !byte $3C,%01010001 + !byte $36,%11000011 + !byte $14,%10100010 + !byte $26,%10001101 + !byte $3C,%01110001 + !byte $5A,%00101000 + !byte $08,%01100100 + !byte $00,%10101100 + !byte $3C,%10110001 + !byte $56,%00100101 + !byte $2C,%11000101 + !byte $06,%00101110 + !byte $3C,%11010001 + !byte $48,%00101000 + !byte $10,%01100111 + !byte $1A,%11010010 + !byte $3C,%00110010 + !byte $48,%11000001 + !byte $10,%10000010 + !byte $14,%01110001 + !byte $3C,%01010010 + !byte $5A,%11000011 + !byte $14,%01000111 + !byte $0C,%10110001 + !byte $3C,%11010010 + !byte $50,%01100010 + !byte $1A,%01000001 + !byte $0C,%00101100 + !byte $3C,%00110011 + !byte $50,%10000111 + !byte $06,%00000100 + !byte $14,%01101100 + !byte $3C,%01010011 + !byte $40,%00000000 + !byte $1A,%10101000 + !byte $04,%10101011 + !byte $44,%11010010 + !byte $58,%00000010 + !byte $00,%01100111 + !byte $1C,%01010011 + !byte $4A,%01110001 + !byte $34,%00000100 + !byte $06,%00001000 + !byte $08,%01001111 + !byte $58,%00101110 + !byte $58,%00001000 + !byte $06,%00000010 + !byte $28,%00110000 + !byte $58,%11010001 + !byte $46,%01100001 + !byte $00,%10000010 + !byte $02,%00101101 + !byte $3C,%00101011 + !byte $34,%00000110 + !byte $06,%00000110 + !byte $08,%10001110 + !byte $3C,%01101011 + !byte $5A,%00100110 + !byte $2A,%00000110 + !byte $1C,%10001010 + !byte $3C,%10010001 + !byte $46,%10001000 + !byte $2A,%00000100 + !byte $04,%00110010 + !byte $3C,%10010010 + !byte $4E,%10000010 + !byte $0E,%10000111 + !byte $28,%10101101 + !byte $3C,%01110011 + !byte $4E,%01100111 + !byte $0E,%01100010 + !byte $16,%11010001 + !byte $3C,%10010011 + !byte $44,%00001001 + !byte $18,%01001000 + !byte $02,%10110000 + !byte $3C,%11010011 + !byte $58,%01000100 + !byte $18,%10100001 + !byte $16,%00001100 + !byte $5E,%10101100 + !byte $32,%11000101 + !byte $04,%10000011 + !byte $0E,%01001100 + !byte $4A,%01101100 + !byte $5E,%11000010 + !byte $04,%00101000 + !byte $1E,%10110011 + !byte $3C,%01001010 + !byte $58,%10100101 + !byte $04,%11000001 + !byte $0E,%10010001 + !byte $3C,%11001010 + !byte $44,%00000001 + !byte $1E,%10101001 + !byte $2A,%11001101 + !byte $3C,%00010010 + !byte $4A,%10000111 + !byte $0A,%00000101 + !byte $04,%01010000 + !byte $3C,%01110010 + !byte $56,%00100010 + !byte $28,%00100110 + !byte $2A,%00010000 + !byte $3C,%00010011 + !byte $32,%00100100 + !byte $28,%11000011 + !byte $06,%11001011 + !byte $44,%00001011 + !byte $56,%11000111 + !byte $04,%01100110 + !byte $1E,%00101010 + !byte $3C,%10110010 + !byte $5E,%00100111 + !byte $1E,%01000000 + !byte $06,%00010010 + !byte $3C,%10110011 + !byte $4A,%01100010 + !byte $0C,%10100111 + !byte $04,%10001101 + !byte $58,%00001100 + !byte $3A,%10100011 + !byte $16,%11000111 + !byte $18,%01010010 + !byte $58,%10101111 + !byte $3A,%01000110 + !byte $16,%00100010 + !byte $18,%10001011 + !byte $34,%00001110 + !byte $5E,%10100001 + !byte $02,%11000110 + !byte $10,%01110001 + !byte $34,%11001111 + !byte $4C,%10100010 + !byte $0C,%01000010 + !byte $2C,%00001110 + !byte $5E,%00110001 + !byte $30,%01000100 + !byte $08,%01100101 + !byte $10,%01101100 + !byte $50,%01101100 + !byte $4C,%01000111 + !byte $02,%01001000 + !byte $00,%01010001 + !byte $50,%01110001 + !byte $5E,%01001000 + !byte $02,%00100011 + !byte $06,%00001110 + !byte $46,%01101011 + !byte $42,%01101001 + !byte $08,%10000100 + !byte $00,%01010010 + !byte $46,%01110010 + !byte $5C,%10100110 + !byte $1C,%10100000 + !byte $2C,%11001111 + !byte $5A,%10101101 + !byte $56,%01000101 + !byte $1C,%01001001 + !byte $06,%11001111 + !byte $5A,%11001011 + !byte $48,%00001000 + !byte $26,%01000110 + !byte $08,%00001100 + !byte $36,%00010000 + !byte $56,%10100100 + !byte $26,%10100011 + !byte $00,%10001100 + !byte $5A,%00010010 + !byte $5C,%01000011 + !byte $02,%10100001 + !byte $1A,%10110010 + !byte $40,%11010011 + !byte $54,%01000010 + !byte $14,%01100111 + !byte $1A,%00101011 + !byte $40,%00001010 + !byte $30,%10100101 + !byte $1A,%11001000 + !byte $14,%10001100 + !byte $36,%11001101 + !byte $48,%00000010 + !byte $14,%10000010 + !byte $08,%11010001 + !byte $52,%10010001 + !byte $42,%10000000 + !byte $0A,%11000111 + !byte $14,%01010001 + !byte $5A,%00110000 + !byte $3C,%00100000 + !byte $0A,%00100010 + !byte $24,%10001101 + !byte $52,%01001100 + !byte $54,%10100111 + !byte $2E,%00100100 + !byte $12,%01010001 + !byte $48,%11001011 + !byte $3C,%10100000 + !byte $00,%10000001 + !byte $24,%01010000 + !byte $56,%10101110 + !byte $3C,%10001001 + !byte $00,%10100010 + !byte $12,%10001100 + !byte $5C,%01001101 + !byte $3C,%01100001 + !byte $1A,%00100001 + !byte $00,%10001011 + !byte $38,%00110000 + !byte $3C,%01000000 + !byte $06,%11000101 + !byte $08,%01101111 + !byte $42,%01110011 + !byte $3C,%01100000 + !byte $06,%00100100 + !byte $02,%11010000 + !byte $48,%00010010 + !byte $3C,%00000010 + !byte $00,%01000111 + !byte $0A,%10110001 + !byte $42,%01101010 + !byte $5C,%11000001 + !byte $00,%01101000 + !byte $2E,%10101111 + !byte $38,%10101101 + !byte $38,%11000011 + !byte $12,%01100111 + !byte $2E,%00101110 + !byte $5C,%10010000 + !byte $3C,%00100001 + !byte $24,%01100110 + !byte $02,%00001101 + !byte $56,%00101111 + !byte $3C,%11000001 + !byte $2E,%11000101 + !byte $08,%01101110 + !byte $5C,%10101011 + !byte $3C,%01100010 + !byte $24,%10000011 + !byte $1C,%00110011 + !byte $5C,%00110010 + !byte $3C,%11001000 + !byte $12,%10000010 + !byte $1C,%10101010 + !byte $4A,%10010001 + !byte $3C,%01001001 + !byte $18,%10000001 + !byte $16,%00101100 + !byte $30,%00101110 + !byte $3C,%01101001 + !byte $08,%00001000 + !byte $02,%00110010 + !byte $54,%10110001 + !byte $3C,%10101001 + !byte $04,%10100011 + !byte $0A,%00101100 + !byte $5E,%11001100 + !byte $3C,%11001001 + !byte $18,%01101000 + !byte $16,%10110001 + !byte $54,%00101100 + !byte $38,%00100110 + !byte $2C,%00000100 + !byte $1E,%10010011 + !byte $58,%01001110 + !byte $3C,%00000000 + !byte $1E,%00100000 + !byte $26,%00110000 + !byte $30,%10101111 + !byte $3C,%10000000 + !byte $08,%00000010 + !byte $1E,%01001010 + !byte $5E,%00010001 + !byte $3C,%11000000 + !byte $04,%01000110 + !byte $0A,%00001111 + !byte $4A,%01001100 + !byte $3C,%00000001 + !byte $2C,%00000110 + !byte $04,%01110000 + !byte $5E,%10001011 + !byte $3C,%01000001 + !byte $10,%01100010 + !byte $0A,%11001110 + !byte $4C,%10001100 + !byte $3C,%10000001 + !byte $1E,%11001001 + !byte $26,%10101101 + !byte $3A,%10001101 + !byte $3C,%10100001 + !byte $10,%10000111 + !byte $02,%10101011 + !byte $4C,%01010001 + !byte $3C,%00100010 + !byte $16,%00000010 + !byte $04,%01101101 + !byte $58,%10001111 + !byte $3C,%01000010 + !byte $08,%01000101 + !byte $0C,%10010001 + !byte $44,%11001010 + !byte $3C,%10000010 + !byte $02,%10100110 + !byte $18,%00110010 + !byte $44,%00010011 + !byte $3C,%10100010 + !byte $06,%11000001 + !byte $18,%10101011 + !byte $3A,%01010000 + !byte $3C,%11000010 + !byte $02,%01000011 + !byte $0C,%01001100 + !byte $5E,%01010010 + !byte $3C,%00000011 + !byte $1C,%01101001 + !byte $04,%00010010 + !byte $32,%11001111 + !byte $3C,%00100011 + !byte $2A,%11000011 + !byte $04,%11001011 + !byte $46,%10010010 + !byte $3C,%01000011 + !byte $16,%00001000 + !byte $06,%00010000 + !byte $56,%00001100 + !byte $3C,%01100011 + !byte $06,%00101000 + !byte $28,%00010000 + !byte $56,%11010001 + !byte $3C,%10000011 + !byte $1C,%10000000 + !byte $28,%11001101 + !byte $46,%01001011 + !byte $3C,%01100110 + !byte $08,%10100100 + !byte $00,%01101100 + !byte $5A,%11001101 + !byte $3C,%10000110 + !byte $0E,%10100111 + !byte $1A,%10010010 + !byte $32,%00001110 + !byte $3C,%10100110 + !byte $2A,%00100110 + !byte $1A,%01001011 + !byte $4E,%01110001 + !byte $3C,%11000110 + !byte $24,%01001001 + !byte $06,%11001101 + !byte $5A,%00010000 + !byte $3C,%00000111 + !byte $24,%00001001 + !byte $14,%10101100 + !byte $4E,%01101100 + !byte $3C,%00100111 + !byte $24,%11001000 + !byte $00,%01110001 + !byte $48,%00110010 + !byte $3C,%01000111 + !byte $24,%10101000 + !byte $0E,%01110001 + !byte $58,%11001011 + !byte $3C,%01100111 + !byte $24,%10001000 + !byte $0E,%01101100 + !byte $58,%00010010 + !byte $3C,%10000111 + !byte $24,%01101000 + !byte $14,%00110001 + !byte $48,%10101011 + !byte $3C,%10100111 + !byte $24,%01001000 + !byte $06,%11010001 + !byte $42,%10010011 + !byte $3C,%11000111 + !byte $24,%00101000 + !byte $2A,%00001110 + !byte $34,%11001101 + !byte $3C,%00001000 + !byte $24,%00001000 + !byte $08,%01001110 + !byte $5C,%01110000 + !byte $3C,%00101000 + !byte $24,%11000111 + !byte $1C,%11001010 + !byte $56,%11001110 + !byte $3C,%01001000 + !byte $24,%10100111 + !byte $02,%00010001 + !byte $34,%00010000 + !byte $3C,%01101000 + !byte $24,%10000111 + !byte $02,%11001100 + !byte $56,%00001111 + !byte $3C,%10001000 + !byte $24,%01100111 + !byte $1C,%00010011 + !byte $5C,%01101101 + !byte $3C,%10101000 + !byte $24,%01000111 + !byte $08,%10001111 + !byte $42,%01001010 + !byte $3C,%00001001 + !byte $24,%00100111 + !byte $2A,%11001111 + !byte $50,%01001100 + !byte $3C,%00101001 + !byte $24,%00000111 + !byte $06,%00001100 + !byte $5A,%10101011 + !byte $40,%11001001 + !byte $24,%11000110 + !byte $16,%10010001 + !byte $50,%10010001 + !byte $5A,%10100011 + !byte $24,%10100110 + !byte $16,%01001100 + !byte $5E,%11010000 + !byte $5C,%00101000 + !byte $24,%10000110 + !byte $10,%10001100 + !byte $4A,%10110001 + !byte $5A,%01000110 + !byte $24,%01100011 + !byte $2C,%00101110 + !byte $4A,%00101100 + !byte $40,%00100000 + !byte $24,%01000011 + !byte $10,%01010001 + !byte $5E,%00001101 + !byte $46,%01101000 + !byte $24,%00100011 + !byte $0A,%10101110 + !byte $44,%10101010 + !byte $52,%01100010 + !byte $24,%00000011 + !byte $1E,%01110011 + !byte $44,%00110011 + !byte $46,%10000001 + !byte $24,%11000010 + !byte $0A,%00101111 + !byte $58,%01101110 + !byte $52,%10000111 + !byte $24,%10100010 + !byte $08,%10110001 + !byte $36,%10101101 + !byte $58,%00100100 + !byte $24,%10000010 + !byte $2C,%10101111 + !byte $36,%00110000 + !byte $36,%00000100 + !byte $24,%01100010 + !byte $08,%00101100 + !byte $5A,%00110010 + !byte $5A,%00001000 + !byte $24,%01000010 + !byte $1E,%01101010 + !byte $58,%01101111 + !byte $5A,%00000010 + !byte $24,%11000001 + !byte $04,%10010000 + !byte $52,%00101100 + !byte $36,%00000110 + !byte $24,%10000001 + !byte $04,%01001101 + !byte $52,%10110001 + !byte $5E,%01000111 + !byte $24,%01100001 + !byte $18,%11001011 + !byte $5C,%10001011 + !byte $44,%00100001 + !byte $24,%10100000 + !byte $18,%00010010 + !byte $5C,%01010010 + !byte $58,%11000101 + !byte $24,%01000000 + !byte $00,%10101011 + !byte $46,%10110010 + !byte $44,%11001000 + !byte $24,%00100000 + !byte $24,%10101101 + !byte $5A,%00001110 + !byte $4A,%01100111 + !byte $14,%01100010 + !byte $20,%11010011 + !byte $38,%10001101 + !byte $5E,%10100010 + !byte $0E,%01000010 + !byte $00,%10010001 + !byte $5A,%11001111 + !byte $50,%10000010 + !byte $24,%11001001 + !byte $00,%00110010 + !byte $46,%00101011 + !byte $4A,%10000010 + !byte $24,%10101001 + !byte $12,%00110001 + !byte $38,%01010000 + !byte $50,%01100111 + !byte $24,%00101001 + !byte $24,%00110000 + !byte $54,%00001100 + !byte $42,%01001001 + !byte $24,%00000010 + !byte $2E,%10001111 + !byte $30,%00001110 + !byte $34,%00100100 + !byte $24,%01000001 + !byte $12,%10101100 + !byte $30,%11001111 + !byte $34,%11000101 + !byte $24,%00000001 + !byte $1A,%01110010 + !byte $54,%11010001 + !byte $56,%10000100 + !byte $24,%10001001 + !byte $06,%00110000 + !byte $48,%01010010 + !byte $5C,%00100011 + !byte $24,%01101001 + !byte $2E,%01001110 + !byte $5C,%10001101 + !byte $58,%00100010 + !byte $24,%10100001 + !byte $06,%10101101 + !byte $5C,%01010000 + !byte $58,%11000111 + !byte $24,%00100001 + !byte $20,%00001010 + !byte $5E,%01101011 + !byte $56,%01100101 + !byte $24,%10000000 + !byte $0A,%10010001 + !byte $4C,%01101100 + !byte $42,%10100000 + !byte $24,%01100000 + !byte $0A,%01001100 + !byte $3A,%01110000 + !byte $5C,%11000110 + !byte $24,%00000000 + !byte $1A,%01101011 + !byte $4C,%01110001 + !byte $48,%00100010 + !byte $24,%00100010 + !byte $00,%01001100 + !byte $3A,%01101101 + !byte $4E,%01000111 + !byte $24,%11000000 + !byte $02,%00010010 + !byte $48,%10001011 + !byte $48,%11000111 + !byte $14,%10000111 + !byte $26,%00010000 + !byte $42,%00101010 + !byte $4E,%10100010 + !byte $06,%10100101 + !byte $02,%11001011 + !byte $56,%11001011 + !byte $3C,%10100011 + !byte $00,%00100111 + !byte $14,%00010001 + !byte $56,%00010010 + !byte $3C,%01000110 + !byte $04,%01001000 + !byte $08,%10101111 + !byte $5E,%01110010 + !byte $40,%10101001 + !byte $28,%01000110 + !byte $14,%11001100 + !byte $42,%10110011 + !byte $32,%01000100 + !byte $28,%10100011 + !byte $08,%00101110 + !byte $32,%11001101 + !byte $32,%10100101 + !byte $04,%10100001 + !byte $26,%11001101 + !byte $5E,%10110000 + !byte $40,%01000000 + !byte $00,%11000010 + !byte $02,%10101100 + !byte $44,%01010011 + !byte $5A,%01100110 + !byte $1A,%00001001 + !byte $1C,%11010010 + !byte $4A,%11010001 + !byte $56,%01000010 + !byte $1A,%00000001 + !byte $1C,%00001011 + !byte $4A,%00001100 + !byte $56,%10100111 + !byte $06,%01000100 + !byte $0C,%01101100 + !byte $5E,%00101101 + !byte $46,%01001000 + !byte $0C,%11000111 + !byte $16,%01101100 + !byte $4E,%01001100 + !byte $54,%00000101 + !byte $18,%01100001 + !byte $02,%00110001 + !byte $32,%00010000 + !byte $5A,%10000011 + !byte $0C,%00100010 + !byte $04,%11010001 + !byte $58,%01001111 + !byte $46,%10100001 + !byte $18,%10001000 + !byte $16,%01110001 + !byte $44,%10001010 + !byte $5E,%11000001 + !byte $1E,%00000000 + !byte $04,%10110000 + !byte $58,%10001110 + !byte $3A,%00100110 + !byte $26,%01100110 + !byte $0C,%01110001 + !byte $4E,%10010001 + !byte $5E,%00101000 + !byte $04,%00100110 + !byte $0A,%01001111 + !byte $58,%00110010 + !byte $4C,%11000010 + !byte $04,%11000011 + !byte $28,%11001111 + !byte $46,%11010010 + !byte $3A,%11000011 + !byte $26,%10000011 + !byte $28,%00001110 + !byte $58,%10101011 + !byte $30,%10000101 + !byte $02,%01101000 + !byte $04,%00001100 + !byte $5A,%00101110 + !byte $4C,%00100111 + !byte $0A,%00000010 + !byte $0A,%10001110 + !byte $34,%10101101 + !byte $58,%00000110 + !byte $02,%10000001 + !byte $1E,%10001010 + !byte $46,%00001011 + !byte $58,%00000100 + !byte $0A,%00001000 + !byte $22,%00101010 + !byte $34,%00110000 + !byte $44,%01000001 + !byte $2E,%00000110 + !byte $04,%00101101 + !byte $50,%10110001 + !byte $30,%01100100 + !byte $16,%00101000 + !byte $22,%01010011 + !byte $5A,%10101111 + !byte $54,%10000111 + !byte $16,%11000001 + !byte $1E,%01010011 + !byte $50,%00101100 + !byte $5E,%10000010 + !byte $2E,%00000100 + !byte $22,%00110010 + !byte $42,%11010011 + !byte $54,%01100010 + !byte $00,%01100001 + !byte $22,%01010001 + !byte $48,%01110010 + !byte $5E,%01100111 + !byte $02,%01100011 + !byte $22,%00001010 + !byte $5C,%00110000 + !byte $4A,%10100010 + !byte $08,%11000100 + !byte $18,%11010001 + !byte $5A,%10001011 + !byte $44,%10101000 + !byte $1C,%01100000 + !byte $22,%10110001 + !byte $36,%10001101 + !byte $4A,%01000111 + !byte $12,%01100010 + !byte $22,%00101011 + !byte $36,%01010000 + !byte $5C,%00000010 + !byte $08,%00100101 + !byte $22,%10101010 + !byte $5A,%01010010 + !byte $38,%00000100 + !byte $02,%10000110 + !byte $22,%11010011 + !byte $5C,%10101101 + !byte $38,%00000110 + !byte $00,%10001000 + !byte $22,%10110011 + !byte $42,%00001010 + !byte $5C,%00001000 + !byte $12,%10000111 + !byte $22,%10010011 + !byte $52,%11010001 + !byte $42,%11000000 + !byte $1C,%10001001 + !byte $22,%01110011 + !byte $48,%01101011 + !byte $56,%01100100 + !byte $2C,%11000011 + !byte $22,%00110011 + !byte $52,%00001100 + !byte $56,%10000101 + !byte $14,%10100111 + !byte $22,%10110010 + !byte $4A,%00010010 + !byte $42,%00101001 + !byte $08,%00101000 + !byte $22,%01110001 + !byte $38,%01101101 + !byte $48,%10100111 + !byte $08,%11000001 + !byte $22,%01101011 + !byte $4A,%11001011 + !byte $5C,%00000011 + !byte $14,%01000010 + !byte $22,%10001010 + !byte $44,%01101010 + !byte $52,%10000010 + !byte $2C,%00100110 + !byte $22,%01101010 + !byte $5C,%01110010 + !byte $52,%01100111 + !byte $06,%01100100 + !byte $22,%01001010 + !byte $5E,%01001101 + !byte $5C,%00000111 + !byte $00,%00000111 + !byte $18,%00001100 + !byte $3A,%00001010 + !byte $40,%01100000 + !byte $00,%00000011 + !byte $0E,%01010001 + !byte $3A,%00101010 + !byte $5A,%00100010 + !byte $1A,%00101001 + !byte $0E,%10001100 + !byte $3A,%01001010 + !byte $36,%11000101 + !byte $1A,%11000000 + !byte $22,%00010011 + !byte $3A,%10101010 + !byte $5A,%11000111 + !byte $10,%10100111 + !byte $22,%11010010 + !byte $3A,%11001010 + !byte $40,%10001001 + !byte $06,%10000101 + !byte $22,%10010010 + !byte $3A,%00001011 + !byte $36,%00100100 + !byte $10,%01000010 + !byte $22,%01110010 + !byte $3A,%00101011 + !byte $48,%01000010 + !byte $06,%01001000 + !byte $22,%01010010 + !byte $3A,%01001011 + !byte $54,%11000100 + !byte $18,%10101000 + !byte $22,%00010010 + !byte $3A,%01101011 + !byte $54,%00100101 + !byte $18,%01000001 + !byte $22,%11010001 + !byte $3A,%10001011 + !byte $46,%00101000 + !byte $04,%00000100 + !byte $22,%10010001 + !byte $3A,%10101011 + !byte $5A,%01100011 + !byte $2A,%01000110 + !byte $22,%00110001 + !byte $3A,%11001011 + !byte $5A,%10000110 + !byte $2A,%10100011 + !byte $22,%00010001 + !byte $3A,%00001100 + !byte $46,%11000001 + !byte $0E,%00100010 + !byte $22,%11010000 + !byte $3A,%00101100 + !byte $50,%10100010 + !byte $04,%00000110 + !byte $22,%10110000 + !byte $3A,%01001100 + !byte $50,%01000111 + !byte $06,%10100001 + !byte $22,%10010000 + !byte $3A,%01101100 + !byte $34,%10100101 + !byte $0E,%11000111 + !byte $22,%01110000 + !byte $3A,%10001100 + !byte $58,%01000010 + !byte $28,%10000011 + !byte $22,%01010000 + !byte $3A,%10101100 + !byte $34,%01000100 + !byte $04,%10000001 + !byte $22,%10001101 + !byte $3A,%11001100 + !byte $3E,%00000000 + !byte $16,%10100001 + !byte $22,%01101101 + !byte $3A,%00001101 + !byte $58,%11000011 + !byte $16,%01001000 + !byte $22,%01001101 + !byte $3A,%00101101 + !byte $44,%01100001 + !byte $04,%01101000 + !byte $22,%00101101 + !byte $3A,%01001101 + !byte $44,%10001000 + !byte $28,%01100110 + !byte $22,%00001101 + !byte $3A,%10010000 + !byte $5E,%01100010 + !byte $1C,%10101001 + !byte $22,%11001100 + !byte $3A,%10110000 + !byte $58,%10100111 + !byte $08,%00000101 + !byte $22,%10101100 + !byte $3A,%11010000 + !byte $58,%00100110 + !byte $02,%01100110 + !byte $22,%10001100 + !byte $3A,%00010001 + !byte $4A,%00100111 + !byte $02,%10000011 + !byte $22,%01101100 + !byte $3A,%00110001 + !byte $3C,%11000011 + !byte $1C,%01000000 + !byte $22,%01001100 + !byte $3A,%01010001 + !byte $3C,%00100110 + !byte $0C,%00001000 + !byte $22,%00101100 + !byte $3A,%01110001 + !byte $4A,%11000010 + !byte $0C,%00000010 + !byte $22,%00001100 + !byte $3A,%10010001 + !byte $4E,%11000010 + !byte $14,%11000111 + !byte $22,%11001011 + !byte $3A,%10110001 + !byte $4E,%00100111 + !byte $14,%00100010 + !byte $22,%10101011 + !byte $3A,%11010001 + !byte $5E,%10000111 + !byte $1A,%01001001 + !byte $22,%10001011 + !byte $3A,%00110010 + !byte $32,%10000101 + !byte $26,%01100011 + !byte $22,%01001011 + !byte $3A,%01010010 + !byte $42,%00001001 + !byte $00,%11000110 + !byte $22,%00001011 + !byte $3A,%01110010 + !byte $56,%10000111 + !byte $02,%10001000 + !byte $22,%11001010 + !byte $3A,%10110010 + !byte $56,%10100101 + !byte $00,%00100011 + !byte $20,%00101010 + !byte $3A,%11010010 + !byte $56,%01100010 + !byte $06,%01100101 + !byte $2A,%10101111 + !byte $3A,%00010011 + !byte $32,%01100100 + !byte $26,%10000110 + !byte $06,%10110001 + !byte $3A,%10010011 + !byte $56,%01000100 + !byte $0A,%11000001 + !byte $2A,%00101110 + !byte $44,%01110011 + !byte $5C,%11000010 + !byte $06,%10000100 + !byte $06,%00101100 + !byte $5C,%01101011 + !byte $42,%00000001 + !byte $1A,%10100000 + !byte $06,%10001101 + !byte $38,%01110000 + !byte $48,%10000111 + !byte $02,%01100001 + !byte $00,%00101100 + !byte $58,%00101111 + !byte $48,%01100010 + !byte $0A,%00101000 + !byte $20,%10110011 + !byte $3A,%01101010 + !byte $3A,%00000110 + !byte $2E,%11000011 + !byte $06,%01010000 + !byte $3A,%10001010 + !byte $5C,%00100111 + !byte $18,%11001000 + !byte $1A,%01010010 + !byte $3A,%01010011 + !byte $4C,%00000111 + !byte $00,%01000001 + !byte $1A,%10001011 + !byte $3A,%11010011 + !byte $5E,%00000010 + !byte $04,%00100100 + !byte $22,%00110000 + !byte $58,%10101110 + !byte $30,%10000100 + !byte $12,%10100111 + !byte $22,%10101101 + !byte $5E,%10010000 + !byte $5E,%00001000 + !byte $2E,%00100110 + !byte $10,%10101100 + !byte $3A,%10010010 + !byte $4C,%00000011 + !byte $12,%01000010 + !byte $2C,%01001110 + !byte $3A,%00010010 + !byte $3A,%00000100 + !byte $00,%10101000 + !byte $00,%10110001 + !byte $3A,%00110011 + !byte $40,%10000000 + !byte $18,%00100001 + !byte $10,%00110001 + !byte $3A,%01110011 + !byte $54,%10100100 + !byte $04,%11000101 + !byte $2C,%10001111 + !byte $3A,%10110011 + !byte $30,%01100101 + !byte $2C,%01000110 + !byte $1C,%10110010 + !byte $54,%11001011 + !byte $54,%01000101 + !byte $08,%10100001 + !byte $02,%01010001 + !byte $30,%11001101 + !byte $40,%01101001 + !byte $08,%01001000 + !byte $08,%10010001 + !byte $30,%00010000 + !byte $5A,%01000011 + !byte $16,%10000001 + !byte $08,%01001100 + !byte $54,%00010010 + !byte $54,%10000010 + !byte $2C,%10100011 + !byte $08,%00001110 + !byte $4C,%01001100 + !byte $54,%01100111 + !byte $02,%01000110 + !byte $1C,%00101011 + !byte $5A,%01001110 + !byte $3E,%11001001 + !byte $10,%11000111 + !byte $00,%11001011 + !byte $4C,%10010001 + !byte $5A,%10100110 + !byte $02,%10100011 + !byte $16,%10001100 + !byte $46,%11001010 + !byte $46,%00000010 + !byte $1C,%00100000 + !byte $08,%11001111 + !byte $46,%00010011 + !byte $46,%00001000 + !byte $10,%00100010 + !byte $00,%00010010 + !byte $5E,%01001011 + !byte $3E,%00100000 + !byte $16,%01101000 + !byte $02,%10001100 + !byte $5A,%10001111 + !byte $5C,%00100010 + !byte $1C,%11001001 + !byte $12,%00010001 + !byte $5E,%10010010 + !byte $5C,%11000111 + !byte $14,%00001000 + !byte $12,%11001100 + !byte $56,%10101011 + !byte $38,%00100100 + !byte $06,%01101000 + !byte $24,%00010000 + !byte $56,%00110010 + !byte $38,%11000101 + !byte $2A,%01100110 + !byte $24,%11001101 + !byte $48,%01001011 + !byte $58,%10100011 + !byte $2A,%10000011 + !byte $16,%01010001 + !byte $5C,%11001101 + !byte $58,%01000110 + !byte $1A,%01101001 + !byte $0A,%01101111 + !byte $32,%10101101 + !byte $5E,%01000010 + !byte $14,%00000010 + !byte $04,%11010000 + !byte $32,%00110000 + !byte $5E,%10100111 + !byte $00,%10100110 + !byte $04,%00001101 + !byte $48,%10010010 + !byte $52,%10100010 + !byte $0E,%00001000 + !byte $1E,%00110011 + !byte $4E,%00101100 + !byte $52,%01000111 + !byte $06,%10000001 + !byte $2E,%01101111 + !byte $4E,%10110001 + !byte $44,%10000001 + !byte $00,%01000011 + !byte $0A,%01101110 + !byte $5C,%00010000 + !byte $44,%01101000 + !byte $06,%10100100 + !byte $0A,%01110001 + !byte $4A,%00110010 + !byte $36,%01000100 + !byte $06,%01000101 + !byte $0A,%01101100 + !byte $58,%10001011 + !byte $4A,%00000111 + !byte $0E,%00000010 + !byte $2E,%01101110 + !byte $58,%01010010 + !byte $5A,%01000010 + !byte $1A,%10000000 + !byte $1E,%10101010 + !byte $34,%10001101 + !byte $36,%10100101 + !byte $04,%10001000 + !byte $18,%00101100 + !byte $34,%01010000 + !byte $4A,%00000011 + !byte $28,%01100011 + !byte $18,%10110001 + !byte $5E,%01101101 + !byte $5A,%10100111 + !byte $18,%00001001 + !byte $20,%10010011 + !byte $44,%01001010 + !byte $42,%00100001 + !byte $28,%10000110 + !byte $02,%11010001 + !byte $4A,%10101011 + !byte $56,%00100100 + !byte $04,%01000100 + !byte $26,%11001111 + !byte $5E,%01110000 + !byte $5C,%01000111 + !byte $18,%00000001 + !byte $02,%00001100 + !byte $50,%00001100 + !byte $3E,%01000000 + !byte $04,%01100001 + !byte $26,%00001110 + !byte $50,%11010001 + !byte $3E,%10101001 + !byte $04,%10100101 + !byte $14,%00001101 + !byte $58,%00001111 + !byte $5C,%10100010 + !byte $0C,%00101000 + !byte $14,%11010000 + !byte $44,%10010011 + !byte $50,%11000010 + !byte $0C,%11000001 + !byte $0C,%11001110 + !byte $58,%11001110 + !byte $56,%11000101 + !byte $26,%01000011 + !byte $06,%01101101 + !byte $4C,%10110001 + !byte $42,%11001000 + !byte $16,%10001000 + !byte $20,%01001010 + !byte $5A,%01101011 + !byte $48,%10000010 + !byte $02,%10101000 + !byte $0C,%00001111 + !byte $5A,%01110010 + !byte $48,%01100111 + !byte $26,%10100110 + !byte $0C,%01010001 + !byte $46,%10101010 + !byte $34,%10000101 + !byte $02,%01000001 + !byte $0C,%10001100 + !byte $36,%01101101 + !byte $50,%00100111 + !byte $16,%01100001 + !byte $1A,%00110010 + !byte $4C,%00101100 + !byte $58,%01100010 + !byte $02,%00100110 + !byte $06,%01110000 + !byte $36,%01110000 + !byte $58,%10000111 + !byte $0A,%01001000 + !byte $00,%11010001 + !byte $5A,%01101110 + !byte $3E,%10101000 + !byte $02,%11000011 + !byte $28,%10101111 + !byte $52,%11001011 + !byte $54,%10000100 + !byte $1C,%00000000 + !byte $04,%00101100 + !byte $46,%00110011 + !byte $5A,%00100011 + !byte $2E,%01000110 + !byte $00,%00001100 + !byte $5A,%01101111 + !byte $5E,%00100010 + !byte $0A,%10100001 + !byte $1A,%10101011 + !byte $52,%00010010 + !byte $34,%01100100 + !byte $26,%01101001 + !byte $04,%10110001 + !byte $38,%01001101 + !byte $40,%10100000 + !byte $26,%01001001 + !byte $28,%00101110 + !byte $38,%10010000 + !byte $3E,%00100001 + !byte $26,%00101001 + !byte $1C,%01001011 + !byte $5C,%10010010 + !byte $3E,%01100001 + !byte $26,%00001001 + !byte $1C,%10010010 + !byte $48,%10110010 + !byte $3E,%01001001 + !byte $26,%11001000 + !byte $08,%00010000 + !byte $5C,%01001011 + !byte $3E,%01101001 + !byte $26,%10001000 + !byte $08,%11001101 + !byte $48,%00101011 + !byte $3E,%00100010 + !byte $26,%01101000 + !byte $0E,%10101100 + !byte $5C,%00001110 + !byte $3E,%10001001 + !byte $26,%01001000 + !byte $02,%01101100 + !byte $54,%10101011 + !byte $3E,%01100000 + !byte $26,%00101000 + !byte $16,%10101100 + !byte $5C,%11001111 + !byte $3E,%10000000 + !byte $26,%00001000 + !byte $02,%01110001 + !byte $30,%10101101 + !byte $3E,%10100000 + !byte $26,%11000111 + !byte $06,%10010001 + !byte $54,%00110010 + !byte $3E,%11000000 + !byte $26,%10100111 + !byte $0E,%00110001 + !byte $30,%00110000 + !byte $3E,%00000001 + !byte $26,%10000111 + !byte $2A,%01001110 + !byte $4A,%01010010 + !byte $3E,%10000010 + !byte $26,%01100111 + !byte $16,%00110001 + !byte $5E,%01010000 + !byte $3E,%11000010 + !byte $26,%01000111 + !byte $2A,%10001111 + !byte $4A,%10001011 + !byte $3E,%00101000 + !byte $26,%00100111 + !byte $06,%01001100 + !byte $5E,%00101011 + !byte $40,%01001001 + !byte $26,%00000111 + !byte $1E,%11001010 + !byte $5E,%10001101 + !byte $5E,%11000111 + !byte $26,%11000110 + !byte $04,%00010001 + !byte $56,%10001011 + !byte $54,%01100101 + !byte $26,%00100011 + !byte $1E,%00010011 + !byte $56,%01010010 + !byte $3E,%01000001 + !byte $26,%00000011 + !byte $0A,%10001111 + !byte $44,%00101010 + !byte $3E,%10000001 + !byte $26,%11000010 + !byte $0A,%01001110 + !byte $5E,%10110010 + !byte $3E,%10100001 + !byte $26,%10100010 + !byte $04,%11001100 + !byte $44,%10110011 + !byte $3E,%11000001 + !byte $26,%10000010 + !byte $10,%00010001 + !byte $32,%10001101 + !byte $3E,%00000010 + !byte $26,%01000010 + !byte $18,%01001100 + !byte $32,%01010000 + !byte $3E,%01000010 + !byte $26,%00100010 + !byte $22,%00010000 + !byte $4C,%00001100 + !byte $3E,%01100010 + !byte $26,%00000010 + !byte $2C,%01101110 + !byte $4C,%11010001 + !byte $3E,%10100010 + !byte $26,%11000001 + !byte $22,%11001101 + !byte $4E,%00001100 + !byte $3E,%00000011 + !byte $26,%10000001 + !byte $10,%11001100 + !byte $46,%01010011 + !byte $3E,%00100011 + !byte $26,%01100001 + !byte $18,%10010001 + !byte $5A,%10001110 + !byte $3E,%01000011 + !byte $26,%01000001 + !byte $08,%01110001 + !byte $4E,%11010001 + !byte $3E,%01100011 + !byte $26,%10100000 + !byte $20,%01101010 + !byte $5A,%01001111 + !byte $3E,%10000011 + !byte $26,%10000000 + !byte $20,%01110011 + !byte $46,%10001010 + !byte $3E,%10100011 + !byte $26,%01000000 + !byte $0C,%00101111 + !byte $58,%01101011 + !byte $3E,%11000011 + !byte $26,%00000000 + !byte $2C,%01101111 + !byte $34,%01110000 + !byte $3E,%00100110 + !byte $2E,%10100011 + !byte $08,%01101100 + !byte $34,%01101101 + !byte $3E,%01000110 + !byte $00,%00100001 + !byte $0C,%10101110 + !byte $5C,%10101111 + !byte $3E,%01100110 + !byte $14,%00101000 + !byte $1A,%00010010 + !byte $50,%11001011 + !byte $3E,%10000110 + !byte $26,%11001001 + !byte $06,%10010000 + !byte $58,%01110010 + !byte $3E,%10100110 + !byte $26,%10101001 + !byte $06,%01001101 + !byte $5C,%00101110 + !byte $3E,%11000110 + !byte $26,%10001001 + !byte $1A,%11001011 + !byte $50,%00010010 + !byte $3E,%00000111 + !byte $26,%01100010 + !byte $24,%00001110 + !byte $48,%00001011 + !byte $3E,%00100111 + !byte $12,%11000111 + !byte $12,%11010000 + !byte $48,%11010010 + !byte $3E,%01000111 + !byte $12,%00100010 + !byte $2E,%10001110 + !byte $5A,%01001011 + !byte $3E,%01100111 + !byte $26,%10101000 + !byte $02,%10010001 + !byte $36,%01001101 + !byte $3E,%10000111 + !byte $26,%10100001 + !byte $24,%11001111 + !byte $36,%10010000 + !byte $3E,%10100111 + !byte $1A,%01100000 + !byte $12,%00001101 + !byte $5A,%10010010 + !byte $3E,%11000111 + !byte $14,%11000001 + !byte $1C,%01101011 + !byte $4A,%01101011 + !byte $3E,%00001000 + !byte $00,%10000110 + !byte $2E,%01001111 + !byte $4A,%01110010 + !byte $3E,%01001000 + !byte $00,%11001000 + !byte $1C,%01110010 + !byte $44,%11010011 + !byte $3E,%01101000 + !byte $26,%00100001 + !byte $08,%00110000 + !byte $5E,%10101101 + !byte $3E,%10001000 + !byte $26,%00000001 + !byte $02,%10110001 + !byte $52,%10101011 + !byte $3E,%11001000 + !byte $26,%11000000 + !byte $0A,%01010001 + !byte $5E,%00110000 + !byte $3E,%00001001 + !byte $26,%00100000 + !byte $0A,%10001100 + !byte $44,%00001010 + !byte $3E,%00101001 + !byte $06,%00100101 + !byte $08,%10101101 + !byte $52,%00110010 + !byte $46,%00100010 + !byte $06,%11000100 + !byte $02,%00101100 + !byte $38,%00101101 + !byte $4E,%00000011 + !byte $1A,%10001001 + !byte $26,%00101110 + !byte $38,%10110000 + !byte $3C,%00000100 + !byte $26,%01100000 + !byte $02,%01001100 + !byte $4C,%00010010 + !byte $4E,%00000111 + !byte $00,%01100011 + !byte $14,%10110000 + !byte $5C,%10110010 + !byte $5A,%11000110 + !byte $08,%01101000 + !byte $26,%10101111 + !byte $4C,%11001011 + !byte $46,%11000111 + !byte $08,%10000001 + !byte $14,%00101101 + !byte $5C,%00101011 + !byte $3C,%00000110 + !byte $2C,%01100110 + !byte $16,%00010001 + !byte $5A,%00101111 + !byte $32,%10000100 + !byte $2C,%10000011 + !byte $1E,%11010010 + !byte $54,%01010010 + !byte $58,%10000011 + !byte $18,%00101001 + !byte $16,%11001100 + !byte $46,%01101010 + !byte $56,%10000010 + !byte $10,%00001000 + !byte $0C,%00110001 + !byte $5A,%10101110 + !byte $56,%01100111 + !byte $04,%01100100 + !byte $1E,%00001011 + !byte $54,%10001011 + !byte $44,%01001000 + !byte $18,%11000000 + !byte $0A,%10101111 + !byte $30,%01010000 + !byte $32,%01100101 + !byte $10,%00000010 + !byte $04,%00110001 + !byte $46,%01110011 + !byte $58,%01100110 + !byte $04,%10000101 + !byte $04,%10010001 + !byte $30,%10001101 + !byte $52,%00000101 + !byte $06,%10001000 + !byte $0A,%00101110 + !byte $5E,%11010010 + !byte $3A,%11000101 + !byte $2A,%01100011 + !byte $0C,%10101100 + !byte $48,%00010011 + !byte $44,%10100001 + !byte $16,%01000001 + !byte $04,%10101100 + !byte $5E,%00001011 + !byte $4C,%11000110 + !byte $06,%01100001 + !byte $18,%01110001 + !byte $5C,%01001110 + !byte $4A,%00100011 + !byte $02,%00000110 + !byte $28,%10001111 + !byte $5C,%10001111 + !byte $3A,%00100100 + !byte $0E,%00101000 + !byte $28,%01001110 + !byte $48,%11001010 + !byte $4A,%11000110 + !byte $2A,%10000110 + !byte $04,%01001100 + !byte $56,%01101011 + !byte $4C,%00100011 + !byte $16,%10101000 + !byte $18,%01101100 + !byte $56,%01110010 + !byte $30,%10100100 + !byte $0E,%11000001 + !byte $20,%10001010 + !byte $32,%01101101 + !byte $42,%10101000 + !byte $02,%00000100 + !byte $0C,%01001111 + !byte $32,%01110000 + !byte $5C,%10000010 + !byte $04,%10101000 + !byte $20,%01010011 + !byte $4E,%11001011 + !byte $5C,%01000010 + !byte $28,%01000011 + !byte $06,%10110000 + !byte $4E,%00010010 + !byte $5C,%01100111 + !byte $04,%01000001 + !byte $0C,%10001110 + !byte $5E,%00010000 + !byte $42,%01000001 + !byte $14,%01001000 + !byte $0E,%00010001 + !byte $4A,%10010010 + !byte $56,%00000100 + !byte $14,%10100001 + !byte $0E,%11001100 + !byte $4A,%01001011 + !byte $30,%01000101 + !byte $00,%01100110 + !byte $2A,%01101111 + !byte $5E,%11001101 + !byte $48,%01000111 + !byte $1A,%01000000 + !byte $2A,%01101110 + !byte $58,%10010010 + !byte $54,%10100010 + !byte $0C,%01001000 + !byte $06,%00101101 + !byte $58,%01001011 + !byte $54,%01000111 + !byte $28,%10100110 + !byte $1A,%11010001 + !byte $38,%01001010 + !byte $38,%01000100 + !byte $06,%00000101 + !byte $1A,%00001100 + !byte $38,%01101010 + !byte $56,%00000110 + !byte $00,%10000011 + !byte $06,%01110001 + !byte $38,%10101010 + !byte $38,%10100101 + !byte $1A,%10101001 + !byte $06,%01101100 + !byte $38,%00001011 + !byte $5C,%10100111 + !byte $0C,%10100001 + !byte $08,%01010000 + !byte $38,%00101011 + !byte $48,%10100010 + !byte $02,%11001000 + !byte $08,%10001101 + !byte $38,%01001011 + !byte $54,%01100100 + !byte $18,%01001001 + !byte $1C,%01010010 + !byte $38,%01101011 + !byte $54,%10000101 + !byte $04,%10000100 + !byte $22,%11001111 + !byte $38,%10001011 + !byte $40,%11000000 + !byte $0A,%01101000 + !byte $22,%00001110 + !byte $38,%10101011 + !byte $40,%00101001 + !byte $18,%10100000 + !byte $1C,%10001011 + !byte $38,%11001011 + !byte $46,%10100111 + !byte $04,%01100101 + !byte $10,%11010000 + !byte $38,%00001100 + !byte $5A,%00000011 + !byte $02,%00100001 + !byte $10,%00001101 + !byte $38,%00101100 + !byte $52,%11000010 + !byte $2E,%10000011 + !byte $20,%00110011 + !byte $38,%01001100 + !byte $52,%00100111 + !byte $0A,%10000001 + !byte $08,%01010001 + !byte $38,%01101100 + !byte $5A,%00000111 + !byte $16,%00100001 + !byte $20,%10101010 + !byte $38,%10001100 + !byte $5A,%01100010 + !byte $12,%00001000 + !byte $16,%00001101 + !byte $38,%10101100 + !byte $46,%01000010 + !byte $2E,%01100110 + !byte $2C,%01001111 + !byte $38,%11001100 + !byte $36,%01100100 + !byte $12,%00000010 + !byte $2C,%10001110 + !byte $38,%00001101 + !byte $36,%10000101 + !byte $00,%00001001 + !byte $16,%11010000 + !byte $38,%11010000 + !byte $58,%01100011 + !byte $00,%00000001 + !byte $1E,%10110010 + !byte $38,%00010001 + !byte $5A,%10000111 + !byte $02,%11000101 + !byte $0A,%00001110 + !byte $38,%00110001 + !byte $52,%00100101 + !byte $02,%00100100 + !byte $08,%10001100 + !byte $38,%01010001 + !byte $44,%11000001 + !byte $16,%11001000 + !byte $1E,%00101011 + !byte $38,%01110001 + !byte $44,%00101000 + !byte $08,%10001000 + !byte $04,%01010001 + !byte $38,%10010001 + !byte $52,%11000100 + !byte $2C,%01100011 + !byte $04,%10001100 + !byte $38,%11010001 + !byte $50,%00000011 + !byte $08,%01100001 + !byte $0A,%11001111 + !byte $38,%00010010 + !byte $3E,%00000100 + !byte $14,%10000001 + !byte $24,%00101110 + !byte $38,%00110010 + !byte $34,%10000100 + !byte $2C,%10000110 + !byte $12,%00101101 + !byte $38,%01010010 + !byte $3E,%00000110 + !byte $10,%00101000 + !byte $18,%10001100 + !byte $38,%11010010 + !byte $50,%00000111 + !byte $10,%11000001 + !byte $2E,%10101110 + !byte $38,%01110011 + !byte $58,%10000110 + !byte $14,%01101000 + !byte $18,%01010001 + !byte $38,%10010011 + !byte $4A,%10100110 + !byte $00,%01000110 + !byte $12,%10110000 + !byte $34,%01001101 + !byte $58,%10000010 + !byte $00,%10100011 + !byte $24,%10101111 + !byte $38,%00001010 + !byte $34,%01100101 + !byte $06,%10101000 + !byte $20,%01110010 + !byte $38,%00101010 + !byte $58,%01100111 + !byte $2A,%10100110 + !byte $20,%00110001 + !byte $38,%11001010 + !byte $4A,%01000011 + !byte $1A,%00100000 + !byte $20,%11001010 + !byte $38,%01110010 + !byte $5C,%01100010 + !byte $1A,%11001001 + !byte $2E,%00101111 + !byte $38,%10010010 + !byte $42,%10001000 + !byte $2A,%01000011 + !byte $0A,%10101100 + !byte $38,%10110010 + !byte $56,%00100110 + !byte $06,%01000001 + !byte $20,%00010011 + !byte $38,%00010011 + !byte $5C,%10000111 + !byte $0E,%01001000 + !byte $20,%11010010 + !byte $38,%01010011 + !byte $3C,%00100100 + !byte $18,%10000000 + !byte $20,%10110010 + !byte $38,%10001010 + !byte $3C,%11000101 + !byte $0E,%10100001 + !byte $20,%01010010 + !byte $38,%10110001 + !byte $42,%01100001 + !byte $04,%01000101 + !byte $20,%00101100 + !byte $38,%10110011 + !byte $56,%11000011 + !byte $04,%10100100 + !byte $20,%10001011 + !byte $38,%00110011 + !byte $4E,%00100011 + !byte $18,%01101001 + !byte $20,%00001011 + !byte $34,%10010000 + !byte $4E,%11000110 + !byte $04,%11001000 + !byte $0C,%01101111 + !byte $38,%11010011 + !byte $48,%00100111 + !byte $28,%11000110 + !byte $0A,%00110001 + !byte $4C,%00110010 + !byte $32,%10100100 + !byte $04,%00100001 + !byte $06,%00001101 + !byte $50,%10101011 + !byte $32,%01000101 + !byte $02,%10100101 + !byte $20,%10010010 + !byte $4C,%10101011 + !byte $48,%11000010 + !byte $0C,%01101000 + !byte $20,%00110010 + !byte $50,%00110010 + !byte $56,%01000111 + !byte $28,%00100011 + !byte $20,%00010010 + !byte $46,%01001010 + !byte $40,%00001001 + !byte $16,%00001001 + !byte $20,%11010001 + !byte $5A,%11001110 + !byte $5A,%11000010 + !byte $16,%00000001 + !byte $20,%10110001 + !byte $5A,%00001111 + !byte $56,%10100010 + !byte $02,%01000100 + !byte $20,%10010001 + !byte $46,%10010011 + !byte $5A,%00100111 + !byte $0C,%10000001 + !byte $20,%01110001 + !byte $5A,%00101011 + !byte $54,%01000100 + !byte $02,%00000001 + !byte $20,%01010001 + !byte $5A,%10110010 + !byte $54,%10100101 + !byte $02,%00001001 + !byte $20,%00010001 + !byte $36,%00101101 + !byte $40,%00000001 + !byte $14,%01100001 + !byte $20,%11010000 + !byte $36,%10110000 + !byte $3A,%01000100 + !byte $00,%00100110 + !byte $20,%10110000 + !byte $5C,%01101110 + !byte $4C,%01000011 + !byte $0A,%10001000 + !byte $20,%10010000 + !byte $52,%10001011 + !byte $3A,%10100101 + !byte $2E,%10000110 + !byte $20,%01110000 + !byte $5C,%01101111 + !byte $4C,%10100110 + !byte $14,%10001000 + !byte $20,%01010000 + !byte $48,%00110011 + !byte $46,%01100010 + !byte $0A,%01100001 + !byte $20,%00110000 + !byte $48,%10101010 + !byte $30,%11000100 + !byte $00,%11000011 + !byte $20,%00010000 + !byte $52,%01010010 + !byte $30,%00100101 + !byte $2E,%01100011 + !byte $20,%11001101 + !byte $5C,%00001011 + !byte $46,%10000111 + !byte $1A,%00000000 + !byte $20,%10101101 + !byte $5C,%11010010 + !byte $54,%11000010 + !byte $12,%11000001 + !byte $20,%10001101 + !byte $4A,%10110010 + !byte $54,%00100111 + !byte $12,%00101000 + !byte $20,%01101101 + !byte $4A,%00101011 + !byte $52,%01000101 + !byte $00,%00101001 + !byte $20,%01001101 + !byte $5E,%00001110 + !byte $58,%10100110 + !byte $00,%11000000 + !byte $20,%00101101 + !byte $54,%01101011 + !byte $52,%10100100 + !byte $18,%01100000 + !byte $20,%00001101 + !byte $54,%01110010 + !byte $38,%10000101 + !byte $04,%00100101 + !byte $20,%11001100 + !byte $5E,%11001111 + !byte $44,%00001000 + !byte $04,%11000100 + !byte $20,%10101100 + !byte $30,%01101101 + !byte $58,%01000011 + !byte $18,%10001001 + !byte $20,%10001100 + !byte $30,%01110000 + !byte $44,%00000010 + !byte $08,%10101000 + !byte $20,%01101100 + !byte $5E,%11001010 + !byte $38,%01100100 + !byte $08,%01000001 + !byte $20,%01001100 + !byte $5E,%00010011 + !byte $4A,%10000110 + !byte $2C,%10100110 + !byte $20,%00001100 + !byte $4C,%01010010 + !byte $42,%10000001 + !byte $2C,%01000011 + !byte $20,%11001011 + !byte $4C,%10001011 + !byte $56,%10100011 + !byte $10,%01001000 + !byte $20,%10101011 + !byte $46,%10110011 + !byte $52,%00000011 + !byte $10,%10100001 + !byte $20,%01101011 + !byte $56,%01001011 + !byte $4A,%01100011 + !byte $16,%00101001 + !byte $20,%01001011 + !byte $32,%01001101 + !byte $42,%01101000 + !byte $02,%10000101 + !byte $20,%00101011 + !byte $56,%10010010 + !byte $36,%01100101 + !byte $06,%11001000 + !byte $26,%10001111 + !byte $46,%00101010 + !byte $52,%00000111 + !byte $02,%01100100 + !byte $0C,%01101110 + !byte $32,%10010000 + !byte $56,%01000110 + !byte $2A,%00100011 + !byte $1A,%00101100 + !byte $4E,%00110010 + !byte $5A,%10000010 + !byte $16,%11000000 + !byte $06,%11010000 + !byte $4E,%10101011 + !byte $5A,%01100111 + !byte $2A,%11000110 + !byte $04,%01110001 + !byte $5C,%10001110 + !byte $48,%00000111 + !byte $06,%00100001 + !byte $1A,%10110001 + !byte $5C,%01001111 + !byte $36,%10000100 + !byte $00,%00000110 + !byte $14,%10010000 + !byte $48,%01010011 + !byte $48,%00000011 + !byte $0E,%01101000 + !byte $26,%01001110 + !byte $48,%10001010 + !byte $40,%11001000 + !byte $0E,%10000001 + !byte $14,%01001101 + !byte $58,%00101011 + !byte $54,%11000101 + !byte $14,%10101000 + !byte $04,%01101100 + !byte $34,%10110000 + !byte $5A,%10100010 + !byte $14,%01000001 + !byte $0C,%11001100 + !byte $58,%10110010 + !byte $50,%00100011 + !byte $28,%11001001 + !byte $0E,%00001111 + !byte $34,%00101101 + !byte $5A,%01000111 + !byte $28,%10101001 + !byte $0C,%00010001 + !byte $50,%10001011 + !byte $54,%00100100 + !byte $28,%01101001 + !byte $08,%01101101 + !byte $50,%01010010 + !byte $3E,%00100100 + !byte $28,%01001001 + !byte $0E,%11001110 + !byte $5E,%10101111 + !byte $3E,%11000101 + !byte $28,%00101001 + !byte $1C,%00110010 + !byte $4A,%11010010 + !byte $50,%11000110 + !byte $28,%00001001 + !byte $28,%01101111 + !byte $4A,%00001011 + !byte $40,%00100001 + !byte $28,%11001000 + !byte $1C,%10101011 + !byte $5E,%00101110 + !byte $46,%01100111 + !byte $28,%10101000 + !byte $08,%01110000 + !byte $5A,%00001011 + !byte $34,%10100100 + !byte $28,%10001000 + !byte $16,%00101101 + !byte $36,%00001101 + !byte $34,%01000101 + !byte $28,%01101000 + !byte $28,%01101110 + !byte $5A,%11010010 + !byte $46,%10000010 + !byte $28,%01001000 + !byte $16,%10110000 + !byte $4C,%01110010 + !byte $58,%10100010 + !byte $28,%00101000 + !byte $1E,%10010010 + !byte $36,%11010000 + !byte $58,%01000111 + !byte $28,%00001000 + !byte $0E,%11010000 + !byte $52,%01101011 + !byte $58,%00100011 + !byte $28,%11000111 + !byte $0A,%00010000 + !byte $52,%01110010 + !byte $52,%01100101 + !byte $28,%10100111 + !byte $20,%11001111 + !byte $46,%00001010 + !byte $52,%10000100 + !byte $28,%10000111 + !byte $20,%00001110 + !byte $4C,%01101011 + !byte $3C,%01000100 + !byte $28,%01100111 + !byte $0E,%00001101 + !byte $46,%11010011 + !byte $32,%11000100 + !byte $28,%01000111 + !byte $1E,%01001011 + !byte $5C,%11001010 + !byte $3C,%10100101 + !byte $28,%00100111 + !byte $2A,%10001110 + !byte $5C,%00010011 + !byte $58,%11000110 + !byte $28,%00000111 + !byte $0A,%11001101 + !byte $54,%01001011 + !byte $44,%11000111 + !byte $28,%00000011 + !byte $18,%10101100 + !byte $54,%10010010 + !byte $4E,%01000011 + !byte $28,%11000010 + !byte $06,%01010001 + !byte $5C,%10101110 + !byte $4E,%10100110 + !byte $28,%10100010 + !byte $06,%10001100 + !byte $5C,%00101111 + !byte $44,%00100010 + !byte $28,%10000010 + !byte $18,%00110001 + !byte $48,%01110011 + !byte $56,%00100111 + !byte $28,%01100010 + !byte $2A,%01001111 + !byte $30,%01001101 + !byte $30,%00000101 + !byte $28,%01000010 + !byte $0C,%10001111 + !byte $30,%10010000 + !byte $32,%00100101 + !byte $28,%00100010 + !byte $0C,%01001110 + !byte $48,%01101010 + !byte $56,%11000010 + !byte $28,%11000001 + !byte $06,%00010001 + !byte $5E,%10101010 + !byte $40,%01000001 + !byte $28,%10100001 + !byte $22,%10101111 + !byte $5E,%00110011 + !byte $40,%10101000 + !byte $28,%10000001 + !byte $1A,%01001100 + !byte $4A,%11001010 + !byte $56,%01100110 + !byte $28,%01100001 + !byte $10,%10110000 + !byte $5E,%01001110 + !byte $50,%00000101 + !byte $28,%01000001 + !byte $2C,%00101111 + !byte $5E,%10001111 + !byte $56,%10000011 + !byte $28,%10100000 + !byte $22,%00101110 + !byte $4A,%00010011 + !byte $3A,%01100100 + !byte $28,%01000000 + !byte $10,%00101101 + !byte $56,%00101011 + !byte $3A,%10000101 + !byte $00,%00000100 + !byte $1A,%10010001 + !byte $32,%10110000 + !byte $42,%10100001 + !byte $28,%00100001 + !byte $06,%11001100 + !byte $56,%10110010 + !byte $4C,%01100011 + !byte $28,%11000000 + !byte $2C,%10101110 + !byte $32,%00101101 + !byte $48,%11000110 + !byte $28,%00000000 + !byte $08,%10101100 + !byte $4E,%10001011 + !byte $4C,%10000110 + !byte $04,%00000001 + !byte $08,%00110001 + !byte $4E,%01010010 + !byte $48,%00100011 + !byte $28,%00000010 + !byte $08,%01001101 + !byte $4C,%10010010 + !byte $42,%01001000 + !byte $28,%00000001 + !byte $0E,%00101111 + !byte $4C,%01001011 + !byte $54,%00000100 + !byte $28,%10000000 + !byte $24,%10001111 + !byte $58,%11010010 + !byte $54,%00000011 + !byte $28,%01100000 + !byte $24,%01001110 + !byte $58,%00001011 + !byte $54,%00000111 + !byte $28,%00100000 + !byte $0E,%10101110 + !byte $34,%00001101 + !byte $54,%00000110 + !byte $28,%10001001 + !byte $12,%01001101 + !byte $34,%11010000 + !byte $40,%01100001 + !byte $04,%00001001 + !byte $1C,%00010010 + !byte $50,%01110010 + !byte $40,%10001000 + !byte $0C,%01100001 + !byte $1C,%11001011 + !byte $50,%01101011 + !byte $38,%10000100 + !byte $12,%01001000 + !byte $08,%10010000 + !byte $48,%10010011 + !byte $40,%00000010 + !byte $12,%10100001 + !byte $12,%10010000 + !byte $5A,%00010011 + !byte $40,%11000111 + !byte $04,%00000101 + !byte $16,%10010000 + !byte $5C,%11001110 + !byte $40,%10000001 + !byte $0C,%10001000 + !byte $2E,%00001111 + !byte $5A,%11001010 + !byte $40,%10100001 + !byte $18,%01000000 + !byte $2E,%11001110 + !byte $36,%11001100 + !byte $40,%00100010 + !byte $18,%10101001 + !byte $16,%01001101 + !byte $36,%00010001 + !byte $40,%10100010 + !byte $02,%00101001 + !byte $0A,%11001100 + !byte $5C,%00001111 + !byte $40,%00000011 + !byte $02,%11000000 + !byte $0A,%10101101 + !byte $52,%01001011 + !byte $40,%01101000 + !byte $0A,%10101000 + !byte $1E,%01101011 + !byte $48,%01001010 + !byte $46,%01000111 + !byte $16,%10100000 + !byte $0A,%00110000 + !byte $52,%10010010 + !byte $4A,%10000011 + !byte $02,%01100101 + !byte $1E,%01110010 + !byte $5E,%01101111 + !byte $38,%01100101 + !byte $02,%10000100 + !byte $0A,%00010001 + !byte $4A,%00110011 + !byte $4A,%01100110 + !byte $16,%01001001 + !byte $18,%00010001 + !byte $4A,%10101010 + !byte $46,%10100010 + !byte $2E,%10100110 + !byte $06,%00110001 + !byte $5E,%01101110 + !byte $40,%11000001 + !byte $2E,%01000011 + !byte $14,%01110000 + !byte $5C,%00110011 + !byte $40,%01000010 + !byte $0A,%01000001 + !byte $26,%01101111 + !byte $5C,%10101010 + !byte $40,%01100010 + !byte $14,%00100001 + !byte $26,%01101110 + !byte $36,%00001010 + !byte $40,%10000010 + !byte $14,%11001000 + !byte $14,%01101101 + !byte $36,%00101010 + !byte $40,%11000010 + !byte $00,%01001001 + !byte $06,%10101100 + !byte $36,%01101010 + !byte $40,%00100011 + !byte $08,%00100001 + !byte $18,%11001100 + !byte $36,%10001010 + !byte $40,%01000011 + !byte $00,%10100000 + !byte $0C,%10101111 + !byte $36,%10101010 + !byte $40,%01100011 + !byte $00,%11000101 + !byte $0C,%00101110 + !byte $36,%00001011 + !byte $40,%10000011 + !byte $08,%11001000 + !byte $0C,%11010000 + !byte $36,%00101011 + !byte $40,%10100011 + !byte $2C,%11000110 + !byte $0C,%00001101 + !byte $36,%01001011 + !byte $40,%11000011 + !byte $00,%00100100 + !byte $28,%01001111 + !byte $36,%01101011 + !byte $40,%00000100 + !byte $10,%01101000 + !byte $28,%10001110 + !byte $36,%10001011 + !byte $40,%00000110 + !byte $2C,%00100011 + !byte $1A,%01110001 + !byte $36,%10101011 + !byte $40,%00100110 + !byte $12,%01101000 + !byte $1A,%01101100 + !byte $36,%11001011 + !byte $40,%01000110 + !byte $10,%10000001 + !byte $08,%10110000 + !byte $36,%00001100 + !byte $40,%01100110 + !byte $12,%10000001 + !byte $0E,%10110000 + !byte $36,%00101100 + !byte $40,%10000110 + !byte $06,%00000001 + !byte $0E,%01001111 + !byte $36,%01001100 + !byte $40,%10100110 + !byte $18,%00100000 + !byte $20,%10101111 + !byte $36,%01101100 + !byte $40,%11000110 + !byte $18,%11001001 + !byte $20,%00101110 + !byte $36,%10001100 + !byte $40,%00000111 + !byte $06,%00001001 + !byte $0E,%00101101 + !byte $36,%10101100 + !byte $40,%00100111 + !byte $2A,%00000111 + !byte $0E,%10001110 + !byte $36,%00110001 + !byte $40,%01000111 + !byte $2A,%00000011 + !byte $1C,%11010001 + !byte $36,%01010001 + !byte $40,%01100111 + !byte $16,%10000000 + !byte $2A,%10101110 + !byte $36,%01110001 + !byte $40,%10000111 + !byte $0E,%01100001 + !byte $08,%00101101 + !byte $36,%10010001 + !byte $40,%10100111 + !byte $02,%10100100 + !byte $1C,%00001100 + !byte $36,%10110001 + !byte $40,%00001000 + !byte $0E,%10001000 + !byte $2A,%00101111 + !byte $36,%11010001 + !byte $40,%00101000 + !byte $02,%01000101 + !byte $16,%01101101 + !byte $36,%00010010 + !byte $40,%01001000 + !byte $04,%00101001 + !byte $16,%01110000 + !byte $36,%01010010 + !byte $52,%11000110 + !byte $04,%11000000 + !byte $1E,%01010010 + !byte $36,%01110010 + !byte $52,%00100011 + !byte $16,%01101001 + !byte $0A,%01010000 + !byte $36,%10010010 + !byte $40,%11000101 + !byte $00,%01000100 + !byte $2C,%00001111 + !byte $36,%10110010 + !byte $52,%10000101 + !byte $0C,%10101000 + !byte $22,%01001110 + !byte $36,%11010010 + !byte $36,%01000101 + !byte $0C,%01000001 + !byte $22,%10001111 + !byte $36,%00110011 + !byte $52,%01100100 + !byte $14,%00000001 + !byte $10,%01001101 + !byte $36,%01010011 + !byte $40,%00100100 + !byte $00,%10100101 + !byte $0A,%10001101 + !byte $54,%00101011 + !byte $36,%10100100 + !byte $14,%00001001 + !byte $10,%10010000 + !byte $4C,%00101011 + !byte $44,%01000010 + !byte $02,%01001001 + !byte $2C,%11001110 + !byte $36,%01001010 + !byte $58,%00000111 + !byte $02,%10100000 + !byte $1E,%10001011 + !byte $36,%11001010 + !byte $44,%10100111 + !byte $12,%01100001 + !byte $08,%00010001 + !byte $36,%01110011 + !byte $58,%00000011 + !byte $12,%10001000 + !byte $08,%11001100 + !byte $36,%11010011 + !byte $58,%11000010 + !byte $2E,%11000110 + !byte $18,%00001101 + !byte $36,%00110010 + !byte $50,%01000011 + !byte $0A,%00100001 + !byte $18,%11010000 + !byte $36,%10010011 + !byte $56,%01100011 + !byte $18,%00000000 + !byte $0C,%11001111 + !byte $4C,%10110010 + !byte $42,%11000001 + !byte $0A,%11001000 + !byte $0C,%00001110 + !byte $36,%00010011 + !byte $50,%11000100 + !byte $2E,%00100011 + !byte $12,%01110000 + !byte $36,%10110011 + !byte $3E,%01000100 + !byte $00,%01101001 + !byte $24,%01101111 + !byte $30,%00101101 + !byte $3E,%10100101 + !byte $00,%10000000 + !byte $24,%01101110 + !byte $54,%10110010 + !byte $50,%10100110 + !byte $02,%00100101 + !byte $12,%01101101 + !byte $30,%10110000 + !byte $58,%00100111 + !byte $16,%10001001 + !byte $1A,%10001100 + !byte $5E,%10001010 + !byte $50,%00100101 + !byte $16,%01100000 + !byte $0A,%00001101 + !byte $5E,%01010011 + !byte $56,%10000110 + !byte $2C,%00000111 + !byte $1A,%01010001 + !byte $48,%10110011 + !byte $32,%00000101 + !byte $2C,%00000011 + !byte $08,%11010000 + !byte $56,%11010010 + !byte $34,%11000100 + !byte $08,%00000001 + !byte $0A,%11010000 + !byte $56,%00001011 + !byte $34,%00100101 + !byte $02,%11000100 + !byte $08,%00001101 + !byte $32,%00001101 + !byte $42,%00101000 + !byte $08,%00001001 + !byte $0E,%01101111 + !byte $32,%11010000 + !byte $48,%10100110 + !byte $10,%10001000 + !byte $26,%10001110 + !byte $4E,%01101011 + !byte $48,%01000011 + !byte $10,%01100001 + !byte $0E,%01101110 + !byte $4E,%01110010 + !byte $3C,%01100100 + !byte $00,%10000101 + !byte $1C,%10110001 + !byte $48,%00101010 + !byte $3C,%10000101 + !byte $14,%00101001 + !byte $1E,%00110010 + !byte $4A,%01010011 + !byte $54,%00100110 + !byte $14,%11000000 + !byte $1C,%00101100 + !byte $5E,%10001110 + !byte $4E,%10000110 + !byte $2A,%00100111 + !byte $14,%10001101 + !byte $34,%11001100 + !byte $54,%11000011 + !byte $2A,%11000010 + !byte $1E,%10101011 + !byte $58,%11001010 + !byte $4E,%01100011 + !byte $00,%01100100 + !byte $14,%01010000 + !byte $58,%00010011 + !byte $46,%11000010 + !byte $06,%00101001 + !byte $26,%01001111 + !byte $34,%00010001 + !byte $56,%00000111 + !byte $06,%11000000 + !byte $0C,%10110000 + !byte $5E,%01001111 + !byte $46,%00100111 + !byte $0E,%01000001 + !byte $16,%10001101 + !byte $4A,%10001010 + !byte $52,%01000100 + !byte $0E,%10101000 + !byte $16,%01010000 + !byte $50,%01001011 + !byte $56,%00000011 + !byte $12,%01000001 + !byte $28,%10101110 + !byte $4C,%00001011 + !byte $3A,%01100101 + !byte $12,%10101000 + !byte $10,%00001111 + !byte $50,%10010010 + !byte $52,%10100101 + !byte $04,%01001001 + !byte $0C,%00101101 + !byte $4C,%11010010 + !byte $3A,%10000100 + !byte $04,%10100000 + !byte $10,%11001110 + !byte $5A,%10101010 + !byte $4C,%10000011 + !byte $0C,%11001000 + !byte $0A,%01101101 + !byte $5A,%00110011 + !byte $4C,%01100110 + !byte $0C,%00100001 + !byte $0A,%01110000 + !byte $52,%00101011 + !byte $44,%01100010 + !byte $02,%00000101 + !byte $28,%00101111 + !byte $48,%00001010 + !byte $54,%11000110 + !byte $16,%01000000 + !byte $18,%00101101 + !byte $52,%10110010 + !byte $44,%10000111 + !byte $02,%01101001 + !byte $18,%10110000 + !byte $48,%11010011 + !byte $54,%00100011 + !byte $16,%10101001 + !byte $1E,%00010010 + !byte $5C,%01010011 + !byte $50,%10100100 + !byte $02,%10000000 + !byte $1E,%11001011 + !byte $5C,%10001010 + !byte $56,%01000011 + !byte $2E,%00000111 + !byte $0C,%00010000 + !byte $54,%00001011 + !byte $38,%10100100 + !byte $2E,%00000011 + !byte $0E,%10010000 + !byte $54,%11010010 + !byte $38,%01000101 + !byte $14,%10100000 + !byte $20,%10001111 + !byte $4A,%01110011 + !byte $56,%10100110 + !byte $0A,%00001001 + !byte $2A,%00001111 + !byte $30,%00001101 + !byte $50,%01000101 + !byte $0A,%00000001 + !byte $20,%01001110 + !byte $4A,%01101010 + !byte $42,%00000010 + !byte $00,%10000100 + !byte $0E,%01001101 + !byte $5E,%10101110 + !byte $42,%00001000 + !byte $00,%01100101 + !byte $0C,%11001101 + !byte $30,%11010000 + !byte $4A,%10100011 + !byte $14,%01001001 + !byte $1E,%10010000 + !byte $5E,%00101111 + !byte $4A,%01000110 + !byte $2A,%11001001 + !byte $1E,%10110001 + !byte $5E,%01110011 + !byte $48,%01100011 + !byte $2A,%10101001 + !byte $1E,%10010001 + !byte $5E,%01101010 + !byte $52,%01000011 + !byte $2A,%10001001 + !byte $1E,%01110001 + !byte $56,%11001010 + !byte $48,%10000110 + !byte $2A,%01101001 + !byte $1E,%11010000 + !byte $4C,%00010011 + !byte $54,%10100011 + !byte $2A,%01001001 + !byte $1E,%01101100 + !byte $32,%11001100 + !byte $40,%01000100 + !byte $2A,%00101001 + !byte $1E,%00001100 + !byte $32,%00010001 + !byte $40,%10100101 + !byte $2A,%00001001 + !byte $2A,%11001110 + !byte $56,%00010011 + !byte $36,%11000100 + !byte $2A,%11001000 + !byte $1E,%11010001 + !byte $4E,%01001011 + !byte $34,%00000101 + !byte $2A,%10101000 + !byte $1E,%01010001 + !byte $4E,%10010010 + !byte $36,%00100101 + !byte $2A,%10001000 + !byte $1E,%00110001 + !byte $4C,%11001010 + !byte $52,%10100110 + !byte $2A,%01101000 + !byte $1E,%00010001 + !byte $58,%10101010 + !byte $54,%01000110 + !byte $2A,%01001000 + !byte $1E,%10110000 + !byte $34,%00110001 + !byte $46,%00000111 + !byte $2A,%00101000 + !byte $1E,%01110000 + !byte $34,%10101100 + !byte $46,%00000011 + !byte $2A,%00001000 + !byte $1E,%01010000 + !byte $50,%00101011 + !byte $3E,%01100100 + !byte $2A,%11000111 + !byte $1E,%00110000 + !byte $58,%00110011 + !byte $50,%10000110 + !byte $2A,%10100111 + !byte $1E,%00010000 + !byte $50,%10110010 + !byte $52,%00100100 + !byte $2A,%10000111 + !byte $1E,%11001111 + !byte $4A,%10010011 + !byte $56,%00100011 + !byte $2A,%01100111 + !byte $1E,%10101111 + !byte $4A,%01001010 + !byte $50,%01100011 + !byte $2A,%01000111 + !byte $1E,%00101110 + !byte $5E,%00001111 + !byte $3E,%10000101 + !byte $2A,%10100010 + !byte $1E,%00001110 + !byte $5A,%10001010 + !byte $52,%11000101 + !byte $2A,%10000010 + !byte $1E,%11001101 + !byte $5A,%01010011 + !byte $56,%11000110 + !byte $2A,%01100010 + !byte $1E,%10101101 + !byte $5E,%11001110 + !byte $44,%01100111 + !byte $2A,%01000010 + !byte $1E,%10001101 + !byte $52,%11010010 + !byte $44,%10000010 + !byte $2A,%00100010 + !byte $1E,%01101101 + !byte $52,%00001011 + !byte $3C,%10000100 + !byte $2A,%00000010 + !byte $1E,%01001101 + !byte $4C,%10101010 + !byte $50,%10000100 + !byte $2A,%11000001 + !byte $1E,%00101101 + !byte $5C,%01101010 + !byte $4E,%10000011 + !byte $2A,%10100001 + !byte $1E,%00001101 + !byte $4C,%00110011 + !byte $3C,%01100101 + !byte $2A,%10000001 + !byte $1E,%11001100 + !byte $5C,%01110011 + !byte $50,%01100101 + !byte $2A,%00100001 + !byte $1E,%10101100 + !byte $54,%11001010 + !byte $4E,%01100110 + !byte $2A,%00000001 + !byte $1E,%10001100 + !byte $30,%11001100 + !byte $42,%11000111 + !byte $2A,%11000000 + !byte $1E,%01001100 + !byte $30,%00010001 + !byte $42,%00100010 + !byte $2A,%10000000 + !byte $1E,%00101100 + !byte $54,%00010011 + !byte $48,%01100110 + !byte $2A,%01000000 + !byte $1A,%10101100 + !byte $4E,%10110010 + !byte $48,%10000011 + !byte $2A,%00100000 + !byte $1A,%00110001 + !byte $4E,%00101011 + !byte $3A,%10100100 + !byte $2A,%01100001 + !byte $22,%01101111 + !byte $5E,%01001010 + !byte $4E,%00000101 + !byte $2A,%01100000 + !byte $0E,%10001111 + !byte $5E,%10010011 + !byte $54,%10000011 + !byte $00,%10001001 + !byte $22,%01101110 + !byte $56,%10101010 + !byte $4C,%10100011 + !byte $00,%01100000 + !byte $0E,%01001110 + !byte $32,%00110001 + !byte $3A,%01000101 + !byte $2A,%00000000 + !byte $1C,%10010001 + !byte $56,%00110011 + !byte $4C,%01000110 + !byte $2A,%01000001 + !byte $10,%01110000 + !byte $32,%10101100 + !byte $54,%01100110 + !byte $2A,%10100000 + !byte $10,%01101101 + !byte $4A,%10110011 + !byte $54,%10100110 + !byte $08,%00101001 + !byte $1C,%01001100 + !byte $4A,%00101010 + !byte $54,%01000011 + !byte $08,%11000000 + !byte $0A,%10010000 + !byte $34,%10001100 + !byte $46,%00100011 + !byte $12,%00100001 + !byte $16,%10101101 + !byte $34,%01010001 + !byte $46,%11000110 + !byte $12,%11001000 + !byte $16,%00110000 + !byte $58,%01010011 + !byte $38,%11000100 + !byte $2C,%00100111 + !byte $0A,%01001101 + !byte $4C,%10001010 + !byte $36,%00000101 + !byte $2C,%11000010 + !byte $10,%00101111 + !byte $58,%10001010 + !byte $52,%00000100 + !byte $10,%10101000 + !byte $24,%01001111 + !byte $34,%00001010 + !byte $38,%00100101 + !byte $10,%01000001 + !byte $24,%10001110 + !byte $34,%00101010 + !byte $52,%00000110 + !byte $06,%01001001 + !byte $10,%10101110 + !byte $34,%01101010 + !byte $52,%01100011 + !byte $16,%00100000 + !byte $12,%01010000 + !byte $34,%10101010 + !byte $4A,%11000011 + !byte $16,%11001001 + !byte $12,%10001101 + !byte $34,%11001010 + !byte $4A,%00100110 + !byte $06,%10100000 + !byte $0A,%10110000 + !byte $34,%00001011 + !byte $44,%01000111 + !byte $0E,%11001000 + !byte $0A,%00101101 + !byte $34,%01001011 + !byte $42,%01000010 + !byte $0E,%00100001 + !byte $18,%01001101 + !byte $34,%01101011 + !byte $42,%10100111 + !byte $00,%01000101 + !byte $0C,%00110000 + !byte $34,%10001011 + !byte $40,%01100100 + !byte $14,%01101001 + !byte $26,%10101110 + !byte $34,%10101011 + !byte $40,%10000101 + !byte $14,%10000000 + !byte $18,%10010000 + !byte $34,%00001100 + !byte $52,%10000110 + !byte $04,%01101001 + !byte $0C,%10101101 + !byte $34,%00101100 + !byte $44,%10100010 + !byte $04,%10000000 + !byte $14,%10101101 + !byte $34,%01001100 + !byte $50,%01100100 + !byte $00,%10100100 + !byte $14,%00110000 + !byte $34,%01101100 + !byte $50,%10000101 + !byte $0C,%00001001 + !byte $26,%00101111 + !byte $34,%01110001 + !byte $54,%01100011 + !byte $0C,%00000001 + !byte $1A,%00010001 + !byte $34,%10010001 + !byte $3E,%01100101 + !byte $12,%00001001 + !byte $1A,%11001100 + !byte $34,%10110001 + !byte $48,%10100011 + !byte $02,%01100000 + !byte $1E,%10001111 + !byte $34,%11010001 + !byte $50,%01100110 + !byte $12,%00000001 + !byte $1E,%01001110 + !byte $34,%00010010 + !byte $48,%01000110 + !byte $02,%10001001 + !byte $0C,%01001101 + !byte $34,%00110010 + !byte $4E,%11000100 + !byte $0A,%11000000 + !byte $0E,%10101111 + !byte $34,%01010010 + !byte $50,%10000011 + !byte $0A,%00101001 + !byte $0C,%10010000 + !byte $34,%10010010 + !byte $3E,%10000100 + !byte $2E,%00100111 + !byte $28,%00001111 + !byte $34,%11010010 + !byte $54,%10000110 + !byte $2E,%11000010 + !byte $0E,%00101110 + !byte $34,%00010011 + !byte $4E,%00100101 + !byte $00,%01000000 + !byte $1C,%01101100 + !byte $34,%00110011 + !byte $42,%10000111 + !byte $16,%00000000 + !byte $28,%11001110 + !byte $4C,%01010011 + !byte $42,%01100010 + !byte $00,%10101001 + !byte $1C,%01110001 + !byte $34,%01001010 + !byte $46,%10100110 + !byte $2C,%10100010 + !byte $0E,%01110000 + !byte $34,%00101011 + !byte $46,%01000011 + !byte $08,%10100000 + !byte $16,%00010000 + !byte $34,%11001011 + !byte $42,%10100010 + !byte $08,%01001001 + !byte $16,%11001101 + !byte $34,%01110010 + !byte $42,%11000010 + !byte $2C,%01000111 + !byte $20,%01101111 + !byte $34,%10110010 + !byte $4E,%10100011 + !byte $14,%01100000 + !byte $20,%01101110 + !byte $34,%01010011 + !byte $3C,%10100100 + !byte $00,%00100101 + !byte $0E,%01101101 + !byte $34,%10010011 + !byte $3C,%01000101 + !byte $00,%11000100 + !byte $10,%10001110 + !byte $34,%11010011 + !byte $4E,%01000110 + !byte $14,%10001001 + !byte $10,%01001111 + !byte $34,%10001010 + !byte $42,%10000010 + !byte $10,%11001000 + !byte $18,%01101101 + !byte $34,%10110011 + !byte $42,%00000011 + !byte $10,%00100001 + !byte $10,%01010000 + !byte $50,%00001011 + !byte $42,%00100011 + !byte $12,%11000000 + !byte $22,%01001111 + !byte $34,%01110011 + !byte $42,%01000011 + !byte $06,%01101001 + !byte $18,%01110000 + !byte $50,%11010010 + !byte $42,%01100011 + !byte $06,%10000000 + !byte $0C,%01010000 + !byte $4E,%11010010 + !byte $42,%10000011 + !byte $12,%00101001 + !byte $10,%10001101 + !byte $5A,%01110011 + !byte $42,%10100011 + !byte $0E,%00000001 + !byte $22,%10001110 + !byte $5A,%01101010 + !byte $42,%11000011 + !byte $0E,%00001001 + !byte $0C,%10001101 + !byte $4E,%00001011 + !byte $42,%00000100 + !byte $04,%10001001 + !byte $1A,%11010000 + !byte $52,%11001010 + !byte $42,%00100100 + !byte $04,%01100000 + !byte $1A,%00001101 + !byte $52,%00010011 + !byte $42,%01000100 + !byte $0C,%00101001 + !byte $12,%00110000 + !byte $5C,%10010011 + !byte $42,%10100101 + !byte $0C,%11000000 + !byte $24,%00101111 + !byte $4A,%00001010 + !byte $42,%11000101 + !byte $02,%10101001 + !byte $24,%10101110 + !byte $5C,%01001010 + !byte $42,%00000110 + !byte $14,%10101001 + !byte $12,%10101101 + !byte $4A,%11010011 + !byte $42,%00100110 + !byte $14,%01000000 + !byte $0E,%11001111 + !byte $54,%10101010 + !byte $42,%01000110 + !byte $00,%00000101 + !byte $0E,%00001110 + !byte $54,%00110011 + !byte $42,%01100110 + !byte $0A,%01001001 + !byte $1C,%01010001 + !byte $30,%10101100 + !byte $42,%10000110 + !byte $02,%01000000 + !byte $1C,%10001100 + !byte $30,%00110001 + !byte $42,%10100110 + !byte $12,%10100000 + !byte $26,%11001110 + !byte $4C,%01110011 + !byte $42,%11000110 + !byte $2E,%01000111 + !byte $0C,%01110000 + !byte $5E,%00101010 + !byte $42,%00000111 + !byte $0A,%10100000 + !byte $0C,%01101101 + !byte $5E,%10110011 + !byte $42,%00100111 + !byte $2E,%10100010 + !byte $26,%00001111 + !byte $4C,%01101010 + !byte $42,%01000111 + !byte $00,%11001001 + !byte $10,%01101111 + !byte $56,%10001010 + !byte $42,%01100111 + !byte $00,%00100000 + !byte $14,%00010000 + !byte $4E,%00010011 + !byte $52,%00100110 + !byte $12,%01001001 + !byte $14,%11001101 + !byte $32,%01010001 + !byte $52,%11000011 + !byte $08,%01101001 + !byte $10,%01101110 + !byte $56,%01010011 + !byte $44,%11000010 + !byte $2C,%01100111 + !byte $1E,%01101111 + !byte $32,%10001100 + !byte $44,%00100111 + !byte $2C,%10000010 + !byte $1E,%01101110 + !byte $4E,%11001010 + !byte $38,%00000101 + !byte $08,%10000000 + !byte $18,%01010000 + !byte $58,%01101010 + !byte $50,%01000100 + !byte $10,%00001001 + !byte $18,%10001101 + !byte $50,%11001010 + !byte $3A,%00100101 + !byte $10,%00000001 + !byte $12,%00001111 + !byte $58,%01110011 + !byte $3A,%11000100 + !byte $06,%10001001 + !byte $16,%11001111 + !byte $50,%00010011 + !byte $4C,%00100110 + !byte $06,%01100000 + !byte $16,%00001110 + !byte $5A,%01001010 + !byte $4C,%11000011 + !byte $14,%11001001 + !byte $12,%11001110 + !byte $5A,%10010011 + !byte $50,%10100101 + !byte $0E,%00101001 + !byte $0E,%01010000 + !byte $4C,%01001010 + !byte $42,%01100100 + !byte $14,%00100000 + !byte $20,%10001110 + !byte $4C,%10010011 + !byte $42,%10000101 + !byte $0E,%11000000 + !byte $1A,%10110000 + !byte $52,%10101010 + !byte $48,%00100110 + !byte $2C,%11001001 + !byte $1A,%00101101 + !byte $52,%00110011 + !byte $48,%11000011 + !byte $2C,%10101001 + !byte $0E,%00010000 + !byte $5C,%00101010 + !byte $4E,%10100100 + !byte $2C,%10001001 + !byte $20,%01001111 + !byte $4E,%00110011 + !byte $4A,%00000100 + !byte $2C,%01101001 + !byte $0E,%10001101 + !byte $4E,%10101010 + !byte $4E,%01000101 + !byte $2C,%01001001 + !byte $1C,%00110001 + !byte $54,%10001010 + !byte $4A,%00000110 + !byte $2C,%11001000 + !byte $0E,%11001101 + !byte $5C,%10110011 + !byte $46,%01100011 + !byte $2C,%10101000 + !byte $1C,%10101100 + !byte $30,%01010001 + !byte $52,%10000011 + !byte $2C,%10001000 + !byte $22,%10101110 + !byte $54,%01010011 + !byte $46,%10000110 + !byte $2C,%01101000 + !byte $10,%10101101 + !byte $30,%10001100 + !byte $40,%10000100 + !byte $2C,%01001000 + !byte $22,%00101111 + !byte $5E,%00001010 + !byte $40,%01100101 + !byte $2C,%00101000 + !byte $10,%10001111 + !byte $5E,%11010011 + !byte $52,%01100110 + !byte $2C,%00001000 + !byte $10,%00110000 + !byte $32,%01110001 + !byte $52,%01000110 + !byte $2C,%11000111 + !byte $10,%01001110 + !byte $56,%01110011 + !byte $52,%10100011 + !byte $2C,%10100111 + !byte $24,%00001111 + !byte $56,%01101010 + !byte $44,%00000011 + !byte $2C,%10000111 + !byte $1C,%11001100 + !byte $32,%01101100 + !byte $44,%00000111 + !byte $2C,%01100010 + !byte $24,%11001110 + !byte $4C,%10110011 + !byte $50,%10100011 + !byte $2C,%01000010 + !byte $1C,%00010001 + !byte $4C,%00101010 + !byte $3E,%01000101 + !byte $2C,%00100010 + !byte $18,%10101101 + !byte $58,%01001010 + !byte $50,%01000110 + !byte $2C,%00000010 + !byte $18,%00110000 + !byte $58,%10010011 + !byte $50,%00100100 + !byte $2C,%11000001 + !byte $12,%00101111 + !byte $4E,%01010011 + !byte $3E,%10100100 + !byte $2C,%01100001 + !byte $12,%00010000 + !byte $4E,%10001010 + !byte $50,%11000101 + !byte $2C,%00100001 + !byte $12,%11001101 + !byte $50,%00110011 + !byte $3C,%11000100 + !byte $2C,%11000000 + !byte $12,%10101110 + !byte $50,%10101010 + !byte $3A,%00000101 + !byte $2C,%10100000 + !byte $1C,%10010000 + !byte $5A,%10110011 + !byte $3C,%00100101 + !byte $2C,%10000000 + !byte $0E,%00110000 + !byte $5A,%00101010 + !byte $48,%00000110 + !byte $04,%01000000 + !byte $0E,%10101101 + !byte $52,%10001010 + !byte $4E,%11000011 + !byte $2C,%00101001 + !byte $1C,%11010000 + !byte $52,%01010011 + !byte $4E,%00100110 + !byte $2C,%00001001 + !byte $1C,%10110000 + !byte $5C,%00001010 + !byte $48,%00000100 + !byte $2C,%10000001 + !byte $1C,%01110000 + !byte $5C,%11010011 + !byte $4E,%10000100 + !byte $2C,%01100000 + !byte $1C,%01010000 + !byte $4C,%11010011 + !byte $4E,%01100101 + !byte $2C,%00100000 + !byte $1C,%00110000 + !byte $4C,%00001010 + !byte $46,%10000011 + !byte $2C,%00000000 + !byte $1C,%00010000 + !byte $54,%01101010 + !byte $46,%01100110 + !byte $12,%10000000 + !byte $1C,%11001111 + !byte $54,%01110011 + !byte $4C,%00000110 + !byte $2C,%10100001 + !byte $1C,%10101111 + !byte $32,%00101010 + !byte $4C,%00000100 + !byte $2C,%01000000 + !byte $1C,%10001111 + !byte $32,%01101010 + !byte $4C,%00000101 + !byte $04,%10101001 + !byte $1C,%01101111 + !byte $32,%11001010 + !byte $42,%01100101 + !byte $2C,%01000001 + !byte $1C,%01101110 + !byte $32,%00001011 + !byte $44,%00100011 + !byte $2C,%00000001 + !byte $1C,%01001110 + !byte $32,%00101011 + !byte $42,%10000100 + !byte $12,%01101001 + !byte $1C,%00101110 + !byte $32,%01001011 + !byte $44,%11000110 + !byte $0C,%01001001 + !byte $1C,%00001110 + !byte $32,%01101011 + !byte $4A,%00100100 + !byte $0C,%10100000 + !byte $1C,%11001101 + !byte $32,%10101011 + !byte $4A,%11000101 + !byte $02,%00100000 + !byte $1C,%10101101 + !byte $32,%11001011 + !byte $50,%00000110 + !byte $02,%11001001 + !byte $1C,%10001101 + !byte $32,%00001100 + !byte $50,%00000100 + !byte $0A,%10000000 + !byte $1C,%01101101 + !byte $32,%00101100 + !byte $40,%10100100 + !byte $2E,%01100111 + !byte $1C,%01001101 + !byte $32,%01001100 + !byte $40,%01000101 + !byte $0A,%01101001 + !byte $1C,%00101101 + !byte $32,%10010001 + !byte $48,%11000101 + !byte $2E,%10000010 + !byte $1C,%00001101 + !byte $32,%10110001 + !byte $4E,%01100100 + !byte $00,%00000000 + !byte $1A,%01001101 + !byte $32,%11010001 + !byte $50,%11000011 + !byte $14,%00000000 + !byte $1A,%10010000 + !byte $32,%00010010 + !byte $50,%00100110 + !byte $08,%10001001 + !byte $14,%11001111 + !byte $32,%01010010 + !byte $48,%00100100 + !byte $08,%01100000 + !byte $14,%00001110 + !byte $32,%01110010 + !byte $4E,%10000101 + !byte $12,%01100000 + !byte $1E,%01001111 + !byte $32,%10010010 + !byte $3C,%00000101 + !byte $10,%11000000 + !byte $1E,%10001110 + !byte $32,%10110010 + !byte $3E,%11000100 + !byte $12,%10001001 + !byte $10,%10101111 + !byte $32,%00010011 + !byte $3E,%00100101 + !byte $10,%00101001 + !byte $16,%10101111 + !byte $32,%01010011 + !byte $46,%01000110 + !byte $06,%10101001 + !byte $16,%00101110 + !byte $32,%01110011 + !byte $46,%10100011 + !byte $06,%01000000 + !byte $10,%00101110 + !byte $32,%10110011 + !byte $4C,%11000100 + !byte $0E,%01001001 + !byte $20,%00101111 + !byte $30,%01101100 + !byte $4C,%00100101 + !byte $0E,%10100000 + !byte $20,%10101110 + !byte $32,%00001010 + !byte $44,%01000011 + !byte $04,%11001001 + !byte $18,%00010000 + !byte $32,%01001010 + !byte $44,%10100110 + !byte $0C,%10000000 + !byte $18,%11001101 + !byte $32,%10001010 + !byte $4E,%00000100 + !byte $04,%00100000 + !byte $12,%10001110 + !byte $32,%10101010 + !byte $4E,%00000110 + !byte $0C,%01101001 + !byte $12,%01001111 + !byte $32,%00110010 + !byte $4C,%11000101 + !byte $12,%01000000 + !byte $22,%00001111 + !byte $32,%00110011 + !byte $4C,%00100100 + !byte $0A,%10001001 + !byte $10,%00010000 + !byte $32,%11010011 + !byte $48,%10100101 + !byte $12,%10101001 + !byte $1A,%01101101 + !byte $32,%10001011 + !byte $4E,%01000100 + !byte $02,%00000000 + !byte $22,%11001110 + !byte $32,%11010010 + !byte $4E,%10100101 + !byte $2E,%10000111 + !byte $10,%11001101 + !byte $32,%10010011 + !byte $48,%01000100 + !byte $2E,%01100010 + !byte $1A,%01110000 + !byte $30,%01110001 + !byte $44,%01100011 + !byte $0A,%01100000 + !byte $12,%11001111 + !byte $4E,%01101010 + !byte $44,%10000110 + !byte $10,%10100000 + !byte $10,%11001111 + !byte $4E,%01110011 + !byte $42,%10100100 + !byte $10,%01001001 + !byte $12,%00001110 + !byte $56,%01001010 + !byte $42,%01000101 + !byte $08,%10101001 + !byte $10,%00001110 + !byte $56,%10010011 + !byte $46,%11000011 + !byte $08,%01000000 + !byte $1C,%01001111 + !byte $58,%10110011 + !byte $4C,%10100100 + !byte $06,%11001001 + !byte $1C,%10001110 + !byte $58,%00101010 + !byte $4A,%01000100 + !byte $12,%00100000 + !byte $14,%10101111 + !byte $50,%10001010 + !byte $4A,%10100101 + !byte $06,%00100000 + !byte $14,%00101110 + !byte $50,%01010011 + !byte $46,%00100110 + !byte $0E,%01101001 + !byte $18,%11001111 + !byte $5A,%00001010 + !byte $4C,%01000101 + !byte $0E,%10000000 + !byte $18,%00001110 + !byte $4E,%01001010 + !byte $40,%11000100 + !byte $12,%11001001 + !byte $12,%01101111 + !byte $5A,%11010011 + !byte $3E,%00000101 + !byte $04,%00000000 + !byte $12,%01101110 + !byte $4E,%10010011 + !byte $44,%10000011 + !byte $0C,%10001001 + !byte $1E,%00101111 + !byte $52,%01101010 + !byte $44,%10100011 + !byte $10,%01101001 + !byte $1E,%10101110 + !byte $52,%01110011 + !byte $44,%11000011 + !byte $10,%10000000 + !byte $1A,%01010000 + !byte $54,%10010011 + !byte $44,%00000100 + !byte $0C,%01100000 + !byte $1A,%10001101 + !byte $54,%01001010 + !byte $44,%00100100 + !byte $0A,%10101001 + !byte $14,%00001111 + !byte $30,%10010001 + !byte $44,%01000100 + !byte $0A,%01000000 + !byte $16,%10001111 + !byte $30,%01001100 + !byte $44,%01100100 + !byte $2E,%10100111 + !byte $16,%01001110 + !byte $56,%00101010 + !byte $44,%10000100 + !byte $2E,%01000010 + !byte $14,%11001110 + !byte $56,%10110011 + !byte $44,%01100101 + !byte $2E,%10101001 + !byte $20,%00001111 + !byte $4E,%10110011 + !byte $44,%10000101 + !byte $2E,%01001001 + !byte $20,%11001110 + !byte $4E,%00101010 + !byte $44,%10100101 + !byte $2E,%00101001 + !byte $12,%10001111 + !byte $58,%00001010 + !byte $44,%11000101 + !byte $2E,%00001001 + !byte $12,%01001110 + !byte $58,%11010011 + !byte $44,%00000110 + !byte $2E,%11001000 + !byte $18,%10101111 + !byte $50,%01101010 + !byte $44,%00100110 + !byte $2E,%10101000 + !byte $18,%00101110 + !byte $50,%01110011 + !byte $44,%01000110 + !byte $2E,%01101000 + !byte $12,%10101111 + !byte $52,%10010011 + !byte $44,%01100110 + !byte $2E,%01001000 + !byte $12,%00101110 + !byte $52,%01001010 + !byte $40,%00100101 + !byte $2E,%00101000 + !byte $1A,%10101101 + !byte $4E,%00001010 + !byte $4E,%00100100 + !byte $2E,%11000111 + !byte $1A,%00110000 + !byte $54,%00101010 + !byte $4E,%11000101 + !byte $2E,%00100010 + !byte $14,%00101111 + !byte $30,%00101100 + !byte $48,%01100100 + !byte $2E,%00000010 + !byte $1C,%00101111 + !byte $54,%10110011 + !byte $48,%10000101 + !byte $2E,%11000001 + !byte $1C,%10101110 + !byte $4E,%11010011 + !byte $46,%00000110 + !byte $2E,%10100001 + !byte $14,%10101110 + !byte $30,%10110001 + !byte $46,%00000100 + !byte $2E,%01100001 + !byte $14,%10001111 + !byte $56,%00001010 + !byte $4C,%10000100 + !byte $2E,%01000001 + !byte $14,%01001110 + !byte $56,%11010011 + !byte $4C,%01100101 + !byte $2E,%00100001 + !byte $1E,%11001110 + !byte $30,%00001010 + !byte $44,%10100100 + !byte $2E,%00000001 + !byte $1E,%00001111 + !byte $30,%10001010 + !byte $44,%01000101 + !byte $2E,%01100000 + !byte $1A,%00010000 + !byte $30,%10101010 + !byte $4C,%01000100 + !byte $2E,%01000000 + !byte $1A,%11001101 + !byte $30,%11001010 + !byte $4C,%10100101 + !byte $2E,%00100000 + !byte $18,%10001111 + !byte $30,%00001011 + !byte $4A,%00000101 + !byte $2E,%00000000 + !byte $18,%01001110 + !byte $30,%00101011 + !byte $40,%00000101 + !byte $12,%00000000 + !byte $16,%01101111 + !byte $30,%01001011 + !byte $42,%11000100 + !byte $08,%11001001 + !byte $16,%01101110 + !byte $30,%01101011 + !byte $42,%00100101 + !byte $2E,%11001001 + !byte $1A,%11001111 + !byte $30,%10001011 + !byte $4A,%01100100 + !byte $2E,%10001001 + !byte $1A,%10101111 + !byte $30,%10101011 + !byte $4A,%10000101 + !byte $2E,%01101001 + !byte $1A,%10001111 + !byte $30,%11001011 + !byte $46,%00100100 + !byte $2E,%10001000 + !byte $1A,%01101111 + !byte $30,%00001100 + !byte $4C,%01100100 + !byte $2E,%00001000 + !byte $1A,%01001111 + !byte $30,%11010001 + !byte $4C,%10000101 + !byte $2E,%10000001 + !byte $1A,%10001110 + !byte $30,%00010010 + !byte $46,%11000101 + !byte $2E,%10100000 + !byte $1A,%01101110 + !byte $30,%00110010 + !byte $48,%10000100 + !byte $2E,%10000000 + !byte $1A,%01001110 + !byte $30,%01010010 + !byte $48,%01100101 + !byte $2E,%11000000 + !byte $1A,%00101110 + !byte $30,%10010010 + !byte $4A,%11000100 + !byte $08,%00100000 + !byte $1A,%00001110 + !byte $30,%00010011 + !byte $4A,%00100101 + !byte $10,%01100000 + !byte $14,%10001110 + !byte $30,%01110011 + !byte $44,%11000100 + !byte $10,%10001001 + !byte $14,%01001111 + !byte $30,%10110011 + !byte $42,%00000101 + !byte $06,%00000000 + !byte $1A,%00101111 + !byte $30,%11010011 + !byte $44,%00100101 + !byte $0E,%01100000 + !byte $1A,%10101110 + !byte $30,%01101010 + !byte $46,%01000100 + !byte $0E,%10001001 + !byte $14,%01101111 + !byte $30,%01110010 + !byte $46,%10100101 + !byte $0C,%10101001 + !byte $14,%01101110 + !byte $30,%11010010 + !byte $4A,%10000100 + !byte $0C,%01000000 + !byte $18,%01101111 + !byte $30,%00110011 + !byte $4A,%01100101 + !byte $10,%10101001 + !byte $1C,%00001111 + !byte $30,%10010011 + !byte $4A,%10100100 + !byte $0A,%00100000 + !byte $1C,%11001110 + !byte $50,%01001010 + !byte $4A,%01000101 + !byte $10,%01000000 + !byte $18,%01101110 + !byte $50,%10010011 + !byte $48,%10100100 + !byte $0A,%11001001 + !byte $16,%01001111 + !byte $30,%00101010 + !byte $48,%01000101 + !byte $08,%00000000 + !byte $16,%10001110 + !byte $30,%10110010 + !byte $46,%01100100 + !byte $0E,%01000000 + !byte $16,%11001110 + !byte $30,%01001010 + !byte $46,%10000101 + !byte $10,%00100000 + !byte $16,%00001111 + !byte $30,%01010011 + !byte $44,%00000101 + !byte $0E,%10101001 + !byte $18,%01001111 + !byte $52,%10110011 + !byte $46,%10000100 + !byte $10,%11001001 + !byte $18,%10001110 + !byte $52,%00101010 + !byte $46,%01100101 + !byte $0C,%11001001 + !byte $1A,%00001111 + !byte $54,%00001010 + !byte $46,%10100100 + !byte $0C,%00100000 + !byte $1A,%11001110 + !byte $54,%11010011 + !byte $46,%11000100 + !byte $0A,%00000000 + !byte $16,%00101111 + !byte $50,%00101010 + !byte $46,%00100101 + !byte $10,%00000000 + !byte $16,%10101110 + !byte $50,%10110011 + !byte $46,%01000101 + !byte $0E,%00100000 + !byte $18,%00101111 + !byte $52,%00001010 + !byte $48,%00000101 + !byte $0E,%11001001 + !byte $18,%10101110 + !byte $52,%11010011 + !byte $48,%11000100 + !byte $0C,%00000000 + !byte $18,%00001111 + !byte $50,%11010011 + !byte $48,%00100101 + !byte $0E,%00000000 + !byte $18,%11001110 + !byte $50,%00001010 + !byte $46,%00000101 diff --git a/src/fx/fx.hgr.halfblock.fizzle.a b/src/fx/fx.hgr.halfblock.fizzle.a new file mode 100644 index 0000000..f82497a --- /dev/null +++ b/src/fx/fx.hgr.halfblock.fizzle.a @@ -0,0 +1,38 @@ +;license:MIT +;(c) 2018-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/HALF.FIZZLE",plain +*=$6000 + + !source "src/fx/fx.hgr.halfblock.fizzle.common.a" + + +BUILD_HALFBLOCK_FIZZLE_DATA + + +LDADDR Coordinates + +ST16 coord +@loop2 + ldy #0 + lda (coord),y + bmi @exit + tax + iny + lda (coord),y + tay + txa + jsr HGRHalfBlockCopy + lda #$07 + jsr WaitForKeyWithTimeout + bmi @exit + inc coord + bne + + inc coord+1 ++ inc coord + bne + + inc coord+1 ++ bne @loop2 +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.halfblock.fizzle.common.a b/src/fx/fx.hgr.halfblock.fizzle.common.a new file mode 100644 index 0000000..b09ec0d --- /dev/null +++ b/src/fx/fx.hgr.halfblock.fizzle.common.a @@ -0,0 +1,84 @@ +;license:MIT +;(c) 2020 by qkumba +; +coord = $FE +Coordinates = $7000 ; about $700 bytes, can be anywhere + + !source "src/fx/macros.a" + +!macro BUILD_HALFBLOCK_FIZZLE_DATA { + +LDADDR Coordinates + +ST16 coord + + ;init RNG + + ldx #1 + stx @rnd1+1 + dex + stx @rnd2+1 + + ;iterate + +@loop + ldy @rnd1+1 + ldx @rnd2+1 + lsr @rnd2+1 + ror @rnd1+1 + bcc + + + ;feedback polynomial forms #$500 for period of 2047 + + lda @rnd2+1 + eor #5 + sta @rnd2+1 + ++ tya + eor #$ff + ldy #0 +- cpx #0 + bne + + cmp #40 + bcc ++ ++ sbc #40 + pha + txa + sbc #0 + tax + pla + iny + bne - + +++ cpy #48 + bcs @rnd2 + tax + tya + jsr @stainc + txa + jsr @stainc + +@rnd2 lda #0 + bne @loop +@rnd1 lda #0 + cmp #1 + bne @loop + + ;include the missing point + + lda #6 + jsr @stainc + lda #15 + jsr @stainc + + lda #$ff + jsr @stainc + bne ++ ; always branches + +@stainc + ldy #0 + sta (coord), y + inc coord + bne + + inc coord+1 ++ rts +++ +} diff --git a/src/fx/fx.hgr.halfblock.fizzle.white.a b/src/fx/fx.hgr.halfblock.fizzle.white.a new file mode 100644 index 0000000..64659cd --- /dev/null +++ b/src/fx/fx.hgr.halfblock.fizzle.white.a @@ -0,0 +1,62 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/HALF.MOSAIC",plain +*=$6000 + + !source "src/fx/fx.hgr.halfblock.fizzle.common.a" + + +BUILD_HALFBLOCK_FIZZLE_DATA + + +LDADDR Coordinates + +ST16 coord +@whiteloop + ldy #0 + lda (coord),y + bmi @endwhite + tax + iny + lda (coord),y + tay + txa + jsr HGRHalfBlockToWhite + lda #$02 + jsr WaitForKeyWithTimeout + bmi @exit + inc coord + bne + + inc coord+1 ++ inc coord + bne + + inc coord+1 ++ bne @whiteloop +@endwhite + +LDADDR Coordinates + +ST16 coord +@copyloop + ldy #0 + lda (coord),y + bmi @exit + tax + iny + lda (coord),y + tay + txa + jsr HGRHalfBlockCopy + lda #$02 + jsr WaitForKeyWithTimeout + bmi @exit + inc coord + bne + + inc coord+1 ++ inc coord + bne + + inc coord+1 ++ bne @copyloop +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.heart.a b/src/fx/fx.hgr.heart.a new file mode 100644 index 0000000..afb14ca --- /dev/null +++ b/src/fx/fx.hgr.heart.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/HEART",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/HEART.DATA" diff --git a/src/fx/fx.hgr.heart.data.a b/src/fx/fx.hgr.heart.data.a new file mode 100644 index 0000000..e3d2892 --- /dev/null +++ b/src/fx/fx.hgr.heart.data.a @@ -0,0 +1,7683 @@ +!cpu 6502 +!to "build/FX/HEART.DATA",plain +*=$8100 + !byte $5F,%11110011 + !byte $5D,%11110011 + !byte $61,%11110011 + !byte $5F,%11010011 + !byte $5D,%11010011 + !byte $61,%11010011 + !byte $5D,%10110011 + !byte $5F,%10110011 + !byte $5B,%11010011 + !byte $5B,%11110011 + !byte $63,%11110011 + !byte $5B,%10110011 + !byte $61,%10110011 + !byte $5D,%01110010 + !byte $5D,%10010011; + !byte $5F,%01110010 + !byte $5F,%10010011; + !byte $63,%11010011 + !byte $5B,%01110010 + !byte $5B,%10010011; + !byte $65,%11110011 + !byte $59,%11010011 + !byte $59,%10110011 + !byte $61,%01110010 + !byte $61,%10010011; + !byte $5D,%01010010 + !byte $59,%11110011 + !byte $63,%10110011 + !byte $5F,%01010010 + !byte $5B,%01010010 + !byte $59,%01110010 + !byte $59,%10010011; + !byte $65,%11010011 + !byte $67,%11110011 + !byte $59,%01010010 + !byte $61,%01010010 + !byte $5D,%00110010 + !byte $5B,%00110010 + !byte $63,%01110010 + !byte $63,%10010011; + !byte $5F,%00110010 + !byte $57,%10110011 + !byte $57,%01110010 + !byte $57,%10010011; + !byte $57,%11010011 + !byte $65,%10110011 + !byte $59,%00110010 + !byte $67,%11010011 + !byte $57,%01010010 + !byte $69,%11110011 + !byte $61,%00110010 + !byte $5D,%00010010 + !byte $5B,%00010010 + !byte $63,%01010010 + !byte $5F,%00010010 + !byte $59,%00010010 + !byte $57,%00110010 + !byte $57,%11110011 + !byte $65,%01110010 + !byte $65,%10010011; + !byte $67,%10110011 + !byte $55,%01110010 + !byte $55,%10010011; + !byte $5B,%11110001 + !byte $55,%10110011 + !byte $61,%00010010 + !byte $5D,%11110001 + !byte $57,%00010010 + !byte $55,%01010010 + !byte $6B,%11110011 + !byte $69,%11010011 + !byte $63,%00110010 + !byte $59,%11110001 + !byte $5F,%11110001 + !byte $65,%01010010 + !byte $55,%00110010 + !byte $55,%11010011 + !byte $57,%11110001 + !byte $67,%01110010 + !byte $67,%10010011; + !byte $55,%00010010 + !byte $5D,%11010001 + !byte $5B,%11010001 + !byte $69,%10110011 + !byte $63,%00010010 + !byte $61,%11110001 + !byte $59,%11010001 + !byte $6D,%11110011 + !byte $6B,%11010011 + !byte $65,%00110010 + !byte $5F,%11010001 + !byte $53,%01010010 + !byte $53,%01110010 + !byte $53,%10010011; + !byte $57,%11010001 + !byte $55,%11110001 + !byte $67,%01010010 + !byte $53,%00110010 + !byte $53,%10110011 + !byte $5B,%10110001 + !byte $69,%01110010 + !byte $69,%10010011; + !byte $5D,%10110001 + !byte $59,%10110001 + !byte $53,%00010010 + !byte $55,%11110011 + !byte $63,%11110001 + !byte $61,%11010001 + !byte $55,%11010001 + !byte $65,%00010010 + !byte $6B,%10110011 + !byte $57,%10110001 + !byte $6F,%11110011 + !byte $5F,%10110001 + !byte $53,%11110001 + !byte $6D,%11010011 + !byte $67,%00110010 + !byte $53,%11010011 + !byte $5B,%01110000 + !byte $5B,%10010001; + !byte $55,%10110001 + !byte $69,%01010010 + !byte $59,%01110000 + !byte $59,%10010001; + !byte $63,%11010001 + !byte $5D,%01110000 + !byte $5D,%10010001; + !byte $53,%11010001 + !byte $51,%00110010 + !byte $51,%01010010 + !byte $61,%10110001 + !byte $65,%11110001 + !byte $57,%01110000 + !byte $57,%10010001; + !byte $51,%00010010 + !byte $51,%01110010 + !byte $51,%10010011; + !byte $6B,%01110010 + !byte $6B,%10010011; + !byte $67,%00010010 + !byte $5F,%01110000 + !byte $5F,%10010001; + !byte $6D,%10110011 + !byte $51,%11110001 + !byte $71,%11110011 + !byte $55,%01110000 + !byte $55,%10010001; + !byte $53,%10110001 + !byte $6F,%11010011 + !byte $51,%10110011 + !byte $69,%00110010 + !byte $5B,%01010000 + !byte $59,%01010000 + !byte $51,%11010001 + !byte $63,%10110001 + !byte $5D,%01010000 + !byte $57,%01010000 + !byte $61,%01110000 + !byte $61,%10010001; + !byte $6B,%01010010 + !byte $65,%11010001 + !byte $53,%01110000 + !byte $53,%10010001; + !byte $67,%11110001 + !byte $55,%01010000 + !byte $5F,%01010000 + !byte $51,%10110001 + !byte $4F,%00110010 + !byte $6D,%01110010 + !byte $6D,%10010011; + !byte $4F,%00010010 + !byte $4F,%01010010 + !byte $53,%11110011 + !byte $73,%11110011 + !byte $6F,%10110011 + !byte $69,%00010010 + !byte $59,%00110000 + !byte $4F,%11110001 + !byte $5B,%00110000 + !byte $71,%11010011 + !byte $57,%00110000 + !byte $51,%11010011 + !byte $63,%01110000 + !byte $63,%10010001; + !byte $5D,%00110000 + !byte $53,%01010000 + !byte $4F,%01110010 + !byte $4F,%10010011; + !byte $6B,%00110010 + !byte $65,%10110001 + !byte $61,%01010000 + !byte $51,%01110000 + !byte $51,%10010001; + !byte $4F,%11010001 + !byte $55,%00110000 + !byte $67,%11010001 + !byte $6D,%01010010 + !byte $5F,%00110000 + !byte $4F,%10110001 + !byte $69,%11110001 + !byte $6F,%01110010 + !byte $6F,%10010011; + !byte $5B,%00010000 + !byte $59,%00010000 + !byte $53,%00110000 + !byte $51,%01010000 + !byte $75,%11110011 + !byte $57,%00010000 + !byte $4F,%10110011 + !byte $73,%11010011 + !byte $71,%10110011 + !byte $6B,%00010010 + !byte $65,%01110000 + !byte $65,%10010001; + !byte $63,%01010000 + !byte $5D,%00010000 + !byte $4F,%01110000 + !byte $4F,%10010001; + !byte $4D,%00010010 + !byte $61,%00110000 + !byte $55,%00010000 + !byte $4D,%11110001 + !byte $4D,%00110010 + !byte $67,%10110001 + !byte $4D,%11010001 + !byte $6D,%00110010 + !byte $51,%00110000 + !byte $4D,%01010010 + !byte $5F,%00010000 + !byte $53,%00010000 + !byte $69,%11010001 + !byte $4F,%01010000 + !byte $59,%11101111 + !byte $4D,%10110001 + !byte $6F,%01010010 + !byte $5B,%11101111 + !byte $57,%11101111 + !byte $6B,%11110001 + !byte $55,%11101111 + !byte $4D,%01110010 + !byte $4D,%10010011; + !byte $77,%11110011 + !byte $71,%01110010 + !byte $71,%10010011; + !byte $65,%01010000 + !byte $63,%00110000 + !byte $5D,%11101111 + !byte $4D,%01110000 + !byte $4D,%10010001; + !byte $51,%00010000 + !byte $4F,%00110000 + !byte $75,%11010011 + !byte $73,%10110011 + !byte $67,%01110000 + !byte $67,%10010001; + !byte $61,%00010000 + !byte $6D,%00010010 + !byte $53,%11101111 + !byte $4F,%11010011 + !byte $51,%11110011 + !byte $69,%10110001 + !byte $5F,%11101111 + !byte $4D,%01010000 + !byte $4B,%11110001 + !byte $4B,%00010010 + !byte $6F,%00110010 + !byte $59,%11001111 + !byte $57,%11001111 + !byte $4B,%11010001 + !byte $5B,%11001111 + !byte $4B,%00110010 + !byte $6B,%11010001 + !byte $55,%11001111 + !byte $51,%11101111 + !byte $4F,%00010000 + !byte $4B,%10110001 + !byte $71,%01010010 + !byte $65,%00110000 + !byte $63,%00010000 + !byte $5D,%11001111 + !byte $4D,%00110000 + !byte $4D,%10110011 + !byte $79,%11110011 + !byte $67,%01010000 + !byte $53,%11001111 + !byte $73,%01110010 + !byte $73,%10010011; + !byte $6D,%11110001 + !byte $61,%11101111 + !byte $4B,%01110000 + !byte $4B,%10010001; + !byte $4B,%01010010 + !byte $77,%11010011 + !byte $75,%10110011 + !byte $69,%01110000 + !byte $69,%10010001; + !byte $5F,%11001111 + !byte $4F,%11101111 + !byte $6F,%00010010 + !byte $59,%10101111 + !byte $57,%10101111 + !byte $51,%11001111 + !byte $4B,%01010000 + !byte $55,%10101111 + !byte $4D,%00010000 + !byte $6B,%10110001 + !byte $5B,%10101111 + !byte $71,%00110010 + !byte $6D,%11010001 + !byte $65,%00010000 + !byte $63,%11101111 + !byte $5D,%10101111 + !byte $53,%10101111 + !byte $4B,%00110000 + !byte $4B,%01110010 + !byte $4B,%10010011; + !byte $67,%00110000 + !byte $49,%11010001 + !byte $49,%11110001 + !byte $7B,%11110011 + !byte $73,%01010010 + !byte $61,%11001111 + !byte $4F,%11001111 + !byte $4D,%11101111 + !byte $49,%10110001 + !byte $49,%00010010 + !byte $69,%01010000 + !byte $75,%01110010 + !byte $75,%10010011; + !byte $51,%10101111 + !byte $49,%01110000 + !byte $49,%10010001; + !byte $79,%11010011 + !byte $6F,%11110001 + !byte $5F,%10101111 + !byte $57,%01101110 + !byte $57,%10001111; + !byte $77,%10110011 + !byte $59,%01101110 + !byte $59,%10001111; + !byte $55,%01101110 + !byte $55,%10001111; + !byte $4B,%00010000 + !byte $49,%00110010 + !byte $6B,%01110000 + !byte $6B,%10010001; + !byte $5B,%01101110 + !byte $5B,%10001111; + !byte $49,%01010000 + !byte $71,%00010010 + !byte $53,%01101110 + !byte $53,%10001111; + !byte $6D,%10110001 + !byte $65,%11101111 + !byte $4F,%10101111 + !byte $4D,%11001111 + !byte $4D,%11010011 + !byte $67,%00010000 + !byte $63,%11001111 + !byte $5D,%01101110 + !byte $5D,%10001111; + !byte $73,%00110010 + !byte $4B,%11101111 + !byte $49,%00110000 + !byte $61,%10101111 + !byte $51,%01101110 + !byte $51,%10001111; + !byte $49,%01010010 + !byte $7D,%11110011 + !byte $6F,%11010001 + !byte $69,%00110000 + !byte $4F,%11110011 + !byte $75,%01010010 + !byte $4B,%10110011 + !byte $59,%01001110 + !byte $57,%01001110 + !byte $55,%01001110 + !byte $77,%01110010 + !byte $77,%10010011; + !byte $6B,%01010000 + !byte $5F,%01101110 + !byte $5F,%10001111; + !byte $4D,%10101111 + !byte $49,%00010000 + !byte $7B,%11010011 + !byte $71,%11110001 + !byte $5B,%01001110 + !byte $4F,%01101110 + !byte $4F,%10001111; + !byte $47,%10110001 + !byte $47,%11010001 + !byte $47,%11110001 + !byte $79,%10110011 + !byte $53,%01001110 + !byte $4B,%11001111 + !byte $47,%01110000 + !byte $47,%10010001; + !byte $6D,%01110000 + !byte $6D,%10010001; + !byte $65,%11001111 + !byte $47,%00010010 + !byte $73,%00010010 + !byte $67,%11101111 + !byte $63,%10101111 + !byte $5D,%01001110 + !byte $51,%01001110 + !byte $49,%11101111 + !byte $47,%01010000 + !byte $6F,%10110001 + !byte $69,%00010000 + !byte $61,%01101110 + !byte $61,%10001111; + !byte $49,%01110010 + !byte $49,%10010011; + !byte $4D,%01101110 + !byte $4D,%10001111; + !byte $4B,%10101111 + !byte $47,%00110000 + !byte $75,%00110010 + !byte $57,%00101110 + !byte $7F,%11110011 + !byte $6B,%00110000 + !byte $59,%00101110 + !byte $55,%00101110 + !byte $4F,%01001110 + !byte $47,%00110010 + !byte $77,%01010010 + !byte $71,%11010001 + !byte $5F,%01001110 + !byte $53,%00101110 + !byte $49,%11001111 + !byte $5B,%00101110 + !byte $47,%00010000 + !byte $79,%01110010 + !byte $79,%10010011; + !byte $6D,%01010000 + !byte $7D,%11010011 + !byte $7B,%10110011 + !byte $51,%00101110 + !byte $73,%11110001 + !byte $67,%11001111 + !byte $65,%10101111 + !byte $63,%01101110 + !byte $63,%10001111; + !byte $5D,%00101110 + !byte $4D,%01001110 + !byte $4B,%01101110 + !byte $4B,%10001111; + !byte $6F,%01110000 + !byte $6F,%10010001; + !byte $69,%11101111 + !byte $47,%11101111 + !byte $45,%10110001 + !byte $61,%01001110 + !byte $49,%10101111 + !byte $45,%01110000 + !byte $45,%10010001; + !byte $45,%11010001 + !byte $47,%01010010 + !byte $75,%00010010 + !byte $4F,%00101110 + !byte $45,%01010000 + !byte $6B,%00010000 + !byte $57,%00001110 + !byte $55,%00001110 + !byte $45,%11110001 + !byte $71,%10110001 + !byte $59,%00001110 + !byte $53,%00001110 + !byte $81,%11110011 + !byte $77,%00110010 + !byte $5F,%00101110 + !byte $47,%11001111 + !byte $45,%00110000 + !byte $4B,%11010011 + !byte $6D,%00110000 + !byte $5B,%00001110 + !byte $4B,%01001110 + !byte $51,%00001110 + !byte $45,%00010010 + !byte $79,%01010010 + !byte $73,%11010001 + !byte $4D,%00101110 + !byte $49,%01101110 + !byte $49,%10001111; + !byte $45,%00010000 + !byte $49,%10110011 + !byte $7F,%11010011 + !byte $7B,%01110010 + !byte $7B,%10010011; + !byte $67,%10101111 + !byte $65,%01101110 + !byte $65,%10001111; + !byte $7D,%10110011 + !byte $6F,%01010000 + !byte $63,%01001110 + !byte $5D,%00001110 + !byte $69,%11001111 + !byte $4F,%00001110 + !byte $47,%10101111 + !byte $75,%11110001 + !byte $61,%00101110 + !byte $45,%11101111 + !byte $4D,%11110011 + !byte $6B,%11101111 + !byte $57,%11101101 + !byte $55,%11101101 + !byte $71,%01110000 + !byte $71,%10010001; + !byte $59,%11101101 + !byte $53,%11101101 + !byte $4B,%00101110 + !byte $45,%00110010 + !byte $49,%01001110 + !byte $47,%01110010 + !byte $47,%10010011; + !byte $77,%00010010 + !byte $6D,%00010000 + !byte $5F,%00001110 + !byte $4D,%00001110 + !byte $83,%11110011 + !byte $5B,%11101101 + !byte $51,%11101101 + !byte $47,%01101110 + !byte $47,%10001111; + !byte $45,%11001111 + !byte $43,%01110000 + !byte $43,%10010001; + !byte $43,%10110001 + !byte $79,%00110010 + !byte $73,%10110001 + !byte $43,%01010000 + !byte $43,%00110000 + !byte $43,%11010001 + !byte $6F,%00110000 + !byte $67,%01101110 + !byte $67,%10001111; + !byte $65,%01001110 + !byte $4F,%11101101 + !byte $7B,%01010010 + !byte $69,%10101111 + !byte $63,%00101110 + !byte $5D,%11101101 + !byte $81,%11010011 + !byte $7D,%01110010 + !byte $7D,%10010011; + !byte $75,%11010001 + !byte $4B,%00001110 + !byte $49,%00101110 + !byte $45,%10101111 + !byte $43,%00010000 + !byte $43,%11110001 + !byte $7F,%10110011 + !byte $61,%00001110 + !byte $55,%11001101 + !byte $71,%01010000 + !byte $6B,%11001111 + !byte $57,%11001101 + !byte $53,%11001101 + !byte $47,%01001110 + !byte $59,%11001101 + !byte $4D,%11101101 + !byte $43,%11101111 + !byte $45,%01010010 + !byte $77,%11110001 + !byte $6D,%11101111 + !byte $51,%11001101 + !byte $5F,%11101101 + !byte $45,%01101110 + !byte $45,%10001111; + !byte $73,%01110000 + !byte $73,%10010001; + !byte $5B,%11001101 + !byte $43,%00010010 + !byte $85,%11110011 + !byte $79,%00010010 + !byte $4F,%11001101 + !byte $43,%11001111 + !byte $6F,%00010000 + !byte $49,%00001110 + !byte $47,%00101110 + !byte $67,%01001110 + !byte $65,%00101110 + !byte $4B,%11101101 + !byte $7B,%00110010 + !byte $75,%10110001 + !byte $69,%01101110 + !byte $69,%10001111; + !byte $63,%00001110 + !byte $5D,%11001101 + !byte $83,%11010011 + !byte $7D,%01010010 + !byte $71,%00110000 + !byte $6B,%10101111 + !byte $61,%11101101 + !byte $57,%10101101 + !byte $55,%10101101 + !byte $53,%10101101 + !byte $4D,%11001101 + !byte $45,%01001110 + !byte $43,%10101111 + !byte $41,%01010000 + !byte $41,%01110000 + !byte $41,%10010001; + !byte $7F,%01110010 + !byte $7F,%10010011; + !byte $41,%00110000 + !byte $41,%10110001 + !byte $47,%10110011 + !byte $49,%11010011 + !byte $81,%10110011 + !byte $77,%11010001 + !byte $59,%10101101 + !byte $51,%10101101 + !byte $41,%00010000 + !byte $6D,%11001111 + !byte $49,%11101101 + !byte $43,%00110010 + !byte $73,%01010000 + !byte $5F,%11001101 + !byte $47,%00001110 + !byte $41,%11010001 + !byte $79,%11110001 + !byte $5B,%10101101 + !byte $4F,%10101101 + !byte $4B,%11001101 + !byte $43,%01101110 + !byte $43,%10001111; + !byte $41,%11101111 + !byte $6F,%11101111 + !byte $45,%00101110 + !byte $87,%11110011 + !byte $67,%00101110 + !byte $45,%01110010 + !byte $45,%10010011; + !byte $75,%01110000 + !byte $75,%10010001; + !byte $69,%01001110 + !byte $65,%00001110 + !byte $41,%11001111 + !byte $7B,%00010010 + !byte $63,%11101101 + !byte $4D,%10101101 + !byte $41,%11110001 + !byte $71,%00010000 + !byte $6B,%01101110 + !byte $6B,%10001111; + !byte $5D,%10101101 + !byte $55,%01101100 + !byte $55,%10001101; + !byte $43,%01001110 + !byte $7D,%00110010 + !byte $57,%01101100 + !byte $57,%10001101; + !byte $53,%01101100 + !byte $53,%10001101; + !byte $47,%11101101 + !byte $4B,%11110011 + !byte $85,%11010011 + !byte $77,%10110001 + !byte $61,%11001101 + !byte $51,%01101100 + !byte $51,%10001101; + !byte $49,%11001101 + !byte $41,%10101111 + !byte $7F,%01010010 + !byte $6D,%10101111 + !byte $59,%01101100 + !byte $59,%10001101; + !byte $45,%00001110 + !byte $83,%10110011 + !byte $81,%01110010 + !byte $81,%10010011; + !byte $73,%00110000 + !byte $4B,%10101101 + !byte $79,%11010001 + !byte $5F,%10101101 + !byte $4F,%01101100 + !byte $4F,%10001101; + !byte $6F,%11001111 + !byte $5B,%01101100 + !byte $5B,%10001101; + !byte $43,%00101110 + !byte $41,%01101110 + !byte $41,%10001111; + !byte $41,%00010010 + !byte $43,%01010010 + !byte $3F,%00110000 + !byte $3F,%01010000 + !byte $75,%01010000 + !byte $67,%00001110 + !byte $4D,%01101100 + !byte $4D,%10001101; + !byte $3F,%00010000 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $89,%11110011 + !byte $7B,%11110001 + !byte $69,%00101110 + !byte $65,%11101101 + !byte $47,%11001101 + !byte $45,%11101101 + !byte $3F,%11101111 + !byte $71,%11101111 + !byte $63,%11001101 + !byte $49,%10101101 + !byte $3F,%10110001 + !byte $6B,%01001110 + !byte $5D,%01101100 + !byte $5D,%10001101; + !byte $55,%01001100 + !byte $53,%01001100 + !byte $41,%01001110 + !byte $7D,%00010010 + !byte $77,%01110000 + !byte $77,%10010001; + !byte $57,%01001100 + !byte $51,%01001100 + !byte $43,%00001110 + !byte $3F,%11001111 + !byte $6D,%01101110 + !byte $6D,%10001111; + !byte $61,%10101101 + !byte $4B,%01101100 + !byte $4B,%10001101; + !byte $7F,%00110010 + !byte $73,%00010000 + !byte $59,%01001100 + !byte $4F,%01001100 + !byte $3F,%11010001 + !byte $87,%11010011 + !byte $3F,%10101111 + !byte $81,%01010010 + !byte $79,%10110001 + !byte $6F,%10101111 + !byte $41,%00110010 + !byte $85,%10110011 + !byte $83,%01110010 + !byte $83,%10010011; + !byte $75,%00110000 + !byte $5F,%01101100 + !byte $5F,%10001101; + !byte $5B,%01001100 + !byte $4D,%01001100 + !byte $47,%10101101 + !byte $45,%11001101 + !byte $41,%00101110 + !byte $49,%01101100 + !byte $49,%10001101; + !byte $7B,%11010001 + !byte $67,%11101101 + !byte $65,%11001101 + !byte $43,%11101101 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $45,%10110011 + !byte $71,%11001111 + !byte $69,%00001110 + !byte $3F,%11110001 + !byte $77,%01010000 + !byte $6B,%00101110 + !byte $63,%10101101 + !byte $55,%00101100 + !byte $53,%00101100 + !byte $47,%11010011 + !byte $8B,%11110011 + !byte $7D,%11110001 + !byte $5D,%01001100 + !byte $57,%00101100 + !byte $51,%00101100 + !byte $4B,%01001100 + !byte $6D,%01001110 + !byte $41,%00001110 + !byte $3D,%00110000 + !byte $43,%01110010 + !byte $43,%10010011; + !byte $73,%11101111 + !byte $61,%01101100 + !byte $61,%10001101; + !byte $4F,%00101100 + !byte $45,%10101101 + !byte $3F,%01001110 + !byte $3D,%00010000 + !byte $3D,%01010000 + !byte $7F,%00010010 + !byte $59,%00101100 + !byte $47,%01101100 + !byte $47,%10001101; + !byte $3D,%11101111 + !byte $79,%01110000 + !byte $79,%10010001; + !byte $6F,%01101110 + !byte $6F,%10001111; + !byte $43,%11001101 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $89,%11010011 + !byte $75,%00010000 + !byte $4D,%00101100 + !byte $49,%01001100 + !byte $3D,%11001111 + !byte $81,%00110010 + !byte $5F,%01001100 + !byte $5B,%00101100 + !byte $3F,%00101110 + !byte $3F,%00010010 + !byte $87,%10110011 + !byte $83,%01010010 + !byte $7B,%10110001 + !byte $41,%11101101 + !byte $3D,%10101111 + !byte $3D,%10110001 + !byte $85,%01110010 + !byte $85,%10010011; + !byte $71,%10101111 + !byte $69,%11101101 + !byte $67,%11001101 + !byte $65,%10101101 + !byte $4B,%00101100 + !byte $41,%01010010 + !byte $77,%00110000 + !byte $6B,%00001110 + !byte $63,%01101100 + !byte $63,%10001101; + !byte $55,%00001100 + !byte $53,%00001100 + !byte $51,%00001100 + !byte $45,%01101100 + !byte $45,%10001101; + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $7D,%11010001 + !byte $73,%11001111 + !byte $5D,%00101100 + !byte $57,%00001100 + !byte $47,%01001100 + !byte $43,%10101101 + !byte $3F,%00001110 + !byte $8D,%11110011 + !byte $6D,%00101110 + !byte $4F,%00001100 + !byte $3D,%11010001 + !byte $79,%01010000 + !byte $61,%01001100 + !byte $59,%00001100 + !byte $41,%11001101 + !byte $49,%11110011 + !byte $7F,%11110001 + !byte $4D,%00001100 + !byte $49,%00101100 + !byte $3D,%01001110 + !byte $75,%11101111 + !byte $6F,%01001110 + !byte $81,%00010010 + !byte $7B,%01110000 + !byte $7B,%10010001; + !byte $5F,%00101100 + !byte $5B,%00001100 + !byte $3F,%11101101 + !byte $8B,%11010011 + !byte $71,%01101110 + !byte $71,%10001111; + !byte $4B,%00001100 + !byte $45,%01001100 + !byte $43,%01101100 + !byte $43,%10001101; + !byte $3D,%00101110 + !byte $3B,%00010000 + !byte $3F,%00110010 + !byte $83,%00110010 + !byte $77,%00010000 + !byte $69,%11001101 + !byte $67,%10101101 + !byte $65,%01101100 + !byte $65,%10001101; + !byte $47,%00101100 + !byte $41,%10101101 + !byte $3B,%11101111 + !byte $3B,%00110000 + !byte $89,%10110011 + !byte $85,%01010010 + !byte $6B,%11101101 + !byte $55,%11101011 + !byte $53,%11101011 + !byte $51,%11101011 + !byte $3B,%11001111 + !byte $3B,%01010000 + !byte $3D,%11110001 + !byte $87,%01110010 + !byte $87,%10010011; + !byte $7D,%10110001 + !byte $73,%10101111 + !byte $63,%01001100 + !byte $6D,%00001110 + !byte $5D,%00001100 + !byte $57,%11101011 + !byte $4F,%11101011 + !byte $3B,%10101111 + !byte $79,%00110000 + !byte $49,%00001100 + !byte $3F,%11001101 + !byte $3D,%00001110 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $8F,%11110011 + !byte $7F,%11010001 + !byte $61,%00101100 + !byte $59,%11101011 + !byte $4D,%11101011 + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $75,%11001111 + !byte $6F,%00101110 + !byte $43,%01001100 + !byte $45,%00101100 + !byte $41,%01101100 + !byte $41,%10001101; + !byte $81,%11110001 + !byte $7B,%01010000 + !byte $4B,%11101011 + !byte $3B,%01001110 + !byte $3B,%10110001 + !byte $43,%10110011 + !byte $71,%01001110 + !byte $5F,%00001100 + !byte $5B,%11101011 + !byte $47,%00001100 + !byte $3D,%11101101 + !byte $77,%11101111 + !byte $3F,%10101101 + !byte $41,%01110010 + !byte $41,%10010011; + !byte $8D,%11010011 + !byte $83,%00010010 + !byte $69,%10101101 + !byte $67,%01101100 + !byte $67,%10001101; + !byte $65,%01001100 + !byte $53,%11001011 + !byte $3D,%00010010 + !byte $7D,%01110000 + !byte $7D,%10010001; + !byte $73,%01101110 + !byte $73,%10001111; + !byte $6B,%11001101 + !byte $55,%11001011 + !byte $51,%11001011 + !byte $3B,%00101110 + !byte $45,%11010011 + !byte $85,%00110010 + !byte $6D,%11101101 + !byte $63,%00101100 + !byte $4F,%11001011 + !byte $49,%11101011 + !byte $8B,%10110011 + !byte $89,%01110010 + !byte $89,%10010011; + !byte $87,%01010010 + !byte $79,%00010000 + !byte $5D,%11101011 + !byte $57,%11001011 + !byte $43,%00101100 + !byte $3B,%11010001 + !byte $4D,%11001011 + !byte $45,%00001100 + !byte $41,%01001100 + !byte $3D,%11001101 + !byte $7F,%10110001 + !byte $75,%10101111 + !byte $6F,%00001110 + !byte $61,%00001100 + !byte $59,%11001011 + !byte $3B,%00001110 + !byte $39,%11001111 + !byte $39,%11101111 + !byte $39,%00010000 + !byte $3F,%01010010 + !byte $91,%11110011 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $39,%00110000 + !byte $7B,%00110000 + !byte $4B,%11001011 + !byte $47,%11101011 + !byte $39,%10101111 + !byte $81,%11010001 + !byte $71,%00101110 + !byte $77,%11001111 + !byte $5F,%11101011 + !byte $5B,%11001011 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $39,%01010000 + !byte $67,%01001100 + !byte $3D,%10101101 + !byte $3B,%11101101 + !byte $83,%11110001 + !byte $7D,%01010000 + !byte $73,%01001110 + !byte $6B,%10101101 + !byte $69,%01101100 + !byte $69,%10001101; + !byte $65,%00101100 + !byte $53,%10101011 + !byte $51,%10101011 + !byte $49,%11001011 + !byte $43,%00001100 + !byte $41,%00101100 + !byte $39,%01001110 + !byte $8F,%11010011 + !byte $55,%10101011 + !byte $4F,%10101011 + !byte $45,%11101011 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $3B,%11110001 + !byte $85,%00010010 + !byte $79,%11101111 + !byte $6D,%11001101 + !byte $63,%00001100 + !byte $57,%10101011 + !byte $3F,%01001100 + !byte $3D,%00110010 + !byte $5D,%11001011 + !byte $4D,%10101011 + !byte $8D,%10110011 + !byte $87,%00110010 + !byte $7F,%01110000 + !byte $7F,%10010001; + !byte $75,%01101110 + !byte $75,%10001111; + !byte $6F,%11101101 + !byte $47,%11001011 + !byte $3B,%11001101 + !byte $39,%00101110 + !byte $8B,%01110010 + !byte $8B,%10010011; + !byte $89,%01010010 + !byte $61,%11101011 + !byte $59,%10101011 + !byte $4B,%10101011 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $7B,%00010000 + !byte $47,%11110011 + !byte $93,%11110011 + !byte $81,%10110001 + !byte $71,%00001110 + !byte $41,%00001100 + !byte $39,%00001110 + !byte $39,%10110001 + !byte $77,%10101111 + !byte $43,%11101011 + !byte $3F,%00101100 + !byte $5F,%11001011 + !byte $5B,%10101011 + !byte $49,%10101011 + !byte $3B,%10101101 + !byte $83,%11010001 + !byte $7D,%00110000 + !byte $69,%01001100 + !byte $67,%00101100 + !byte $53,%01101010 + !byte $53,%10001011; + !byte $51,%01101010 + !byte $51,%10001011; + !byte $45,%11001011 + !byte $73,%00101110 + !byte $6B,%01101100 + !byte $6B,%10001101; + !byte $65,%00001100 + !byte $55,%01101010 + !byte $55,%10001011; + !byte $4F,%01101010 + !byte $4F,%10001011; + !byte $3D,%01001100 + !byte $39,%11101101 + !byte $37,%10101111 + !byte $37,%11001111 + !byte $37,%11101111 + !byte $79,%11001111 + !byte $6D,%10101101 + !byte $37,%00010000 + !byte $85,%11110001 + !byte $63,%11101011 + !byte $57,%01101010 + !byte $57,%10001011; + !byte $4D,%01101010 + !byte $4D,%10001011; + !byte $47,%10101011 + !byte $37,%01101110 + !byte $37,%10001111; + !byte $3B,%00010010 + !byte $91,%11010011 + !byte $7F,%01010000 + !byte $75,%01001110 + !byte $5D,%10101011 + !byte $37,%00110000 + !byte $39,%11010001 + !byte $87,%00010010 + !byte $6F,%11001101 + !byte $4B,%01101010 + !byte $4B,%10001011; + !byte $41,%11101011 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $37,%01001110 + !byte $41,%10110011 + !byte $7B,%11101111 + !byte $59,%01101010 + !byte $59,%10001011; + !byte $43,%11001011 + !byte $3F,%00001100 + !byte $39,%11001101 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $8F,%10110011 + !byte $89,%00110010 + !byte $81,%01110000 + !byte $81,%10010001; + !byte $71,%11101101 + !byte $61,%11001011 + !byte $37,%01010000 + !byte $8D,%01110010 + !byte $8D,%10010011; + !byte $8B,%01010010 + !byte $77,%01101110 + !byte $77,%10001111; + !byte $49,%01101010 + !byte $49,%10001011; + !byte $3D,%00101100 + !byte $37,%00101110 + !byte $95,%11110011 + !byte $45,%10101011 + !byte $7D,%00010000 + !byte $73,%00001110 + !byte $5F,%10101011 + !byte $5B,%01101010 + !byte $5B,%10001011; + !byte $3D,%01010010 + !byte $83,%10110001 + !byte $69,%00101100 + !byte $67,%00001100 + !byte $53,%01001010 + !byte $51,%01001010 + !byte $4F,%01001010 + !byte $3B,%01001100 + !byte $39,%10101101 + !byte $37,%00001110 + !byte $43,%11010011 + !byte $79,%10101111 + !byte $6B,%01001100 + !byte $65,%11101011 + !byte $55,%01001010 + !byte $4D,%01001010 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $6D,%01101100 + !byte $6D,%10001101; + !byte $47,%01101010 + !byte $47,%10001011; + !byte $41,%11001011 + !byte $3F,%11101011 + !byte $85,%11010001 + !byte $7F,%00110000 + !byte $75,%00101110 + !byte $63,%11001011 + !byte $57,%01001010 + !byte $3D,%00001100 + !byte $37,%11101101 + !byte $39,%11110001 + !byte $6F,%10101101 + !byte $5D,%01101010 + !byte $5D,%10001011; + !byte $4B,%01001010 + !byte $43,%10101011 + !byte $93,%11010011 + !byte $7B,%11001111 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $87,%11110001 + !byte $59,%01001010 + !byte $45,%01101010 + !byte $45,%10001011; + !byte $3B,%00101100 + !byte $89,%00010010 + !byte $81,%01010000 + !byte $77,%01001110 + !byte $71,%11001101 + !byte $61,%10101011 + !byte $49,%01001010 + !byte $37,%11001101 + !byte $35,%01101110 + !byte $35,%10001111; + !byte $35,%10101111 + !byte $35,%11001111 + !byte $35,%11101111 + !byte $37,%10110001 + !byte $3B,%00110010 + !byte $91,%10110011 + !byte $8B,%00110010 + !byte $7D,%11101111 + !byte $35,%01001110 + !byte $35,%00010000 + !byte $97,%11110011 + !byte $8F,%01110010 + !byte $8F,%10010011; + !byte $8D,%01010010 + !byte $83,%01110000 + !byte $83,%10010001; + !byte $73,%11101101 + !byte $5B,%01001010 + !byte $53,%00101010 + !byte $51,%00101010 + !byte $4F,%00101010 + !byte $41,%10101011 + !byte $3F,%11001011 + !byte $79,%01101110 + !byte $79,%10001111; + !byte $6B,%00101100 + !byte $69,%00001100 + !byte $67,%11101011 + !byte $5F,%01101010 + !byte $5F,%10001011; + !byte $4D,%00101010 + !byte $47,%01001010 + !byte $3D,%11101011 + !byte $39,%01001100 + !byte $35,%00101110 + !byte $6D,%01001100 + !byte $65,%11001011 + !byte $55,%00101010 + !byte $43,%01101010 + !byte $43,%10001011; + !byte $37,%10101101 + !byte $35,%00110000 + !byte $85,%10110001 + !byte $7F,%00010000 + !byte $75,%00001110 + !byte $4B,%00101010 + !byte $3B,%00001100 + !byte $7B,%10101111 + !byte $6F,%01101100 + !byte $6F,%10001101; + !byte $57,%00101010 + !byte $35,%00001110 + !byte $63,%10101011 + !byte $5D,%01001010 + !byte $45,%01001010 + !byte $87,%11010001 + !byte $49,%00101010 + !byte $35,%01010000 + !byte $37,%11010001 + !byte $39,%00010010 + !byte $95,%11010011 + !byte $81,%00110000 + !byte $77,%00101110 + !byte $71,%10101101 + !byte $59,%00101010 + !byte $3F,%10101011 + !byte $39,%00101100 + !byte $37,%01101100 + !byte $37,%10001101; + !byte $35,%11101101 + !byte $61,%01101010 + !byte $61,%10001011; + !byte $41,%01101010 + !byte $41,%10001011; + !byte $3D,%11001011 + !byte $89,%11110001 + !byte $7D,%11001111 + !byte $45,%11110011 + !byte $83,%01010000 + !byte $79,%01001110 + !byte $73,%11001101 + !byte $51,%00001010 + !byte $47,%00101010 + !byte $3B,%11101011 + !byte $35,%11001101 + !byte $93,%10110011 + !byte $8B,%00010010 + !byte $5B,%00101010 + !byte $53,%00001010 + !byte $4F,%00001010 + !byte $43,%01001010 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $99,%11110011 + !byte $91,%01110010 + !byte $91,%10010011; + !byte $8D,%00110010 + !byte $6B,%00001100 + !byte $69,%11101011 + !byte $67,%11001011 + !byte $5F,%01001010 + !byte $55,%00001010 + !byte $4D,%00001010 + !byte $37,%01001100 + !byte $8F,%01010010 + !byte $7F,%11101111 + !byte $75,%11101101 + !byte $6D,%00101100 + !byte $4B,%00001010 + !byte $39,%00001100 + !byte $33,%01101110 + !byte $33,%10001111; + !byte $33,%10101111 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $85,%01110000 + !byte $85,%10010001; + !byte $7B,%01101110 + !byte $7B,%10001111; + !byte $65,%10101011 + !byte $45,%00101010 + !byte $35,%10101101 + !byte $33,%01001110 + !byte $33,%11001111 + !byte $3F,%10110011 + !byte $6F,%01001100 + !byte $57,%00001010 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $3D,%10101011 + !byte $33,%11101111 + !byte $63,%01101010 + !byte $63,%10001011; + !byte $49,%00001010 + !byte $3B,%11001011 + !byte $33,%00101110 + !byte $3B,%01010010 + !byte $87,%10110001 + !byte $81,%00010000 + !byte $77,%00001110 + !byte $71,%01101100 + !byte $71,%10001101; + !byte $5D,%00101010 + !byte $41,%01001010 + !byte $37,%00101100 + !byte $33,%00010000 + !byte $37,%11110001 + !byte $7D,%10101111 + !byte $59,%00001010 + !byte $33,%00001110 + !byte $61,%01001010 + !byte $47,%00001010 + !byte $43,%00101010 + !byte $39,%11101011 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $35,%10110001 + !byte $97,%11010011 + !byte $89,%11010001 + !byte $83,%00110000 + !byte $79,%00101110 + !byte $73,%10101101 + !byte $51,%11101001 + !byte $4F,%11101001 + !byte $33,%11101101 + !byte $33,%00110000 + !byte $8B,%11110001 + !byte $7F,%11001111 + !byte $53,%11101001 + !byte $4D,%11101001 + !byte $41,%11010011 + !byte $95,%10110011 + !byte $75,%11001101 + !byte $6B,%11101011 + !byte $69,%11001011 + !byte $67,%10101011 + !byte $5F,%00101010 + !byte $5B,%00001010 + !byte $55,%11101001 + !byte $4B,%11101001 + !byte $45,%00001010 + !byte $3F,%01001010 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $37,%00001100 + !byte $39,%00110010 + !byte $9B,%11110011 + !byte $8D,%00010010 + !byte $85,%01010000 + !byte $7B,%01001110 + !byte $6D,%00001100 + !byte $3B,%10101011 + !byte $35,%01001100 + !byte $33,%11001101 + !byte $93,%01110010 + !byte $93,%10010011; + !byte $91,%01010010 + !byte $8F,%00110010 + !byte $6F,%00101100 + !byte $65,%01101010 + !byte $65,%10001011; + !byte $41,%00101010 + !byte $81,%11101111 + !byte $57,%11101001 + !byte $49,%11101001 + !byte $39,%11001011 + !byte $33,%01010000 + !byte $87,%01110000 + !byte $87,%10010001; + !byte $77,%11101101 + !byte $63,%01001010 + !byte $33,%10101101 + !byte $7D,%01101110 + !byte $7D,%10001111; + !byte $71,%01001100 + !byte $5D,%00001010 + !byte $43,%00001010 + !byte $35,%11010001 + !byte $59,%11101001 + !byte $47,%11101001 + !byte $37,%11101011 + !byte $35,%00101100 + !byte $89,%10110001 + !byte $83,%00010000 + !byte $79,%00001110 + !byte $73,%01101100 + !byte $73,%10001101; + !byte $61,%00101010 + !byte $3D,%01001010 + !byte $31,%01001110 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $31,%10101111 + !byte $51,%11001001 + !byte $4F,%11001001 + !byte $3F,%00101010 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $31,%00101110 + !byte $31,%11001111 + !byte $37,%00010010 + !byte $99,%11010011 + !byte $7F,%10101111 + !byte $53,%11001001 + !byte $4D,%11001001 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $8B,%11010001 + !byte $75,%10101101 + !byte $69,%10101011 + !byte $4B,%11001001 + !byte $45,%11101001 + !byte $39,%10101011 + !byte $31,%00001110 + !byte $31,%11101111 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $85,%00110000 + !byte $7B,%00101110 + !byte $6D,%11101011 + !byte $6B,%11001011 + !byte $67,%01101010 + !byte $67,%10001011; + !byte $5F,%00001010 + !byte $5B,%11101001 + !byte $55,%11001001 + !byte $41,%00001010 + !byte $35,%00001100 + !byte $8D,%11110001 + !byte $49,%11001001 + !byte $37,%11001011 + !byte $31,%11101101 + !byte $9D,%11110011 + !byte $97,%10110011 + !byte $81,%11001111 + !byte $6F,%00001100 + !byte $65,%01001010 + !byte $33,%01001100 + !byte $31,%00010000 + !byte $8F,%00010010 + !byte $87,%01010000 + !byte $77,%11001101 + !byte $57,%11001001 + !byte $43,%11101001 + !byte $95,%01110010 + !byte $95,%10010011; + !byte $93,%01010010 + !byte $91,%00110010 + !byte $7D,%01001110 + !byte $71,%00101100 + !byte $63,%00101010 + !byte $47,%11001001 + !byte $3D,%00101010 + !byte $3B,%01001010 + !byte $31,%11001101 + !byte $5D,%11101001 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $83,%11101111 + !byte $73,%01001100 + !byte $59,%11001001 + !byte $3F,%00001010 + !byte $35,%11101011 + !byte $89,%01110000 + !byte $89,%10010001; + !byte $79,%11101101 + !byte $61,%00001010 + !byte $33,%00101100 + !byte $31,%10101101 + !byte $31,%00110000 + !byte $33,%10110001 + !byte $35,%11110001 + !byte $7F,%01101110 + !byte $7F,%10001111; + !byte $51,%10101001 + !byte $4F,%10101001 + !byte $4D,%10101001 + !byte $45,%11001001 + !byte $41,%11101001 + !byte $37,%10101011 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $75,%01101100 + !byte $75,%10001101; + !byte $53,%10101001 + !byte $4B,%10101001 + !byte $9B,%11010011 + !byte $8B,%10110001 + !byte $85,%00010000 + !byte $7B,%00001110 + !byte $6B,%10101011 + !byte $69,%01101010 + !byte $69,%10001011; + !byte $39,%01010010 + !byte $3D,%10110011 + !byte $43,%11110011 + !byte $6D,%11001011 + !byte $67,%01001010 + !byte $5F,%11101001 + !byte $5B,%11001001 + !byte $55,%10101001 + !byte $49,%10101001 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $8D,%11010001 + !byte $81,%10101111 + !byte $6F,%11101011 + !byte $43,%11001001 + !byte $3D,%00001010 + !byte $3B,%00101010 + !byte $35,%11001011 + !byte $33,%00001100 + !byte $77,%10101101 + !byte $65,%00101010 + !byte $57,%10101001 + !byte $39,%01001010 + !byte $2F,%00101110 + !byte $2F,%01001110 + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $31,%01010000 + !byte $9F,%11110011 + !byte $99,%10110011 + !byte $8F,%11110001 + !byte $87,%00110000 + !byte $7D,%00101110 + !byte $71,%00001100 + !byte $47,%10101001 + !byte $3F,%11101001 + !byte $31,%01001100 + !byte $2F,%00001110 + !byte $2F,%10101111 + !byte $63,%00001010 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $2F,%11001111 + !byte $37,%00110010 + !byte $97,%01110010 + !byte $97,%10010011; + !byte $91,%00010010 + !byte $83,%11001111 + !byte $79,%11001101 + !byte $5D,%11001001 + !byte $2F,%11101101 + !byte $95,%01010010 + !byte $93,%00110010 + !byte $89,%01010000 + !byte $73,%00101100 + !byte $59,%10101001 + !byte $45,%10101001 + !byte $41,%11001001 + !byte $33,%11101011 + !byte $7F,%01001110 + !byte $61,%11101001 + !byte $51,%01101000 + !byte $51,%10001001; + !byte $4F,%01101000 + !byte $4F,%10001001; + !byte $4D,%01101000 + !byte $4D,%10001001; + !byte $35,%10101011 + !byte $2F,%11001101 + !byte $2F,%11101111 + !byte $33,%11010001 + !byte $4B,%01101000 + !byte $4B,%10001001; + !byte $31,%00101100 + !byte $8B,%01110000 + !byte $8B,%10010001; + !byte $85,%11101111 + !byte $7B,%11101101 + !byte $75,%01001100 + !byte $53,%01101000 + !byte $53,%10001001; + !byte $3B,%00001010 + !byte $39,%00101010 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $6B,%01101010 + !byte $6B,%10001011; + !byte $69,%01001010 + !byte $49,%01101000 + !byte $49,%10001001; + !byte $43,%10101001 + !byte $3D,%11101001 + !byte $37,%01001010 + !byte $2F,%10101101 + !byte $3F,%11010011 + !byte $9D,%11010011 + !byte $81,%01101110 + !byte $81,%10001111; + !byte $6D,%10101011 + !byte $67,%00101010 + !byte $5F,%11001001 + !byte $5B,%10101001 + !byte $55,%01101000 + !byte $55,%10001001; + !byte $33,%11001011 + !byte $2F,%00010000 + !byte $35,%00010010 + !byte $8D,%10110001 + !byte $77,%01101100 + !byte $77,%10001101; + !byte $6F,%11001011 + !byte $47,%01101000 + !byte $47,%10001001; + !byte $3F,%11001001 + !byte $31,%00001100 + !byte $87,%00010000 + !byte $7D,%00001110 + !byte $65,%00001010 + !byte $57,%01101000 + !byte $57,%10001001; + !byte $35,%01101010 + !byte $35,%10001011; + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $8F,%11010001 + !byte $71,%11101011 + !byte $A1,%11110011 + !byte $83,%10101111 + !byte $79,%10101101 + !byte $63,%11101001 + !byte $41,%10101001 + !byte $9B,%10110011 + !byte $91,%11110001 + !byte $89,%00110000 + !byte $73,%00001100 + !byte $5D,%10101001 + !byte $45,%01101000 + !byte $45,%10001001; + !byte $39,%00001010 + !byte $2F,%00110000 + !byte $7F,%00101110 + !byte $59,%01101000 + !byte $59,%10001001; + !byte $3B,%11101001 + !byte $33,%10101011 + !byte $31,%11101011 + !byte $2F,%01001100 + !byte $99,%01110010 + !byte $99,%10010011; + !byte $93,%00010010 + !byte $61,%11001001 + !byte $51,%01001000 + !byte $4F,%01001000 + !byte $4D,%01001000 + !byte $4B,%01001000 + !byte $3D,%11001001 + !byte $37,%00101010 + !byte $97,%01010010 + !byte $95,%00110010 + !byte $85,%11001111 + !byte $7B,%11001101 + !byte $75,%00101100 + !byte $53,%01001000 + !byte $2D,%00001110 + !byte $2D,%00101110 + !byte $2D,%01001110 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $31,%10110001 + !byte $8B,%01010000 + !byte $49,%01001000 + !byte $43,%01101000 + !byte $43,%10001001; + !byte $3F,%10101001 + !byte $35,%01001010 + !byte $2F,%00101100 + !byte $2D,%11101101 + !byte $81,%01001110 + !byte $6B,%01001010 + !byte $69,%00101010 + !byte $55,%01001000 + !byte $2D,%10101111 + !byte $33,%11110001 + !byte $77,%01001100 + !byte $6D,%01101010 + !byte $6D,%10001011; + !byte $67,%00001010 + !byte $5F,%10101001 + !byte $5B,%01101000 + !byte $5B,%10001001; + !byte $47,%01001000 + !byte $2D,%11001101 + !byte $9F,%11010011 + !byte $8D,%01110000 + !byte $8D,%10010001; + !byte $87,%11101111 + !byte $7D,%11101101 + !byte $6F,%10101011 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $31,%11001011 + !byte $2D,%11001111 + !byte $2F,%01010000 + !byte $71,%11001011 + !byte $65,%11101001 + !byte $57,%01001000 + !byte $41,%01101000 + !byte $41,%10001001; + !byte $39,%11101001 + !byte $2D,%10101101 + !byte $8F,%10110001 + !byte $83,%01101110 + !byte $83,%10001111; + !byte $79,%01101100 + !byte $79,%10001101; + !byte $45,%01001000 + !byte $3B,%11001001 + !byte $37,%00001010 + !byte $2F,%00001100 + !byte $89,%00010000 + !byte $73,%11101011 + !byte $63,%11001001 + !byte $3D,%10101001 + !byte $39,%01110010 + !byte $39,%10010011; + !byte $A3,%11110011 + !byte $91,%11010001 + !byte $7F,%00001110 + !byte $5D,%01101000 + !byte $5D,%10001001; + !byte $35,%00101010 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $2D,%11101111 + !byte $37,%01010010 + !byte $9D,%10110011 + !byte $59,%01001000 + !byte $4F,%00101000 + !byte $4D,%00101000 + !byte $31,%10101011 + !byte $93,%11110001 + !byte $85,%10101111 + !byte $7B,%10101101 + !byte $75,%00001100 + !byte $51,%00101000 + !byte $4B,%00101000 + !byte $43,%01001000 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $2F,%11101011 + !byte $8B,%00110000 + !byte $61,%10101001 + !byte $53,%00101000 + !byte $49,%00101000 + !byte $33,%01001010 + !byte $2D,%01001100 + !byte $9B,%01110010 + !byte $9B,%10010011; + !byte $99,%01010010 + !byte $95,%00010010 + !byte $81,%00101110 + !byte $2D,%00010000 + !byte $31,%11010001 + !byte $35,%00110010 + !byte $3B,%10110011 + !byte $97,%00110010 + !byte $77,%00101100 + !byte $6D,%01001010 + !byte $6B,%00101010 + !byte $69,%00001010 + !byte $55,%00101000 + !byte $47,%00101000 + !byte $39,%11001001 + !byte $37,%11101001 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $8D,%01010000 + !byte $87,%11001111 + !byte $7D,%11001101 + !byte $6F,%01101010 + !byte $6F,%10001011; + !byte $67,%11101001 + !byte $5F,%01101000 + !byte $5F,%10001001; + !byte $5B,%01001000 + !byte $41,%01001000 + !byte $3B,%10101001 + !byte $35,%00001010 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $2F,%11001011 + !byte $2D,%00101100 + !byte $41,%11110011 + !byte $83,%01001110 + !byte $79,%01001100 + !byte $71,%10101011 + !byte $65,%11001001 + !byte $57,%00101000 + !byte $45,%00101000 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $2B,%00001110 + !byte $2B,%00101110 + !byte $A1,%11010011 + !byte $8F,%01110000 + !byte $8F,%10010001; + !byte $33,%00101010 + !byte $2B,%11101101 + !byte $2B,%01001110 + !byte $89,%11101111 + !byte $7F,%11101101 + !byte $73,%11001011 + !byte $63,%10101001 + !byte $2B,%11001101 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $2D,%00110000 + !byte $33,%00010010 + !byte $91,%10110001 + !byte $5D,%01001000 + !byte $4F,%00001000 + !byte $4D,%00001000 + !byte $43,%00101000 + !byte $3F,%01001000 + !byte $2D,%00001100 + !byte $A5,%11110011 + !byte $85,%01101110 + !byte $85,%10001111; + !byte $7B,%01101100 + !byte $7B,%10001101; + !byte $75,%11101011 + !byte $59,%00101000 + !byte $51,%00001000 + !byte $4B,%00001000 + !byte $2F,%10101011 + !byte $2B,%10101101 + !byte $2B,%10101111 + !byte $9F,%10110011 + !byte $8B,%00010000 + !byte $49,%00001000 + !byte $39,%10101001 + !byte $37,%11001001 + !byte $35,%11101001 + !byte $31,%01001010 + !byte $93,%11010001 + !byte $81,%00001110 + !byte $61,%01101000 + !byte $61,%10001001; + !byte $53,%00001000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $77,%00001100 + !byte $47,%00001000 + !byte $41,%00101000 + !byte $2D,%11101011 + !byte $2B,%11001111 + !byte $9D,%01110010 + !byte $9D,%10010011; + !byte $95,%11110001 + !byte $8D,%00110000 + !byte $87,%10101111 + !byte $7D,%10101101 + !byte $6D,%00101010 + !byte $6B,%00001010 + !byte $69,%11101001 + !byte $55,%00001000 + !byte $3D,%01001000 + !byte $33,%00001010 + !byte $2F,%10110001 + !byte $3D,%11010011 + !byte $9B,%01010010 + !byte $99,%00110010 + !byte $97,%00010010 + !byte $6F,%01001010 + !byte $67,%11001001 + !byte $5B,%00101000 + !byte $45,%00001000 + !byte $2B,%01001100 + !byte $83,%00101110 + !byte $79,%00101100 + !byte $71,%01101010 + !byte $71,%10001011; + !byte $5F,%01001000 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $2D,%01010000 + !byte $8F,%01010000 + !byte $7F,%11001101 + !byte $65,%10101001 + !byte $57,%00001000 + !byte $31,%00101010 + !byte $2D,%11001011 + !byte $2B,%11101111 + !byte $31,%11110001 + !byte $89,%11001111 + !byte $73,%10101011 + !byte $3F,%00101000 + !byte $37,%10101001 + !byte $2B,%00101100 + !byte $A3,%11010011 + !byte $63,%01101000 + !byte $63,%10001001; + !byte $43,%00001000 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $35,%11001001 + !byte $85,%01001110 + !byte $7B,%01001100 + !byte $4F,%11100111 + !byte $4D,%11100111 + !byte $4B,%11100111 + !byte $3B,%01001000 + !byte $91,%01110000 + !byte $91,%10010001; + !byte $8B,%11101111 + !byte $75,%11001011 + !byte $5D,%00101000 + !byte $59,%00001000 + !byte $51,%11100111 + !byte $49,%11100111 + !byte $33,%11101001 + !byte $2F,%01001010 + !byte $A7,%11110011 + !byte $81,%11101101 + !byte $2D,%10101011 + !byte $2B,%00001100 + !byte $93,%10110001 + !byte $61,%01001000 + !byte $53,%11100111 + !byte $47,%11100111 + !byte $41,%00001000 + !byte $3D,%00101000 + !byte $31,%00001010 + !byte $29,%11101101 + !byte $29,%00001110 + !byte $29,%00101110 + !byte $2B,%00010000 + !byte $A1,%10110011 + !byte $87,%01101110 + !byte $87,%10001111; + !byte $7D,%01101100 + !byte $7D,%10001101; + !byte $77,%11101011 + !byte $6B,%11101001 + !byte $29,%11001101 + !byte $29,%01001110 + !byte $95,%11010001 + !byte $8D,%00010000 + !byte $6F,%00101010 + !byte $6D,%00001010 + !byte $69,%11001001 + !byte $55,%11100111 + !byte $45,%11100111 + !byte $29,%10101101 + !byte $9F,%01110010 + !byte $9F,%10010011; + !byte $97,%11110001 + !byte $83,%00001110 + !byte $79,%00001100 + !byte $67,%10101001 + !byte $5B,%00001000 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $35,%10101001 + !byte $2B,%11101011 + !byte $29,%01101110 + !byte $29,%10001111; + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $2F,%11010001 + !byte $35,%01010010 + !byte $71,%01001010 + !byte $5F,%00101000 + !byte $3F,%00001000 + !byte $39,%01001000 + !byte $33,%11001001 + !byte $2F,%00101010 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $29,%01101100 + !byte $29,%10001101; + !byte $37,%01110010 + !byte $37,%10010011; + !byte $9D,%01010010 + !byte $9B,%00110010 + !byte $99,%00010010 + !byte $8F,%00110000 + !byte $89,%10101111 + !byte $7F,%10101101 + !byte $65,%01101000 + !byte $65,%10001001; + !byte $57,%11100111 + !byte $43,%11100111 + !byte $73,%01101010 + !byte $73,%10001011; + !byte $3B,%00101000 + !byte $29,%10101111 + !byte $33,%00110010 + !byte $85,%00101110 + !byte $7B,%00101100 + !byte $4D,%11000111 + !byte $4B,%11000111 + !byte $31,%11101001 + !byte $2B,%11001011 + !byte $29,%01001100 + !byte $2B,%00110000 + !byte $A5,%11010011 + !byte $91,%01010000 + !byte $81,%11001101 + !byte $75,%10101011 + !byte $63,%01001000 + !byte $4F,%11000111 + !byte $49,%11000111 + !byte $8B,%11001111 + !byte $5D,%00001000 + !byte $59,%11100111 + !byte $51,%11000111 + !byte $41,%11100111 + !byte $3D,%00001000 + !byte $29,%00101100 + !byte $87,%01001110 + !byte $53,%11000111 + !byte $47,%11000111 + !byte $2F,%00001010 + !byte $2D,%01001010 + !byte $29,%11001111 + !byte $39,%10110011 + !byte $A9,%11110011 + !byte $93,%01110000 + !byte $93,%10010001; + !byte $7D,%01001100 + !byte $77,%11001011 + !byte $61,%00101000 + !byte $37,%01001000 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $2B,%10101011 + !byte $8D,%11101111 + !byte $6D,%11101001 + !byte $45,%11000111 + !byte $39,%00101000 + !byte $33,%10101001 + !byte $29,%00001100 + !byte $31,%00010010 + !byte $A3,%10110011 + !byte $95,%10110001 + !byte $83,%11101101 + !byte $6F,%00001010 + !byte $6B,%11001001 + !byte $69,%10101001 + !byte $55,%11000111 + !byte $3F,%11100111 + !byte $7F,%01101100 + !byte $7F,%10001101; + !byte $79,%11101011 + !byte $71,%00101010 + !byte $67,%01101000 + !byte $67,%10001001; + !byte $5B,%11100111 + !byte $31,%11001001 + !byte $2D,%10110001 + !byte $97,%11010001 + !byte $8F,%00010000 + !byte $89,%01101110 + !byte $89,%10001111; + !byte $5F,%00001000 + !byte $43,%11000111 + !byte $3B,%00001000 + !byte $2D,%00101010 + !byte $29,%11101111 + !byte $2B,%01010000 + !byte $A1,%01110010 + !byte $A1,%10010011; + !byte $85,%00001110 + !byte $73,%01001010 + !byte $65,%01001000 + !byte $57,%11000111 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $29,%11101011 + !byte $9F,%01010010 + !byte $9B,%00010010 + !byte $99,%11110001 + !byte $7B,%00001100 + !byte $2F,%11101001 + !byte $27,%11001101 + !byte $27,%11101101 + !byte $27,%00001110 + !byte $3F,%11110011 + !byte $9D,%00110010 + !byte $8B,%10101111 + !byte $81,%10101101 + !byte $75,%01101010 + !byte $75,%10001011; + !byte $4F,%10100111 + !byte $4D,%10100111 + !byte $4B,%10100111 + !byte $49,%10100111 + !byte $41,%11000111 + !byte $3D,%11100111 + !byte $35,%01001000 + !byte $27,%10101101 + !byte $27,%00101110 + !byte $91,%00110000 + !byte $63,%00101000 + !byte $51,%10100111 + !byte $37,%00101000 + !byte $33,%01101000 + !byte $33,%10001001; + !byte $27,%01101100 + !byte $27,%10001101; + !byte $2F,%11110001 + !byte $A7,%11010011 + !byte $87,%00101110 + !byte $5D,%11100111 + !byte $59,%11000111 + !byte $47,%10100111 + !byte $29,%11001011 + !byte $27,%01001110 + !byte $7D,%00101100 + !byte $77,%10101011 + !byte $53,%10100111 + !byte $39,%00001000 + !byte $31,%10101001 + !byte $2D,%00001010 + !byte $2B,%01001010 + !byte $27,%01001100 + !byte $29,%00010000 + !byte $93,%01010000 + !byte $8D,%11001111 + !byte $61,%00001000 + !byte $45,%10100111 + !byte $3F,%11000111 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $AB,%11110011 + !byte $83,%11001101 + !byte $6D,%11001001 + !byte $6B,%10101001 + !byte $3B,%11100111 + !byte $2F,%11001001 + !byte $95,%01110000 + !byte $95,%10010001; + !byte $89,%01001110 + !byte $7F,%01001100 + !byte $79,%11001011 + !byte $6F,%11101001 + !byte $69,%01101000 + !byte $69,%10001001; + !byte $55,%10100111 + !byte $43,%10100111 + !byte $29,%10101011 + !byte $27,%00101100 + !byte $3B,%11010011 + !byte $A5,%10110011 + !byte $8F,%11101111 + !byte $71,%00001010 + !byte $67,%01001000 + !byte $5B,%11000111 + !byte $27,%10101111 + !byte $97,%10110001 + !byte $85,%11101101 + !byte $73,%00101010 + !byte $5F,%11100111 + !byte $35,%00101000 + !byte $33,%01001000 + !byte $2B,%00101010 + !byte $27,%00001100 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $7B,%11101011 + !byte $65,%00101000 + !byte $57,%10100111 + !byte $3D,%11000111 + !byte $37,%00001000 + !byte $2D,%11101001 + !byte $A3,%01110010 + !byte $A3,%10010011; + !byte $99,%11010001 + !byte $8B,%01101110 + !byte $8B,%10001111; + !byte $81,%01101100 + !byte $81,%10001101; + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $41,%10100111 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $29,%01101010 + !byte $29,%10001011; + !byte $2D,%11010001 + !byte $91,%00010000 + !byte $75,%01001010 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $49,%01100110 + !byte $49,%10000111; + !byte $39,%11100111 + !byte $27,%11101011 + !byte $29,%00110000 + !byte $A1,%01010010 + !byte $9B,%11110001 + !byte $87,%00001110 + !byte $63,%00001000 + !byte $51,%01100110 + !byte $51,%10000111; + !byte $47,%01100110 + !byte $47,%10000111; + !byte $2F,%10101001 + !byte $27,%11001111 + !byte $9F,%00110010 + !byte $9D,%00010010 + !byte $7D,%00001100 + !byte $77,%01101010 + !byte $77,%10001011; + !byte $5D,%11000111 + !byte $59,%10100111 + !byte $3F,%10100111 + !byte $93,%00110000 + !byte $8D,%10101111 + !byte $83,%10101101 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $45,%01100110 + !byte $45,%10000111; + !byte $3B,%11000111 + !byte $2B,%00001010 + !byte $A9,%11010011 + !byte $61,%11100111 + !byte $2D,%11001001 + !byte $29,%01001010 + !byte $27,%11001011 + !byte $33,%01010010 + !byte $79,%10101011 + !byte $6F,%11001001 + !byte $6D,%10101001 + !byte $6B,%01101000 + !byte $6B,%10001001; + !byte $43,%01100110 + !byte $43,%10000111; + !byte $35,%00001000 + !byte $33,%00101000 + !byte $25,%10101101 + !byte $25,%11001101 + !byte $25,%11101101 + !byte $25,%00001110 + !byte $31,%00110010 + !byte $AD,%11110011 + !byte $95,%01010000 + !byte $89,%00101110 + !byte $7F,%00101100 + !byte $69,%01001000 + !byte $55,%01100110 + !byte $55,%10000111; + !byte $37,%11100111 + !byte $31,%01001000 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $27,%11101111 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $8F,%11001111 + !byte $85,%11001101 + !byte $71,%11101001 + !byte $67,%00101000 + !byte $5B,%10100111 + !byte $3D,%10100111 + !byte $25,%01001100 + !byte $25,%00101110 + !byte $97,%01110000 + !byte $97,%10010001; + !byte $7B,%11001011 + !byte $73,%00001010 + !byte $5F,%11000111 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $27,%10101011 + !byte $A7,%10110011 + !byte $8B,%01001110 + !byte $81,%01001100 + !byte $65,%00001000 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $4B,%01000110 + !byte $39,%11000111 + !byte $2B,%11101001 + !byte $29,%00101010 + !byte $25,%00101100 + !byte $25,%01001110 + !byte $29,%01010000 + !byte $2B,%10110001 + !byte $99,%10110001 + !byte $91,%11101111 + !byte $75,%00101010 + !byte $4F,%01000110 + !byte $4D,%01000110 + !byte $49,%01000110 + !byte $2D,%10101001 + !byte $2F,%00010010 + !byte $87,%11101101 + !byte $47,%01000110 + !byte $A5,%01110010 + !byte $A5,%10010011; + !byte $9B,%11010001 + !byte $7D,%11101011 + !byte $77,%01001010 + !byte $63,%11100111 + !byte $51,%01000110 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $3B,%10100111 + !byte $27,%01101010 + !byte $27,%10001011; + !byte $25,%00001100 + !byte $25,%01101110 + !byte $25,%10001111; + !byte $93,%00010000 + !byte $8D,%01101110 + !byte $8D,%10001111; + !byte $83,%01101100 + !byte $83,%10001101; + !byte $5D,%10100111 + !byte $59,%01100110 + !byte $59,%10000111; + !byte $45,%01000110 + !byte $35,%11100111 + !byte $33,%00001000 + !byte $31,%00101000 + !byte $27,%00010000 + !byte $37,%10110011 + !byte $A3,%01010010 + !byte $9F,%00010010 + !byte $9D,%11110001 + !byte $53,%01000110 + !byte $2F,%01001000 + !byte $2B,%11001001 + !byte $29,%00001010 + !byte $A1,%00110010 + !byte $89,%00001110 + !byte $7F,%00001100 + !byte $79,%01101010 + !byte $79,%10001011; + !byte $61,%11000111 + !byte $43,%01000110 + !byte $37,%11000111 + !byte $25,%11101011 + !byte $AB,%11010011 + !byte $6F,%10101001 + !byte $6D,%01101000 + !byte $6D,%10001001; + !byte $6B,%01001000 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $27,%01001010 + !byte $25,%10101111 + !byte $2D,%11110001 + !byte $95,%00110000 + !byte $8F,%10101111 + !byte $85,%10101101 + !byte $71,%11001001 + !byte $69,%00101000 + !byte $55,%01000110 + !byte $39,%10100111 + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $AF,%11110011 + !byte $7B,%10101011 + !byte $67,%00001000 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $41,%01000110 + !byte $25,%11001011 + !byte $97,%01010000 + !byte $8B,%00101110 + !byte $81,%00101100 + !byte $73,%11101001 + !byte $5F,%10100111 + !byte $29,%11101001 + !byte $91,%11001111 + !byte $65,%11100111 + !byte $57,%01000110 + !byte $4D,%00100110 + !byte $4B,%00100110 + !byte $49,%00100110 + !byte $33,%11100111 + !byte $31,%00001000 + !byte $2B,%10101001 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $A9,%10110011 + !byte $87,%11001101 + !byte $75,%00001010 + !byte $4F,%00100110 + !byte $47,%00100110 + !byte $3F,%01000110 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $35,%11000111 + !byte $27,%00101010 + !byte $25,%10101011 + !byte $25,%11001111 + !byte $99,%01110000 + !byte $99,%10010001; + !byte $7D,%11001011 + !byte $51,%00100110 + !byte $45,%00100110 + !byte $2F,%00101000 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $23,%10101101 + !byte $23,%11001101 + !byte $23,%11101101 + !byte $27,%00110000 + !byte $8D,%01001110 + !byte $83,%01001100 + !byte $77,%00101010 + !byte $63,%11000111 + !byte $37,%10100111 + !byte $23,%01001100 + !byte $23,%00001110 + !byte $3D,%11110011 + !byte $A7,%01110010 + !byte $A7,%10010011; + !byte $9B,%10110001 + !byte $93,%11101111 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $2D,%01001000 + !byte $89,%11101101 + !byte $7F,%11101011 + !byte $59,%01000110 + !byte $53,%00100110 + !byte $43,%00100110 + !byte $3D,%01000110 + !byte $29,%11001001 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $23,%00101100 + !byte $23,%00101110 + !byte $2B,%11010001 + !byte $A5,%01010010 + !byte $9F,%11110001 + !byte $9D,%11010001 + !byte $79,%01001010 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $27,%00001010 + !byte $23,%00001100 + !byte $A3,%00110010 + !byte $A1,%00010010 + !byte $95,%00010000 + !byte $8F,%01101110 + !byte $8F,%10001111; + !byte $85,%01101100 + !byte $85,%10001101; + !byte $6F,%01101000 + !byte $6F,%10001001; + !byte $6D,%01001000 + !byte $6B,%00101000 + !byte $61,%10100111 + !byte $41,%00100110 + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $25,%11101111 + !byte $AD,%11010011 + !byte $71,%10101001 + !byte $69,%00001000 + !byte $55,%00100110 + !byte $33,%11000111 + !byte $31,%11100111 + !byte $23,%01001110 + !byte $39,%11010011 + !byte $8B,%00001110 + !byte $81,%00001100 + !byte $7B,%01101010 + !byte $7B,%10001011; + !byte $73,%11001001 + !byte $67,%11100111 + !byte $5B,%01000110 + !byte $2F,%00001000 + !byte $25,%01001010 + !byte $23,%11101011 + !byte $B1,%11110011 + !byte $97,%00110000 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $4B,%00000110 + !byte $49,%00000110 + !byte $3B,%01000110 + !byte $35,%10100111 + !byte $91,%10101111 + !byte $87,%10101101 + !byte $75,%11101001 + !byte $65,%11000111 + !byte $57,%00100110 + !byte $4D,%00000110 + !byte $47,%00000110 + !byte $3F,%00100110 + !byte $37,%01100110 + !byte $37,%10000111; + !byte $2D,%00101000 + !byte $29,%10101001 + !byte $27,%11101001 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $7D,%10101011 + !byte $4F,%00000110 + !byte $23,%11001011 + !byte $27,%01010000 + !byte $99,%01010000 + !byte $8D,%00101110 + !byte $83,%00101100 + !byte $51,%00000110 + !byte $45,%00000110 + !byte $2B,%01001000 + !byte $25,%00101010 + !byte $2F,%00110010 + !byte $31,%01010010 + !byte $AB,%10110011 + !byte $93,%11001111 + !byte $77,%00001010 + !byte $63,%10100111 + !byte $43,%00000110 + !byte $3D,%00100110 + !byte $29,%10110001 + !byte $9B,%01110000 + !byte $9B,%10010001; + !byte $89,%11001101 + !byte $7F,%11001011 + !byte $5D,%01000110 + !byte $39,%01000110 + !byte $23,%10101011 + !byte $25,%00010000 + !byte $79,%00101010 + !byte $59,%00100110 + !byte $53,%00000110 + !byte $33,%10100111 + !byte $31,%11000111 + !byte $2F,%11100111 + !byte $27,%11001001 + !byte $23,%10101111 + !byte $33,%01110010 + !byte $33,%10010011; + !byte $A9,%01110010 + !byte $A9,%10010011; + !byte $9D,%10110001 + !byte $95,%11101111 + !byte $8F,%01001110 + !byte $85,%01001100 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $41,%00000110 + !byte $29,%01101000 + !byte $29,%10001001; + !byte $2D,%00010010 + !byte $9F,%11010001 + !byte $6F,%01001000 + !byte $6D,%00101000 + !byte $6B,%00001000 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $2D,%00001000 + !byte $25,%00001010 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $21,%01101100 + !byte $21,%10001101; + !byte $21,%10101101 + !byte $A7,%01010010 + !byte $8B,%11101101 + !byte $81,%11101011 + !byte $7B,%01001010 + !byte $71,%01101000 + !byte $71,%10001001; + !byte $69,%11100111 + !byte $55,%00000110 + !byte $3B,%00100110 + !byte $21,%01001100 + !byte $21,%11001101 + !byte $AF,%11010011 + !byte $A5,%00110010 + !byte $A3,%00010010 + !byte $A1,%11110001 + !byte $73,%10101001 + !byte $67,%11000111 + !byte $3F,%00000110 + !byte $37,%01000110 + !byte $2B,%00101000 + !byte $21,%00101100 + !byte $21,%11101101 + !byte $97,%00010000 + !byte $91,%01101110 + !byte $91,%10001111; + !byte $87,%01101100 + !byte $87,%10001101; + !byte $5B,%00100110 + !byte $4D,%11100101 + !byte $4B,%11100101 + !byte $49,%11100101 + !byte $47,%11100101 + !byte $21,%00001110 + !byte $B3,%11110011 + !byte $7D,%01101010 + !byte $7D,%10001011; + !byte $75,%11001001 + !byte $5F,%01000110 + !byte $57,%00000110 + !byte $4F,%11100101 + !byte $27,%10101001 + !byte $23,%01001010 + !byte $21,%00001100 + !byte $23,%11001111 + !byte $99,%00110000 + !byte $8D,%00001110 + !byte $83,%00001100 + !byte $65,%10100111 + !byte $45,%11100101 + !byte $31,%10100111 + !byte $29,%01001000 + !byte $25,%11101001 + !byte $2B,%11110001 + !byte $93,%10101111 + !byte $77,%11101001 + !byte $51,%11100101 + !byte $43,%11100101 + !byte $3D,%00000110 + !byte $39,%00100110 + !byte $33,%01100110 + !byte $33,%10000111; + !byte $2F,%11000111 + !byte $21,%11101011 + !byte $21,%00101110 + !byte $27,%01110000 + !byte $27,%10010001; + !byte $89,%10101101 + !byte $63,%01100110 + !byte $63,%10000111; + !byte $2D,%11100111 + !byte $25,%00110000 + !byte $35,%10110011 + !byte $AD,%10110011 + !byte $9B,%01010000 + !byte $7F,%10101011 + !byte $79,%00001010 + !byte $5D,%00100110 + !byte $53,%11100101 + !byte $35,%01000110 + !byte $2B,%00001000 + !byte $23,%00101010 + !byte $21,%11001011 + !byte $8F,%00101110 + !byte $85,%00101100 + !byte $59,%00000110 + !byte $41,%11100101 + !byte $21,%01001110 + !byte $9D,%01110000 + !byte $9D,%10010001; + !byte $95,%11001111 + !byte $6F,%00101000 + !byte $3B,%00000110 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $25,%11001001 + !byte $8B,%11001101 + !byte $81,%11001011 + !byte $7B,%00101010 + !byte $71,%01001000 + !byte $6D,%00001000 + !byte $6B,%11100111 + !byte $61,%01000110 + !byte $55,%11100101 + !byte $37,%00100110 + !byte $21,%10101011 + !byte $23,%11101111 + !byte $AB,%01110010 + !byte $AB,%10010011; + !byte $9F,%10110001 + !byte $73,%01101000 + !byte $73,%10001001; + !byte $69,%11000111 + !byte $3F,%11100101 + !byte $29,%00101000 + !byte $23,%00001010 + !byte $A9,%01010010 + !byte $A1,%11010001 + !byte $97,%11101111 + !byte $91,%01001110 + !byte $87,%01001100 + !byte $4B,%11000101 + !byte $49,%11000101 + !byte $31,%01100110 + !byte $31,%10000111; + !byte $2F,%10100111 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $29,%11010001 + !byte $B1,%11010011 + !byte $A3,%11110001 + !byte $7D,%01001010 + !byte $75,%10101001 + !byte $67,%10100111 + !byte $5B,%00000110 + !byte $4D,%11000101 + !byte $47,%11000101 + !byte $2D,%11000111 + !byte $21,%01101010 + !byte $21,%10001011; + !byte $A7,%00110010 + !byte $A5,%00010010 + !byte $8D,%11101101 + !byte $83,%11101011 + !byte $5F,%00100110 + !byte $57,%11100101 + !byte $4F,%11000101 + !byte $45,%11000101 + !byte $3D,%11100101 + !byte $39,%00000110 + !byte $33,%01000110 + !byte $2B,%11100111 + !byte $27,%01001000 + !byte $25,%10101001 + !byte $B5,%11110011 + !byte $99,%00010000 + !byte $93,%01101110 + !byte $93,%10001111; + !byte $77,%11001001 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $43,%11000101 + !byte $89,%01101100 + !byte $89,%10001101; + !byte $51,%11000101 + !byte $35,%00100110 + !byte $23,%11101001 + !byte $21,%01001010 + !byte $1F,%01001100 + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $1F,%10101101 + !byte $7F,%01101010 + !byte $7F,%10001011; + !byte $79,%11101001 + !byte $63,%01000110 + !byte $41,%11000101 + !byte $29,%00001000 + !byte $1F,%00101100 + !byte $1F,%11001101 + !byte $25,%01010000 + !byte $9B,%00110000 + !byte $8F,%00001110 + !byte $85,%00001100 + !byte $53,%11000101 + !byte $3B,%11100101 + !byte $1F,%00001100 + !byte $1F,%11101101 + !byte $21,%10101111 + !byte $23,%00010000 + !byte $AF,%10110011 + !byte $95,%10101111 + !byte $5D,%00000110 + !byte $59,%11100101 + !byte $37,%00000110 + !byte $25,%01101000 + !byte $25,%10001001; + !byte $9D,%01010000 + !byte $8B,%10101101 + !byte $81,%10101011 + !byte $7B,%00001010 + !byte $6F,%00001000 + !byte $6D,%11100111 + !byte $3F,%11000101 + !byte $31,%01000110 + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $2D,%10100111 + !byte $21,%00101010 + !byte $1F,%11101011 + !byte $27,%10110001 + !byte $3B,%11110011 + !byte $71,%00101000 + !byte $6B,%11000111 + !byte $61,%00100110 + !byte $55,%11000101 + !byte $27,%00101000 + !byte $23,%11001001 + !byte $1F,%00001110 + !byte $9F,%01110000 + !byte $9F,%10010001; + !byte $97,%11001111 + !byte $91,%00101110 + !byte $87,%00101100 + !byte $73,%01001000 + !byte $69,%10100111 + !byte $33,%00100110 + !byte $2B,%11000111 + !byte $1F,%11001011 + !byte $AD,%01110010 + !byte $AD,%10010011; + !byte $7D,%00101010 + !byte $75,%01101000 + !byte $75,%10001001; + !byte $67,%01100110 + !byte $67,%10000111; + !byte $4D,%10100101 + !byte $4B,%10100101 + !byte $49,%10100101 + !byte $47,%10100101 + !byte $3D,%11000101 + !byte $39,%11100101 + !byte $2D,%00110010 + !byte $A1,%10110001 + !byte $8D,%11001101 + !byte $83,%11001011 + !byte $5B,%11100101 + !byte $45,%10100101 + !byte $35,%00000110 + !byte $29,%11100111 + !byte $21,%00001010 + !byte $1F,%10101011 + !byte $1F,%00101110 + !byte $21,%11001111 + !byte $2F,%01010010 + !byte $37,%11010011 + !byte $AB,%01010010 + !byte $A3,%11010001 + !byte $5F,%00000110 + !byte $57,%11000101 + !byte $4F,%10100101 + !byte $43,%10100101 + !byte $25,%01001000 + !byte $B3,%11010011 + !byte $A9,%00110010 + !byte $A5,%11110001 + !byte $99,%11101111 + !byte $93,%01001110 + !byte $89,%01001100 + !byte $7F,%01001010 + !byte $77,%10101001 + !byte $65,%01000110 + !byte $23,%10101001 + !byte $2B,%00010010 + !byte $B7,%11110011 + !byte $A7,%00010010 + !byte $51,%10100101 + !byte $41,%10100101 + !byte $3B,%11000101 + !byte $27,%00001000 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $31,%01110010 + !byte $31,%10010011; + !byte $9B,%00010000 + !byte $8F,%11101101 + !byte $85,%11101011 + !byte $79,%11001001 + !byte $63,%00100110 + !byte $37,%11100101 + !byte $2F,%01000110 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $21,%11101001 + !byte $1F,%01001110 + !byte $95,%01101110 + !byte $95,%10001111; + !byte $53,%10100101 + !byte $31,%00100110 + !byte $2B,%10100111 + !byte $23,%00110000 + !byte $8B,%01101100 + !byte $8B,%10001101; + !byte $81,%01101010 + !byte $81,%10001011; + !byte $7B,%11101001 + !byte $5D,%11100101 + !byte $59,%11000101 + !byte $3F,%10100101 + !byte $33,%00000110 + !byte $1F,%01001010 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $B1,%10110011 + !byte $9D,%00110000 + !byte $91,%00001110 + !byte $71,%00001000 + !byte $6F,%11100111 + !byte $6D,%11000111 + !byte $6B,%10100111 + !byte $29,%11000111 + !byte $25,%00101000 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $29,%11110001 + !byte $97,%10101111 + !byte $87,%00001100 + !byte $61,%00000110 + !byte $55,%10100101 + !byte $39,%11000101 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $21,%11101111 + !byte $9F,%01010000 + !byte $83,%10101011 + !byte $7D,%00001010 + !byte $73,%00101000 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $49,%01100100 + !byte $49,%10000101; + !byte $47,%01100100 + !byte $47,%10000101; + !byte $3D,%10100101 + !byte $35,%11100101 + !byte $27,%11100111 + !byte $21,%11001001 + !byte $1F,%00101010 + !byte $1D,%00101100 + !byte $1D,%01001100 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $8D,%10101101 + !byte $75,%01001000 + !byte $67,%01000110 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $45,%01100100 + !byte $45,%10000101; + !byte $1D,%00001100 + !byte $1D,%10101101 + !byte $AF,%01110010 + !byte $AF,%10010011; + !byte $A1,%01110000 + !byte $A1,%10010001; + !byte $93,%00101110 + !byte $89,%00101100 + !byte $5B,%11000101 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $43,%01100100 + !byte $43,%10000101; + !byte $2F,%00100110 + !byte $2D,%01000110 + !byte $1D,%11101011 + !byte $1D,%11001101 + !byte $99,%11001111 + !byte $77,%01101000 + !byte $77,%10001001; + !byte $5F,%11100101 + !byte $57,%10100101 + !byte $37,%11000101 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $23,%01001000 + !byte $AD,%01010010 + !byte $A3,%10110001 + !byte $8F,%11001101 + !byte $85,%11001011 + !byte $7F,%00101010 + !byte $65,%00100110 + !byte $51,%01100100 + !byte $51,%10000101; + !byte $41,%01100100 + !byte $41,%10000101; + !byte $3B,%10100101 + !byte $31,%00000110 + !byte $29,%10100111 + !byte $25,%00001000 + !byte $21,%10101001 + !byte $1F,%00001010 + !byte $1D,%11001011 + !byte $1D,%11101101 + !byte $27,%11010001 + !byte $B5,%11010011 + !byte $79,%10101001 + !byte $1F,%10101111 + !byte $33,%10110011 + !byte $B9,%11110011 + !byte $AB,%00110010 + !byte $A9,%00010010 + !byte $A7,%11110001 + !byte $A5,%11010001 + !byte $9B,%11101111 + !byte $95,%01001110 + !byte $33,%11100101 + !byte $1D,%10101011 + !byte $8B,%01001100 + !byte $81,%01001010 + !byte $63,%00000110 + !byte $53,%01100100 + !byte $53,%10000101; + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $27,%11000111 + !byte $1D,%00001110 + !byte $23,%01010000 + !byte $87,%11101011 + !byte $7B,%11001001 + !byte $5D,%11000101 + !byte $59,%10100101 + !byte $39,%10100101 + !byte $1F,%11101001 + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $21,%00010000 + !byte $9D,%00010000 + !byte $91,%11101101 + !byte $71,%11100111 + !byte $6F,%11000111 + !byte $6D,%10100111 + !byte $35,%11000101 + !byte $23,%00101000 + !byte $97,%01101110 + !byte $97,%10001111; + !byte $8D,%01101100 + !byte $8D,%10001101; + !byte $73,%00001000 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $61,%11100101 + !byte $55,%01100100 + !byte $55,%10000101; + !byte $49,%01000100 + !byte $47,%01000100 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $2F,%00000110 + !byte $2D,%00100110 + !byte $2B,%01000110 + !byte $25,%11100111 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $1D,%00101110 + !byte $B3,%10110011 + !byte $9F,%00110000 + !byte $83,%01101010 + !byte $83,%10001011; + !byte $7D,%11101001 + !byte $75,%00101000 + !byte $69,%01000110 + !byte $4B,%01000100 + !byte $45,%01000100 + !byte $29,%01100110 + !byte $29,%10000111; + !byte $1D,%01001010 + !byte $93,%00001110 + !byte $89,%00001100 + !byte $67,%00100110 + !byte $4D,%01000100 + !byte $43,%01000100 + !byte $37,%10100101 + !byte $31,%11100101 + !byte $1F,%11001001 + !byte $1F,%11001111 + !byte $25,%10110001 + !byte $A1,%01010000 + !byte $99,%10101111 + !byte $7F,%00001010 + !byte $77,%01001000 + !byte $5B,%10100101 + !byte $4F,%01000100 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $8F,%10101101 + !byte $85,%10101011 + !byte $5F,%11000101 + !byte $57,%01100100 + !byte $57,%10000101; + !byte $41,%01000100 + !byte $33,%11000101 + !byte $27,%10100111 + !byte $1D,%00101010 + !byte $1D,%01001110 + !byte $B1,%01110010 + !byte $B1,%10010011; + !byte $79,%01101000 + !byte $79,%10001001; + !byte $65,%00000110 + !byte $51,%01000100 + !byte $23,%00001000 + !byte $21,%01001000 + !byte $A3,%01110000 + !byte $A3,%10010001; + !byte $9B,%11001111 + !byte $95,%00101110 + !byte $8B,%00101100 + !byte $3F,%01000100 + !byte $B7,%11010011 + !byte $AF,%01010010 + !byte $A5,%10110001 + !byte $81,%00101010 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $35,%10100101 + !byte $25,%11000111 + !byte $1F,%10101001 + !byte $1D,%00001010 + !byte $1B,%00001100 + !byte $1B,%00101100 + !byte $1B,%01001100 + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $BB,%11110011 + !byte $AD,%00110010 + !byte $7B,%10101001 + !byte $63,%11100101 + !byte $53,%01000100 + !byte $2D,%00000110 + !byte $2B,%00100110 + !byte $1B,%11101011 + !byte $1B,%10101101 + !byte $AB,%00010010 + !byte $A9,%11110001 + !byte $A7,%11010001 + !byte $9D,%11101111 + !byte $91,%11001101 + !byte $87,%11001011 + !byte $5D,%10100101 + !byte $59,%01100100 + !byte $59,%10000101; + !byte $3D,%01000100 + !byte $2F,%11100101 + !byte $29,%01000110 + !byte $1B,%11001011 + !byte $21,%00110000 + !byte $2B,%00110010 + !byte $97,%01001110 + !byte $8D,%01001100 + !byte $83,%01001010 + !byte $71,%11000111 + !byte $6F,%10100111 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $31,%11000101 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $21,%00101000 + !byte $1B,%11001101 + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $2D,%01010010 + !byte $7D,%11001001 + !byte $73,%11100111 + !byte $6B,%01000110 + !byte $61,%11000101 + !byte $55,%01000100 + !byte $4B,%00100100 + !byte $49,%00100100 + !byte $47,%00100100 + !byte $45,%00100100 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $23,%11100111 + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $1D,%11101001 + !byte $1B,%10101011 + !byte $1F,%11101111 + !byte $29,%00010010 + !byte $9F,%00010000 + !byte $93,%11101101 + !byte $89,%11101011 + !byte $75,%00001000 + !byte $69,%00100110 + !byte $4D,%00100100 + !byte $43,%00100100 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $39,%11110011 + !byte $B5,%10110011 + !byte $99,%01101110 + !byte $99,%10001111; + !byte $3B,%01000100 + !byte $33,%10100101 + !byte $25,%10100111 + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $1B,%11101101 + !byte $8F,%01101100 + !byte $8F,%10001101; + !byte $85,%01101010 + !byte $85,%10001011; + !byte $7F,%11101001 + !byte $77,%00101000 + !byte $67,%00000110 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $4F,%00100100 + !byte $41,%00100100 + !byte $35,%11010011 + !byte $A1,%00110000 + !byte $5F,%10100101 + !byte $57,%01000100 + !byte $2B,%00000110 + !byte $21,%00001000 + !byte $1D,%11001001 + !byte $1B,%01001010 + !byte $27,%11110001 + !byte $9B,%10101111 + !byte $95,%00001110 + !byte $8B,%00001100 + !byte $79,%01001000 + !byte $65,%11100101 + !byte $51,%00100100 + !byte $3F,%00100100 + !byte $39,%01000100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $2D,%11100101 + !byte $29,%00100110 + !byte $1F,%01001000 + !byte $1B,%00001110 + !byte $1D,%10101111 + !byte $B3,%01110010 + !byte $B3,%10010011; + !byte $A3,%01010000 + !byte $81,%00001010 + !byte $2F,%11000101 + !byte $27,%01000110 + !byte $23,%11000111 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $87,%10101011 + !byte $7B,%01101000 + !byte $7B,%10001001; + !byte $1B,%00101010 + !byte $B9,%11010011 + !byte $A5,%01110000 + !byte $A5,%10010001; + !byte $91,%10101101 + !byte $63,%11000101 + !byte $53,%00100100 + !byte $3D,%00100100 + !byte $31,%10100101 + !byte $1D,%10101001 + !byte $BD,%11110011 + !byte $B1,%01010010 + !byte $A7,%10110001 + !byte $9D,%11001111 + !byte $97,%00101110 + !byte $8D,%00101100 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $59,%01000100 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $1B,%00101110 + !byte $AF,%00110010 + !byte $A9,%11010001 + !byte $83,%00101010 + !byte $7D,%10101001 + !byte $71,%10100111 + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $6D,%01000110 + !byte $49,%00000100 + !byte $47,%00000100 + !byte $37,%01000100 + !byte $21,%11100111 + !byte $1B,%00001010 + !byte $1F,%00010000 + !byte $25,%11010001 + !byte $AD,%00010010 + !byte $AB,%11110001 + !byte $93,%11001101 + !byte $89,%11001011 + !byte $73,%11000111 + !byte $6B,%00100110 + !byte $61,%10100101 + !byte $55,%00100100 + !byte $4B,%00000100 + !byte $45,%00000100 + !byte $3B,%00100100 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $1F,%00101000 + !byte $21,%01010000 + !byte $9F,%11101111 + !byte $75,%11100111 + !byte $69,%00000110 + !byte $4D,%00000100 + !byte $43,%00000100 + !byte $2B,%11100101 + !byte $29,%00000110 + !byte $23,%10100111 + !byte $19,%00001100 + !byte $19,%00101100 + !byte $99,%01001110 + !byte $8F,%01001100 + !byte $85,%01001010 + !byte $7F,%11001001 + !byte $41,%00000100 + !byte $2D,%11000101 + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $1B,%11101001 + !byte $19,%11101011 + !byte $19,%01001100 + !byte $1D,%11001111 + !byte $B7,%10110011 + !byte $A1,%00010000 + !byte $77,%00001000 + !byte $67,%11100101 + !byte $5B,%01000100 + !byte $4F,%00000100 + !byte $35,%01000100 + !byte $2F,%10100101 + !byte $27,%00100110 + !byte $19,%11001011 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $1B,%01001110 + !byte $95,%11101101 + !byte $8B,%11101011 + !byte $79,%00101000 + !byte $3F,%00000100 + !byte $39,%00100100 + !byte $25,%01000110 + !byte $19,%10101011 + !byte $19,%10101101 + !byte $9B,%01101110 + !byte $9B,%10001111; + !byte $81,%11101001 + !byte $65,%11000101 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $57,%00100100 + !byte $51,%00000100 + !byte $31,%01100100 + !byte $31,%10000101; + !byte $21,%11000111 + !byte $1F,%00001000 + !byte $A3,%00110000 + !byte $91,%01101100 + !byte $91,%10001101; + !byte $87,%01101010 + !byte $87,%10001011; + !byte $1D,%01001000 + !byte $1B,%11001001 + !byte $19,%01101010 + !byte $19,%10001011; + !byte $23,%10110001 + !byte $31,%10110011 + !byte $7B,%01001000 + !byte $3D,%00000100 + !byte $19,%11001101 + !byte $B5,%01110010 + !byte $B5,%10010011; + !byte $A5,%01010000 + !byte $9D,%10101111 + !byte $97,%00001110 + !byte $8D,%00001100 + !byte $63,%10100101 + !byte $53,%00000100 + !byte $37,%00100100 + !byte $33,%01000100 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $19,%01001010 + !byte $BB,%11010011 + !byte $83,%00001010 + !byte $7D,%01101000 + !byte $7D,%10001001; + !byte $6F,%01000110 + !byte $5D,%01000100 + !byte $59,%00100100 + !byte $2B,%11000101 + !byte $29,%11100101 + !byte $19,%11101101 + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $BF,%11110011 + !byte $B3,%01010010 + !byte $A7,%01110000 + !byte $A7,%10010001; + !byte $89,%10101011 + !byte $73,%10100111 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $6D,%00100110 + !byte $4B,%11100011 + !byte $49,%11100011 + !byte $47,%11100011 + !byte $45,%11100011 + !byte $3B,%00000100 + !byte $2D,%10100101 + !byte $27,%00000110 + !byte $1F,%11100111 + !byte $1B,%10101001 + !byte $19,%00101010 + !byte $A9,%10110001 + !byte $9F,%11001111 + !byte $93,%10101101 + !byte $75,%11000111 + !byte $6B,%00000110 + !byte $61,%01100100 + !byte $61,%10000101; + !byte $55,%00000100 + !byte $43,%11100011 + !byte $25,%00100110 + !byte $21,%10100111 + !byte $1D,%00101000 + !byte $1D,%11101111 + !byte $1F,%00110000 + !byte $B1,%00110010 + !byte $AF,%00010010 + !byte $AB,%11010001 + !byte $99,%00101110 + !byte $8F,%00101100 + !byte $7F,%10101001 + !byte $69,%11100101 + !byte $4D,%11100011 + !byte $41,%11100011 + !byte $35,%00100100 + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $AD,%11110001 + !byte $85,%00101010 + !byte $77,%11100111 + !byte $4F,%11100011 + !byte $39,%00000100 + !byte $19,%00001010 + !byte $19,%00001110 + !byte $A1,%11101111 + !byte $95,%11001101 + !byte $8B,%11001011 + !byte $67,%11000101 + !byte $5B,%00100100 + !byte $3F,%11100011 + !byte $31,%01000100 + !byte $23,%01000110 + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $9B,%01001110 + !byte $81,%11001001 + !byte $79,%00001000 + !byte $57,%00000100 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $B9,%10110011 + !byte $91,%01001100 + !byte $87,%01001010 + !byte $65,%10100101 + !byte $5F,%01000100 + !byte $51,%11100011 + !byte $3D,%11100011 + !byte $29,%11000101 + !byte $1F,%11000111 + !byte $1D,%00001000 + !byte $19,%11101001 + !byte $1B,%10101111 + !byte $29,%00110010 + !byte $A3,%00010000 + !byte $7B,%00101000 + !byte $37,%00000100 + !byte $33,%00100100 + !byte $2B,%10100101 + !byte $27,%11100101 + !byte $27,%00010010 + !byte $97,%11101101 + !byte $8D,%11101011 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $21,%01100110 + !byte $21,%10000111; + !byte $17,%11101011 + !byte $17,%00001100 + !byte $17,%00101100 + !byte $19,%00101110 + !byte $A5,%00110000 + !byte $9D,%01101110 + !byte $9D,%10001111; + !byte $83,%11101001 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $53,%11100011 + !byte $3B,%11100011 + !byte $25,%00000110 + !byte $1B,%01001000 + !byte $19,%11001001 + !byte $17,%11001011 + !byte $17,%01001100 + !byte $2B,%01010010 + !byte $B7,%01110010 + !byte $B7,%10010011; + !byte $93,%01101100 + !byte $93,%10001101; + !byte $89,%01101010 + !byte $89,%10001011; + !byte $7D,%01001000 + !byte $71,%01000110 + !byte $6F,%00100110 + !byte $6D,%00000110 + !byte $5D,%00100100 + !byte $59,%00000100 + !byte $49,%11000011 + !byte $47,%11000011 + !byte $45,%11000011 + !byte $2F,%01000100 + !byte $17,%10101011 + !byte $25,%11110001 + !byte $BD,%11010011 + !byte $A7,%01010000 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $4B,%11000011 + !byte $43,%11000011 + !byte $35,%00000100 + !byte $23,%00100110 + !byte $1D,%11100111 + !byte $17,%01101010 + !byte $17,%10001011; + !byte $17,%01101100 + !byte $17,%10001101; + !byte $9F,%10101111 + !byte $99,%00001110 + !byte $8F,%00001100 + !byte $85,%00001010 + !byte $7F,%01101000 + !byte $7F,%10001001; + !byte $75,%10100111 + !byte $6B,%11100101 + !byte $55,%11100011 + !byte $4D,%11000011 + !byte $41,%11000011 + !byte $1F,%10100111 + !byte $1D,%00010000 + !byte $B5,%01010010 + !byte $A9,%01110000 + !byte $A9,%10010001; + !byte $77,%11000111 + !byte $69,%11000101 + !byte $61,%01000100 + !byte $39,%11100011 + !byte $31,%00100100 + !byte $1B,%00101000 + !byte $19,%10101001 + !byte $17,%01001010 + !byte $17,%10101101 + !byte $19,%01001110 + !byte $AB,%10110001 + !byte $95,%10101101 + !byte $8B,%10101011 + !byte $4F,%11000011 + !byte $3F,%11000011 + !byte $29,%10100101 + !byte $21,%01000110 + !byte $1B,%11001111 + !byte $B3,%00110010 + !byte $B1,%00010010 + !byte $AD,%11010001 + !byte $A1,%11001111 + !byte $79,%11100111 + !byte $67,%10100101 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $27,%11000101 + !byte $25,%11100101 + !byte $17,%00101010 + !byte $17,%11001101 + !byte $1F,%01010000 + !byte $AF,%11110001 + !byte $9B,%00101110 + !byte $91,%00101100 + !byte $87,%00101010 + !byte $81,%10101001 + !byte $5B,%00000100 + !byte $57,%11100011 + !byte $3D,%11000011 + !byte $37,%11100011 + !byte $33,%00000100 + !byte $2D,%01000100 + !byte $23,%11010001 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $33,%11010011 + !byte $37,%11110011 + !byte $65,%01100100 + !byte $65,%10000101; + !byte $5F,%00100100 + !byte $51,%11000011 + !byte $1D,%11000111 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $17,%00001010 + !byte $BB,%10110011 + !byte $A3,%11101111 + !byte $97,%11001101 + !byte $8D,%11001011 + !byte $7B,%00001000 + !byte $2F,%00100100 + !byte $23,%00000110 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $1B,%00001000 + !byte $9D,%01001110 + !byte $83,%11001001 + !byte $3B,%11000011 + !byte $17,%11101101 + !byte $A5,%00010000 + !byte $93,%01001100 + !byte $89,%01001010 + !byte $7D,%00101000 + !byte $63,%01000100 + !byte $53,%11000011 + !byte $47,%10100011 + !byte $35,%11100011 + !byte $21,%00100110 + !byte $17,%11101001 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $71,%00100110 + !byte $6F,%00000110 + !byte $6D,%11100101 + !byte $59,%11100011 + !byte $49,%10100011 + !byte $45,%10100011 + !byte $43,%10100011 + !byte $31,%00000100 + !byte $19,%01001000 + !byte $B9,%01110010 + !byte $B9,%10010011; + !byte $A7,%00110000 + !byte $9F,%01101110 + !byte $9F,%10001111; + !byte $99,%11101101 + !byte $8F,%11101011 + !byte $85,%11101001 + !byte $73,%01000110 + !byte $5D,%00000100 + !byte $4B,%10100011 + !byte $41,%10100011 + !byte $39,%11000011 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $27,%10100101 + !byte $1D,%10100111 + !byte $BF,%11010011 + !byte $7F,%01001000 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $6B,%11000101 + !byte $55,%11000011 + !byte $4D,%10100011 + !byte $2B,%01000100 + !byte $25,%11000101 + !byte $1B,%11100111 + !byte $17,%11001001 + !byte $17,%00001110 + !byte $21,%10110001 + !byte $A9,%01010000 + !byte $95,%01101100 + !byte $95,%10001101; + !byte $8B,%01101010 + !byte $8B,%10001011; + !byte $77,%10100111 + !byte $69,%10100101 + !byte $61,%00100100 + !byte $3F,%10100011 + !byte $2D,%00100100 + !byte $23,%11100101 + !byte $1F,%01000110 + !byte $B7,%01010010 + !byte $A1,%10101111 + !byte $9B,%00001110 + !byte $81,%01101000 + !byte $81,%10001001; + !byte $4F,%10100011 + !byte $37,%11000011 + !byte $33,%11100011 + !byte $15,%11001011 + !byte $15,%11101011 + !byte $15,%00001100 + !byte $1B,%11101111 + !byte $1D,%00110000 + !byte $AB,%01110000 + !byte $AB,%10010001; + !byte $91,%00001100 + !byte $87,%00001010 + !byte $79,%11000111 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $3D,%10100011 + !byte $19,%00101000 + !byte $15,%10101011 + !byte $15,%00101100 + !byte $B5,%00110010 + !byte $AD,%10110001 + !byte $5B,%11100011 + !byte $2F,%00000100 + !byte $21,%00000110 + !byte $17,%10101001 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $15,%01001100 + !byte $B3,%00010010 + !byte $B1,%11110001 + !byte $AF,%11010001 + !byte $A3,%11001111 + !byte $97,%10101101 + !byte $8D,%10101011 + !byte $7B,%11100111 + !byte $5F,%00000100 + !byte $57,%11000011 + !byte $51,%10100011 + !byte $3B,%10100011 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $1B,%11000111 + !byte $15,%01001010 + !byte $17,%00101110 + !byte $19,%10101111 + !byte $9D,%00101110 + !byte $83,%10101001 + !byte $65,%01000100 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $2F,%10110011 + !byte $BD,%10110011 + !byte $93,%00101100 + !byte $89,%00101010 + !byte $7D,%00001000 + !byte $35,%11000011 + !byte $31,%11100011 + !byte $29,%01000100 + !byte $27,%01100100 + !byte $27,%10000101; + !byte $25,%10100101 + !byte $1F,%00100110 + !byte $19,%00001000 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $15,%00101010 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $A5,%11101111 + !byte $99,%11001101 + !byte $63,%00100100 + !byte $53,%10100011 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $47,%01100010 + !byte $47,%10000011; + !byte $45,%01100010 + !byte $45,%10000011; + !byte $43,%01100010 + !byte $43,%10000011; + !byte $39,%10100011 + !byte $2B,%00100100 + !byte $23,%11000101 + !byte $15,%10101101 + !byte $9F,%01001110 + !byte $8F,%11001011 + !byte $71,%00000110 + !byte $6F,%11100101 + !byte $6D,%11000101 + !byte $59,%11000011 + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $41,%01100010 + !byte $41,%10000011; + !byte $15,%00001010 + !byte $85,%11001001 + !byte $7F,%00101000 + !byte $73,%00100110 + !byte $6B,%10100101 + !byte $5D,%11100011 + !byte $2D,%00000100 + !byte $21,%11100101 + !byte $A7,%00010000 + !byte $95,%01001100 + !byte $8B,%01001010 + !byte $75,%01000110 + !byte $55,%10100011 + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $33,%11000011 + !byte $1D,%01000110 + !byte $1B,%10100111 + !byte $17,%01001000 + !byte $15,%11101001 + !byte $15,%11001101 + !byte $17,%01001110 + !byte $BB,%01110010 + !byte $BB,%10010011; + !byte $A1,%01101110 + !byte $A1,%10001111; + !byte $91,%11101011 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $69,%01100100 + !byte $69,%10000101; + !byte $61,%00000100 + !byte $37,%10100011 + !byte $19,%11100111 + !byte $25,%00010010 + !byte $27,%00110010 + !byte $A9,%00110000 + !byte $9B,%11101101 + !byte $87,%11101001 + !byte $81,%01001000 + !byte $79,%10100111 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $2F,%11100011 + !byte $1F,%00000110 + !byte $1B,%00010000 + !byte $AB,%01010000 + !byte $8D,%01101010 + !byte $8D,%10001011; + !byte $67,%01000100 + !byte $27,%01000100 + !byte $15,%11001001 + !byte $19,%11001111 + !byte $B9,%01010010 + !byte $97,%01101100 + !byte $97,%10001101; + !byte $5B,%11000011 + !byte $51,%01100010 + !byte $51,%10000011; + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $29,%00100100 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $17,%00101000 + !byte $15,%11101101 + !byte $23,%11110001 + !byte $AD,%01110000 + !byte $AD,%10010001; + !byte $A3,%10101111 + !byte $9D,%00001110 + !byte $83,%01101000 + !byte $83,%10001001; + !byte $7B,%11000111 + !byte $5F,%11100011 + !byte $57,%10100011 + !byte $35,%10100011 + !byte $31,%11000011 + !byte $2B,%00000100 + !byte $23,%10100101 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $1D,%01010000 + !byte $29,%01010010 + !byte $B7,%00110010 + !byte $AF,%10110001 + !byte $93,%00001100 + !byte $89,%00001010 + !byte $65,%00100100 + !byte $21,%11000101 + !byte $1D,%00100110 + !byte $19,%11000111 + !byte $15,%10101001 + !byte $B5,%00010010 + !byte $B3,%11110001 + !byte $B1,%11010001 + !byte $A5,%11001111 + !byte $8F,%10101011 + !byte $7D,%11100111 + !byte $47,%01000010 + !byte $45,%01000010 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $2D,%11100011 + !byte $BF,%10110011 + !byte $99,%10101101 + !byte $85,%10101001 + !byte $63,%00000100 + !byte $53,%01100010 + !byte $53,%10000011; + !byte $49,%01000010 + !byte $43,%01000010 + !byte $41,%01000010 + !byte $13,%10101011 + !byte $13,%11001011 + !byte $13,%11101011 + !byte $13,%00001100 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $9F,%00101110 + !byte $8B,%00101010 + !byte $7F,%00001000 + !byte $73,%00000110 + !byte $71,%11100101 + !byte $6F,%11000101 + !byte $6D,%10100101 + !byte $59,%10100011 + !byte $4B,%01000010 + !byte $33,%10100011 + !byte $1F,%11100101 + !byte $17,%00001000 + !byte $13,%01101010 + !byte $13,%10001011; + !byte $13,%00101100 + !byte $15,%00001110 + !byte $21,%11010001 + !byte $A7,%11101111 + !byte $95,%00101100 + !byte $75,%00100110 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $5D,%11000011 + !byte $4D,%01000010 + !byte $3F,%01000010 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $2F,%11000011 + !byte $15,%01101000 + !byte $15,%10001001; + !byte $13,%01001010 + !byte $91,%11001011 + !byte $77,%01000110 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $27,%00100100 + !byte $25,%01000100 + !byte $1B,%01000110 + !byte $19,%10100111 + !byte $13,%00101010 + !byte $13,%01001100 + !byte $A9,%00010000 + !byte $A1,%01001110 + !byte $9B,%11001101 + !byte $87,%11001001 + !byte $81,%00101000 + !byte $69,%01000100 + !byte $61,%11100011 + !byte $3D,%01000010 + !byte $29,%00000100 + !byte $23,%01100100 + !byte $23,%10000101; + !byte $BD,%01110010 + !byte $BD,%10010011; + !byte $8D,%01001010 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $4F,%01000010 + !byte $1D,%00000110 + !byte $17,%11100111 + !byte $15,%01001000 + !byte $13,%00001010 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $97,%01001100 + !byte $67,%00100100 + !byte $3B,%01000010 + !byte $35,%01100010 + !byte $35,%10000011; + !byte $31,%10100011 + !byte $2B,%11100011 + !byte $21,%10100101 + !byte $19,%11101111 + !byte $AB,%00110000 + !byte $A3,%01101110 + !byte $A3,%10001111; + !byte $9D,%11101101 + !byte $93,%11101011 + !byte $83,%01001000 + !byte $7B,%10100111 + !byte $5B,%10100011 + !byte $51,%01000010 + !byte $13,%11101001 + !byte $15,%00101110 + !byte $1B,%00110000 + !byte $1F,%10110001 + !byte $BB,%01010010 + !byte $AD,%01010000 + !byte $89,%11101001 + !byte $5F,%11000011 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $2D,%11000011 + !byte $1F,%11000101 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $13,%10101101 + !byte $17,%10101111 + !byte $99,%01101100 + !byte $99,%10001101; + !byte $8F,%01101010 + !byte $8F,%10001011; + !byte $7D,%11000111 + !byte $65,%00000100 + !byte $39,%01000010 + !byte $1B,%00100110 + !byte $15,%00101000 + !byte $31,%11010011 + !byte $B9,%00110010 + !byte $AF,%01110000 + !byte $AF,%10010001; + !byte $A5,%10101111 + !byte $85,%01101000 + !byte $85,%10001001; + !byte $49,%00100010 + !byte $47,%00100010 + !byte $45,%00100010 + !byte $43,%00100010 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $17,%11000111 + !byte $13,%11001001 + !byte $B7,%00010010 + !byte $B1,%10110001 + !byte $9F,%00001110 + !byte $8B,%00001010 + !byte $6F,%10100101 + !byte $53,%01000010 + !byte $41,%00100010 + !byte $2F,%10100011 + !byte $27,%00000100 + !byte $25,%00100100 + !byte $23,%01000100 + !byte $1D,%11100101 + !byte $35,%11110011 + !byte $B5,%11110001 + !byte $B3,%11010001 + !byte $95,%00001100 + !byte $7F,%11100111 + !byte $73,%11100101 + !byte $71,%11000101 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $63,%11100011 + !byte $4B,%00100010 + !byte $3F,%00100010 + !byte $37,%01000010 + !byte $29,%11100011 + !byte $13,%11001101 + !byte $A7,%11001111 + !byte $9B,%10101101 + !byte $75,%00000110 + !byte $5D,%10100011 + !byte $59,%01100010 + !byte $59,%10000011; + !byte $4D,%00100010 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $15,%00001000 + !byte $13,%10101001 + !byte $15,%01001110 + !byte $A1,%00101110 + !byte $91,%10101011 + !byte $87,%10101001 + !byte $77,%00100110 + !byte $6B,%01000100 + !byte $55,%01000010 + !byte $3D,%00100010 + !byte $2B,%11000011 + !byte $1F,%10100101 + !byte $19,%01000110 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $A9,%11101111 + !byte $8D,%00101010 + !byte $81,%00001000 + !byte $79,%01000110 + !byte $69,%00100100 + !byte $61,%11000011 + !byte $4F,%00100010 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $1B,%00000110 + !byte $17,%10100111 + !byte $97,%00101100 + !byte $3B,%00100010 + !byte $35,%01000010 + !byte $13,%01101000 + !byte $13,%10001001; + !byte $13,%11101101 + !byte $BF,%01110010 + !byte $BF,%10010011; + !byte $9D,%11001101 + !byte $93,%11001011 + !byte $89,%11001001 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $67,%00000100 + !byte $2D,%10100011 + !byte $1D,%11000101 + !byte $11,%01101010 + !byte $11,%10001011; + !byte $11,%10101011 + !byte $11,%11001011 + !byte $11,%11101011 + !byte $AB,%00010000 + !byte $A3,%01001110 + !byte $83,%00101000 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $51,%00100010 + !byte $39,%00100010 + !byte $15,%11100111 + !byte $11,%01001010 + !byte $11,%00001100 + !byte $17,%11001111 + !byte $19,%00010000 + !byte $99,%01001100 + !byte $8F,%01001010 + !byte $57,%01000010 + !byte $27,%11100011 + !byte $25,%00000100 + !byte $23,%00100100 + !byte $13,%01001000 + !byte $11,%00101010 + !byte $11,%00101100 + !byte $AD,%00110000 + !byte $7D,%10100111 + !byte $65,%11100011 + !byte $5F,%10100011 + !byte $47,%00000010 + !byte $45,%00000010 + !byte $43,%00000010 + !byte $33,%01000010 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $29,%11000011 + !byte $21,%01000100 + !byte $19,%00100110 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $11,%00001010 + !byte $2D,%10110011 + !byte $BD,%01010010 + !byte $A5,%01101110 + !byte $A5,%10001111; + !byte $9F,%11101101 + !byte $8B,%11101001 + !byte $85,%01001000 + !byte $49,%00000010 + !byte $41,%00000010 + !byte $37,%00100010 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $1B,%11100101 + !byte $11,%01001100 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $AF,%01010000 + !byte $95,%11101011 + !byte $7F,%11000111 + !byte $71,%10100101 + !byte $53,%00100010 + !byte $4B,%00000010 + !byte $3F,%00000010 + !byte $15,%11000111 + !byte $13,%00101000 + !byte $11,%11101001 + !byte $13,%00001110 + !byte $BB,%00110010 + !byte $B1,%01110000 + !byte $B1,%10010001; + !byte $A7,%10101111 + !byte $91,%01101010 + !byte $91,%10001011; + !byte $75,%11100101 + !byte $73,%11000101 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $6D,%01000100 + !byte $63,%11000011 + !byte $2B,%10100011 + !byte $1B,%01010000 + !byte $23,%00010010 + !byte $B9,%00010010 + !byte $B7,%11110001 + !byte $B3,%10110001 + !byte $9B,%01101100 + !byte $9B,%10001101; + !byte $87,%01101000 + !byte $87,%10001001; + !byte $77,%00000110 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $59,%01000010 + !byte $4D,%00000010 + !byte $3D,%00000010 + !byte $31,%01000010 + !byte $1D,%10100101 + !byte $11,%11001001 + !byte $11,%01101100 + !byte $11,%10001101; + !byte $25,%00110010 + !byte $B5,%11010001 + !byte $A1,%00001110 + !byte $97,%00001100 + !byte $8D,%00001010 + !byte $81,%11100111 + !byte $6B,%00100100 + !byte $55,%00100010 + !byte $35,%00100010 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $19,%00000110 + !byte $17,%01000110 + !byte $21,%11110001 + !byte $A9,%11001111 + !byte $79,%00100110 + !byte $69,%00000100 + !byte $61,%10100011 + !byte $4F,%00000010 + !byte $3B,%00000010 + !byte $25,%11100011 + !byte $23,%00000100 + !byte $13,%00001000 + !byte $9D,%10101101 + !byte $89,%10101001 + !byte $27,%11000011 + !byte $21,%00100100 + !byte $1B,%11000101 + !byte $15,%10100111 + !byte $11,%10101001 + !byte $1F,%11010001 + !byte $A3,%00101110 + !byte $93,%10101011 + !byte $83,%00001000 + !byte $7B,%01000110 + !byte $67,%11100011 + !byte $39,%00000010 + !byte $1F,%01000100 + !byte $11,%10101101 + !byte $13,%00101110 + !byte $27,%01010010 + !byte $AB,%11101111 + !byte $8F,%00101010 + !byte $5B,%01000010 + !byte $51,%00000010 + !byte $33,%00100010 + !byte $2F,%01000010 + !byte $29,%10100011 + !byte $17,%11101111 + !byte $99,%00101100 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $57,%00100010 + !byte $13,%11100111 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $15,%10101111 + !byte $AD,%00010000 + !byte $A5,%01001110 + !byte $9F,%11001101 + !byte $95,%11001011 + !byte $85,%00101000 + !byte $65,%11000011 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $47,%11100001 + !byte $45,%11100001 + !byte $43,%11100001 + !byte $41,%11100001 + !byte $37,%00000010 + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $19,%11100101 + !byte $17,%00100110 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $11,%11001101 + !byte $8B,%11001001 + !byte $7F,%10100111 + !byte $53,%00000010 + !byte $49,%11100001 + !byte $3F,%11100001 + !byte $19,%00110000 + !byte $BF,%01010010 + !byte $AF,%00110000 + !byte $9B,%01001100 + !byte $91,%01001010 + !byte $71,%01100100 + !byte $71,%10000101; + !byte $4B,%11100001 + !byte $31,%00100010 + !byte $11,%01001000 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $0F,%10101011 + !byte $1D,%10110001 + !byte $A7,%01101110 + !byte $A7,%10001111; + !byte $87,%01001000 + !byte $75,%11000101 + !byte $73,%10100101 + !byte $6F,%01000100 + !byte $6D,%00100100 + !byte $63,%10100011 + !byte $3D,%11100001 + !byte $35,%00000010 + !byte $2D,%01000010 + !byte $25,%11000011 + !byte $23,%11100011 + !byte $21,%00000100 + !byte $1B,%10100101 + !byte $0F,%01001010 + !byte $0F,%11001011 + !byte $0F,%11101011 + !byte $BD,%00110010 + !byte $B1,%01010000 + !byte $A1,%11101101 + !byte $97,%11101011 + !byte $8D,%11101001 + !byte $81,%11000111 + !byte $77,%11100101 + !byte $6B,%00000100 + !byte $5D,%01000010 + !byte $59,%00100010 + !byte $4D,%11100001 + !byte $3B,%11100001 + !byte $13,%11000111 + !byte $0F,%00101010 + !byte $13,%01001110 + !byte $BB,%00010010 + !byte $B3,%01110000 + !byte $B3,%10010001; + !byte $27,%10100011 + !byte $1F,%00100100 + !byte $17,%00000110 + !byte $11,%00101000 + !byte $0F,%00001010 + !byte $0F,%00001100 + !byte $29,%01110010 + !byte $29,%10010011; + !byte $B9,%11110001 + !byte $B7,%11010001 + !byte $B5,%10110001 + !byte $A9,%10101111 + !byte $9D,%01101100 + !byte $9D,%10001101; + !byte $93,%01101010 + !byte $93,%10001011; + !byte $79,%00000110 + !byte $69,%11100011 + !byte $55,%00000010 + !byte $4F,%11100001 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $1D,%01000100 + !byte $15,%01000110 + !byte $0F,%11101001 + !byte $11,%11101101 + !byte $A3,%00001110 + !byte $89,%01101000 + !byte $89,%10001001; + !byte $83,%11100111 + !byte $7B,%00100110 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $39,%11100001 + !byte $33,%00000010 + !byte $2F,%00100010 + !byte $19,%11000101 + !byte $0F,%00101100 + !byte $99,%00001100 + !byte $8F,%00001010 + !byte $67,%11000011 + !byte $13,%10100111 + !byte $0F,%11001001 + !byte $AB,%11001111 + !byte $7D,%01000110 + !byte $5B,%00100010 + !byte $51,%11100001 + !byte $2B,%01000010 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $11,%00001000 + !byte $0F,%01001100 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $A5,%00101110 + !byte $9F,%10101101 + !byte $95,%10101011 + !byte $85,%00001000 + !byte $57,%00000010 + !byte $47,%11000001 + !byte $45,%11000001 + !byte $43,%11000001 + !byte $41,%11000001 + !byte $37,%11100001 + !byte $0F,%10101001 + !byte $15,%11001111 + !byte $AD,%11101111 + !byte $8B,%10101001 + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $65,%10100011 + !byte $5F,%01000010 + !byte $49,%11000001 + !byte $3F,%11000001 + !byte $31,%00000010 + !byte $25,%10100011 + !byte $23,%11000011 + !byte $21,%11100011 + !byte $17,%11100101 + !byte $15,%00100110 + !byte $11,%00001110 + !byte $17,%00010000 + !byte $9B,%00101100 + !byte $91,%00101010 + !byte $2D,%00100010 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $1F,%00000100 + !byte $19,%10100101 + !byte $11,%11100111 + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $AF,%00010000 + !byte $A7,%01001110 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $71,%01000100 + !byte $53,%11100001 + !byte $4B,%11000001 + !byte $3D,%11000001 + !byte $35,%11100001 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $13,%01101110 + !byte $13,%10001111; + !byte $2F,%11010011 + !byte $A1,%11001101 + !byte $97,%11001011 + !byte $8D,%11001001 + !byte $87,%00101000 + !byte $75,%10100101 + !byte $6F,%00100100 + !byte $6D,%00000100 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $3B,%11000001 + !byte $1D,%00100100 + !byte $B1,%00110000 + !byte $81,%10100111 + !byte $77,%11000101 + !byte $5D,%00100010 + !byte $59,%00000010 + !byte $4D,%11000001 + !byte $29,%01000010 + !byte $A9,%01101110 + !byte $A9,%10001111; + !byte $9D,%01001100 + !byte $93,%01001010 + !byte $79,%11100101 + !byte $6B,%11100011 + !byte $55,%11100001 + !byte $2F,%00000010 + !byte $1B,%01000100 + !byte $15,%00000110 + !byte $11,%11000111 + !byte $0F,%01001000 + !byte $0F,%10101101 + !byte $33,%11110011 + !byte $BF,%00110010 + !byte $B3,%01010000 + !byte $A3,%11101101 + !byte $89,%01001000 + !byte $83,%11000111 + !byte $69,%11000011 + !byte $61,%01000010 + !byte $4F,%11000001 + !byte $39,%11000001 + !byte $33,%11100001 + !byte $2B,%00100010 + !byte $17,%11000101 + !byte $19,%01010000 + !byte $BD,%00010010 + !byte $B7,%10110001 + !byte $B5,%01110000 + !byte $B5,%10010001; + !byte $99,%11101011 + !byte $8F,%11101001 + !byte $7B,%00000110 + !byte $23,%10100011 + !byte $21,%11000011 + !byte $13,%01000110 + !byte $11,%00101110 + !byte $BB,%11110001 + !byte $B9,%11010001 + !byte $AB,%10101111 + !byte $67,%10100011 + !byte $37,%11000001 + !byte $1F,%11100011 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $0F,%00101000 + !byte $0D,%01001010 + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $0D,%10101011 + !byte $9F,%01101100 + !byte $9F,%10001101; + !byte $95,%01101010 + !byte $95,%10001011; + !byte $8B,%01101000 + !byte $8B,%10001001; + !byte $85,%11100111 + !byte $7D,%00100110 + !byte $51,%11000001 + !byte $45,%10100001 + !byte $43,%10100001 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $1D,%00000100 + !byte $0D,%00001010 + !byte $0D,%00101010 + !byte $0D,%11001011 + !byte $A5,%00001110 + !byte $5B,%00000010 + !byte $57,%11100001 + !byte $47,%10100001 + !byte $41,%10100001 + !byte $3F,%10100001 + !byte $31,%11100001 + !byte $2D,%00000010 + !byte $27,%01000010 + !byte $11,%10100111 + !byte $0D,%11101011 + !byte $0F,%11001101 + !byte $21,%00010010 + !byte $AD,%11001111 + !byte $9B,%00001100 + !byte $91,%00001010 + !byte $7F,%01000110 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $5F,%00100010 + !byte $49,%10100001 + !byte $35,%11000001 + !byte $1B,%00100100 + !byte $15,%11100101 + !byte $13,%00100110 + !byte $0F,%00001000 + !byte $0D,%11101001 + !byte $15,%11101111 + !byte $1F,%11110001 + !byte $23,%00110010 + !byte $2B,%10110011 + !byte $87,%00001000 + !byte $53,%11000001 + !byte $4B,%10100001 + !byte $3D,%10100001 + !byte $29,%00100010 + !byte $17,%10100101 + !byte $0D,%11001001 + !byte $0D,%00001100 + !byte $13,%10101111 + !byte $A7,%00101110 + !byte $A1,%10101101 + !byte $97,%10101011 + !byte $8D,%10101001 + !byte $81,%01100110 + !byte $81,%10000111; + !byte $75,%01100100 + !byte $75,%10000101; + !byte $73,%01000100 + !byte $71,%00100100 + !byte $6F,%00000100 + !byte $3B,%10100001 + !byte $1D,%11010001 + !byte $AF,%11101111 + !byte $6D,%11100011 + !byte $63,%01000010 + !byte $4D,%10100001 + !byte $2F,%11100001 + !byte $19,%01000100 + !byte $11,%01100110 + !byte $11,%10000111; + !byte $0D,%10101001 + !byte $0D,%00101100 + !byte $B1,%00010000 + !byte $9D,%00101100 + !byte $93,%00101010 + !byte $77,%10100101 + !byte $6B,%11000011 + !byte $5D,%00000010 + !byte $59,%11100001 + !byte $39,%10100001 + !byte $33,%11000001 + !byte $2B,%00000010 + !byte $21,%10100011 + !byte $1F,%11000011 + !byte $0F,%11100111 + !byte $0F,%11101101 + !byte $11,%01001110 + !byte $17,%00110000 + !byte $A9,%01001110 + !byte $A3,%11001101 + !byte $89,%00101000 + !byte $83,%10100111 + !byte $79,%11000101 + !byte $55,%11000001 + !byte $25,%01000010 + !byte $23,%01100010 + !byte $23,%10000011; + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $99,%11001011 + !byte $8F,%11001001 + !byte $7B,%11100101 + !byte $69,%10100011 + !byte $4F,%10100001 + !byte $1D,%11100011 + !byte $15,%11000101 + !byte $13,%00000110 + !byte $0D,%01001100 + !byte $25,%01010010 + !byte $B5,%01010000 + !byte $B3,%00110000 + !byte $61,%00100010 + !byte $37,%10100001 + !byte $27,%00100010 + !byte $17,%01100100 + !byte $17,%10000101; + !byte $0F,%11000111 + !byte $1B,%10110001 + !byte $AB,%01101110 + !byte $AB,%10001111; + !byte $9F,%01001100 + !byte $95,%01001010 + !byte $8B,%01001000 + !byte $85,%11000111 + !byte $7D,%00000110 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $31,%11000001 + !byte $2D,%11100001 + !byte $1B,%00000100 + !byte $11,%01000110 + !byte $0D,%01001000 + !byte $BF,%00010010 + !byte $B7,%01110000 + !byte $B7,%10010001; + !byte $A5,%11101101 + !byte $5B,%11100001 + !byte $51,%10100001 + !byte $47,%01100000 + !byte $47,%10000001; + !byte $45,%01100000 + !byte $45,%10000001; + !byte $43,%01100000 + !byte $43,%10000001; + !byte $41,%01100000 + !byte $41,%10000001; + !byte $BD,%11110001 + !byte $BB,%11010001 + !byte $B9,%10110001 + !byte $9B,%11101011 + !byte $91,%11101001 + !byte $7F,%00100110 + !byte $57,%11000001 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $35,%10100001 + !byte $29,%00000010 + !byte $19,%00100100 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $AD,%10101111 + !byte $87,%11100111 + !byte $65,%01000010 + !byte $5F,%00000010 + !byte $49,%01100000 + !byte $49,%10000001; + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $15,%10100101 + !byte $13,%11100101 + !byte $0F,%10100111 + !byte $0D,%00101000 + !byte $0F,%00001110 + !byte $13,%11001111 + !byte $A7,%00001110 + !byte $A1,%01101100 + !byte $A1,%10001101; + !byte $97,%01101010 + !byte $97,%10001011; + !byte $8D,%01101000 + !byte $8D,%10001001; + !byte $53,%10100001 + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $2F,%11000001 + !byte $23,%01000010 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $1F,%10100011 + !byte $AF,%11001111 + !byte $81,%01000110 + !byte $75,%01000100 + !byte $73,%00100100 + !byte $71,%00000100 + !byte $6F,%11100011 + !byte $33,%10100001 + !byte $2B,%11100001 + !byte $1D,%11000011 + !byte $17,%01000100 + !byte $11,%00100110 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $19,%01110000 + !byte $19,%10010001; + !byte $9D,%00001100 + !byte $93,%00001010 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $6D,%11000011 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $39,%01100000 + !byte $39,%10000001; + !byte $25,%00100010 + !byte $1B,%11100011 + !byte $0D,%00001000 + !byte $0B,%00001010 + !byte $0B,%00101010 + !byte $0B,%01001010 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $0B,%10101011 + !byte $0D,%10101101 + !byte $15,%00010000 + !byte $A3,%10101101 + !byte $89,%00001000 + !byte $79,%10100101 + !byte $63,%00100010 + !byte $59,%11000001 + !byte $0B,%11101001 + !byte $B1,%11101111 + !byte $A9,%00101110 + !byte $99,%10101011 + !byte $8F,%10101001 + !byte $83,%01100110 + !byte $83,%10000111; + !byte $6B,%10100011 + !byte $5D,%11100001 + !byte $55,%10100001 + !byte $27,%00000010 + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $0B,%11001011 + !byte $95,%00101010 + !byte $7B,%11000101 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $37,%01100000 + !byte $37,%10000001; + !byte $31,%10100001 + !byte $2D,%11000001 + !byte $19,%00000100 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $13,%11000101 + !byte $11,%00000110 + !byte $0D,%11100111 + !byte $0B,%11001001 + !byte $0B,%11101011 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $B3,%00010000 + !byte $AB,%01001110 + !byte $9F,%00101100 + !byte $61,%00000010 + !byte $29,%11100001 + !byte $0B,%10101001 + !byte $0F,%00101110 + !byte $B5,%00110000 + !byte $A5,%11001101 + !byte $8B,%00101000 + !byte $85,%10100111 + !byte $7D,%11100101 + !byte $67,%01000010 + !byte $45,%01000000 + !byte $43,%01000000 + !byte $41,%01000000 + !byte $35,%01100000 + !byte $35,%10000001; + !byte $0B,%00001100 + !byte $0D,%11001101 + !byte $9B,%11001011 + !byte $91,%11001001 + !byte $51,%01100000 + !byte $51,%10000001; + !byte $47,%01000000 + !byte $3F,%01000000 + !byte $23,%00100010 + !byte $21,%01000010 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $1D,%10100011 + !byte $17,%00100100 + !byte $0F,%01000110 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $B7,%01010000 + !byte $7F,%00000110 + !byte $5B,%11000001 + !byte $57,%10100001 + !byte $49,%01000000 + !byte $3D,%01000000 + !byte $2F,%10100001 + !byte $0D,%11000111 + !byte $17,%01010000 + !byte $BF,%11110001 + !byte $B9,%01110000 + !byte $B9,%10010001; + !byte $AD,%01101110 + !byte $AD,%10001111; + !byte $A1,%01001100 + !byte $97,%01001010 + !byte $8D,%01001000 + !byte $87,%11000111 + !byte $65,%00100010 + !byte $5F,%11100001 + !byte $3B,%01000000 + !byte $2B,%11000001 + !byte $25,%00000010 + !byte $1B,%11000011 + !byte $13,%10100101 + !byte $0B,%00101100 + !byte $BD,%11010001 + !byte $BB,%10110001 + !byte $A7,%11101101 + !byte $93,%11101001 + !byte $81,%00100110 + !byte $53,%01100000 + !byte $53,%10000001; + !byte $4B,%01000000 + !byte $33,%01100000 + !byte $33,%10000001; + !byte $19,%11100011 + !byte $15,%01000100 + !byte $11,%11100101 + !byte $0B,%01001000 + !byte $AF,%10101111 + !byte $9D,%11101011 + !byte $75,%00100100 + !byte $73,%00000100 + !byte $71,%11100011 + !byte $6F,%11000011 + !byte $39,%01000000 + !byte $27,%11100001 + !byte $0D,%10100111 + !byte $11,%10101111 + !byte $13,%11101111 + !byte $89,%11100111 + !byte $77,%01000100 + !byte $6D,%10100011 + !byte $63,%00000010 + !byte $4D,%01000000 + !byte $0F,%00100110 + !byte $0B,%00101000 + !byte $0B,%01001100 + !byte $0D,%11101101 + !byte $2D,%11010011 + !byte $A9,%00001110 + !byte $A3,%01101100 + !byte $A3,%10001101; + !byte $99,%01101010 + !byte $99,%10001011; + !byte $8F,%01101000 + !byte $8F,%10001001; + !byte $83,%01000110 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $59,%10100001 + !byte $37,%01000000 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $2D,%10100001 + !byte $17,%00000100 + !byte $0F,%01001110 + !byte $B1,%11001111 + !byte $5D,%11000001 + !byte $29,%11000001 + !byte $1F,%01000010 + !byte $9F,%00001100 + !byte $95,%00001010 + !byte $8B,%00001000 + !byte $85,%01100110 + !byte $85,%10000111; + !byte $7B,%10100101 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $4F,%01000000 + !byte $21,%00100010 + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $13,%01100100 + !byte $13,%10000101; + !byte $11,%11000101 + !byte $0B,%00001000 + !byte $1F,%00010010 + !byte $B3,%11101111 + !byte $AB,%00101110 + !byte $A5,%10101101 + !byte $7D,%11000101 + !byte $69,%01000010 + !byte $61,%11100001 + !byte $35,%01000000 + !byte $23,%00000010 + !byte $1B,%10100011 + !byte $0F,%00000110 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $15,%00110000 + !byte $1D,%11110001 + !byte $B5,%00010000 + !byte $9B,%10101011 + !byte $91,%10101001 + !byte $67,%00100010 + !byte $45,%00100000 + !byte $43,%00100000 + !byte $41,%00100000 + !byte $3F,%00100000 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $25,%11100001 + !byte $19,%11000011 + !byte $15,%00100100 + !byte $1B,%11010001 + !byte $7F,%11100101 + !byte $51,%01000000 + !byte $47,%00100000 + !byte $3D,%00100000 + !byte $2B,%10100001 + !byte $0B,%11100111 + !byte $09,%11101001 + !byte $09,%00001010 + !byte $09,%00101010 + !byte $09,%01001010 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $21,%00110010 + !byte $31,%11110011 + !byte $B7,%00110000 + !byte $AD,%01001110 + !byte $A1,%00101100 + !byte $97,%00101010 + !byte $8D,%00101000 + !byte $87,%10100111 + !byte $5B,%10100001 + !byte $57,%01100000 + !byte $57,%10000001; + !byte $49,%00100000 + !byte $3B,%00100000 + !byte $33,%01000000 + !byte $0D,%01000110 + !byte $09,%11001001 + !byte $09,%10101011 + !byte $0D,%00001110 + !byte $A7,%11001101 + !byte $93,%11001001 + !byte $65,%00000010 + !byte $5F,%11000001 + !byte $27,%11000001 + !byte $17,%11100011 + !byte $11,%10100101 + !byte $09,%11001011 + !byte $29,%10110011 + !byte $B9,%01010000 + !byte $9D,%11001011 + !byte $81,%00000110 + !byte $4B,%00100000 + !byte $39,%00100000 + !byte $13,%01000100 + !byte $0F,%11100101 + !byte $0B,%11000111 + !byte $09,%10101001 + !byte $0B,%10101101 + !byte $19,%10110001 + !byte $BD,%10110001 + !byte $BB,%01110000 + !byte $BB,%10010001; + !byte $AF,%01101110 + !byte $AF,%10001111; + !byte $A3,%01001100 + !byte $89,%11000111 + !byte $75,%00000100 + !byte $73,%11100011 + !byte $71,%11000011 + !byte $6F,%10100011 + !byte $53,%01000000 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $1F,%00100010 + !byte $1D,%01000010 + !byte $09,%01101000 + !byte $09,%10001001; + !byte $09,%11101011 + !byte $11,%11001111 + !byte $BF,%11010001 + !byte $A9,%11101101 + !byte $99,%01001010 + !byte $8F,%01001000 + !byte $83,%00100110 + !byte $77,%00100100 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $4D,%00100000 + !byte $37,%00100000 + !byte $31,%01000000 + !byte $29,%10100001 + !byte $21,%00000010 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $15,%00000100 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $95,%11101001 + !byte $79,%01000100 + !byte $63,%11100001 + !byte $59,%01100000 + !byte $59,%10000001; + !byte $23,%11100001 + !byte $19,%10100011 + !byte $0D,%00100110 + !byte $09,%01001000 + !byte $23,%01010010 + !byte $B1,%10101111 + !byte $9F,%11101011 + !byte $8B,%11100111 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $6B,%01000010 + !byte $5D,%10100001 + !byte $4F,%00100000 + !byte $0B,%10100111 + !byte $09,%00001100 + !byte $13,%00010000 + !byte $AB,%00001110 + !byte $A5,%01101100 + !byte $A5,%10001101; + !byte $85,%01000110 + !byte $55,%01000000 + !byte $35,%00100000 + !byte $25,%11000001 + !byte $11,%01100100 + !byte $11,%10000101; + !byte $0F,%11000101 + !byte $0B,%11001101 + !byte $B3,%11001111 + !byte $9B,%01101010 + !byte $9B,%10001011; + !byte $91,%01101000 + !byte $91,%10001001; + !byte $7D,%10100101 + !byte $69,%00100010 + !byte $61,%11000001 + !byte $45,%00000000 + !byte $43,%00000000 + !byte $41,%00000000 + !byte $3F,%00000000 + !byte $2F,%01000000 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $17,%11000011 + !byte $13,%00100100 + !byte $09,%00101000 + !byte $0D,%00101110 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $7F,%11000101 + !byte $67,%00000010 + !byte $47,%00000000 + !byte $3D,%00000000 + !byte $27,%10100001 + !byte $09,%00101100 + !byte $B5,%11101111 + !byte $A1,%00001100 + !byte $97,%00001010 + !byte $8D,%00001000 + !byte $87,%01100110 + !byte $87,%10000111; + !byte $51,%00100000 + !byte $3B,%00000000 + !byte $33,%00100000 + !byte $0D,%00000110 + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $09,%00001000 + !byte $AD,%00101110 + !byte $A7,%10101101 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $57,%01000000 + !byte $49,%00000000 + !byte $1F,%00000010 + !byte $1D,%00100010 + !byte $1B,%01000010 + !byte $15,%11100011 + !byte $B7,%00010000 + !byte $9D,%10101011 + !byte $93,%10101001 + !byte $81,%11100101 + !byte $65,%11100001 + !byte $5F,%10100001 + !byte $4B,%00000000 + !byte $39,%00000000 + !byte $2D,%01000000 + !byte $21,%11100001 + !byte $89,%10100111 + !byte $73,%11000011 + !byte $53,%00100000 + !byte $31,%00100000 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $23,%11000001 + !byte $19,%01100010 + !byte $19,%10000011; + !byte $11,%01000100 + !byte $0F,%10100101 + !byte $09,%11100111 + !byte $09,%01001100 + !byte $B9,%00110000 + !byte $AF,%01001110 + !byte $A3,%00101100 + !byte $99,%00101010 + !byte $8F,%00101000 + !byte $83,%00000110 + !byte $77,%00000100 + !byte $75,%11100011 + !byte $71,%10100011 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $37,%00000000 + !byte $13,%00000100 + !byte $0D,%11100101 + !byte $0B,%01000110 + !byte $0B,%11101101 + !byte $0F,%10101111 + !byte $BB,%01010000 + !byte $A9,%11001101 + !byte $9F,%11001011 + !byte $79,%00100100 + !byte $6D,%01000010 + !byte $4D,%00000000 + !byte $25,%10100001 + !byte $17,%10100011 + !byte $07,%00001010 + !byte $07,%00101010 + !byte $15,%01010000 + !byte $BF,%10110001 + !byte $BD,%01110000 + !byte $BD,%10010001; + !byte $B1,%01101110 + !byte $B1,%10001111; + !byte $95,%11001001 + !byte $8B,%11000111 + !byte $7B,%01000100 + !byte $63,%11000001 + !byte $09,%11000111 + !byte $07,%11001001 + !byte $07,%11101001 + !byte $07,%01001010 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $AB,%11101101 + !byte $91,%01001000 + !byte $85,%00100110 + !byte $6B,%00100010 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $59,%01000000 + !byte $4F,%00000000 + !byte $35,%00000000 + !byte $2F,%00100000 + !byte $2B,%01000000 + !byte $15,%11000011 + !byte $07,%10101001 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $0D,%01001110 + !byte $11,%11101111 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $A5,%01001100 + !byte $9B,%01001010 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $55,%00100000 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $1D,%00000010 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $0B,%00100110 + !byte $07,%10101011 + !byte $B3,%10101111 + !byte $97,%11101001 + !byte $69,%00000010 + !byte $33,%00000000 + !byte $1F,%11100001 + !byte $1B,%00100010 + !byte $11,%00100100 + !byte $0D,%11000101 + !byte $09,%10100111 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $A1,%11101011 + !byte $8D,%11100111 + !byte $87,%01000110 + !byte $7F,%10100101 + !byte $61,%10100001 + !byte $21,%11000001 + !byte $19,%01000010 + !byte $13,%11100011 + !byte $07,%01001000 + !byte $07,%11001011 + !byte $B5,%11001111 + !byte $AD,%00001110 + !byte $A7,%01101100 + !byte $A7,%10001101; + !byte $9D,%01101010 + !byte $9D,%10001011; + !byte $93,%01101000 + !byte $93,%10001001; + !byte $67,%11100001 + !byte $51,%00000000 + !byte $2D,%00100000 + !byte $23,%10100001 + !byte $0B,%00001110 + !byte $81,%11000101 + !byte $5B,%01000000 + !byte $57,%00100000 + !byte $29,%01000000 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $0B,%00000110 + !byte $07,%00101000 + !byte $07,%11101011 + !byte $09,%10101101 + !byte $B7,%11101111 + !byte $99,%00001010 + !byte $89,%01100110 + !byte $89,%10000111; + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $31,%00000000 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $13,%00110000 + !byte $AF,%00101110 + !byte $A3,%00001100 + !byte $8F,%00001000 + !byte $75,%11000011 + !byte $73,%10100011 + !byte $65,%11000001 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $15,%10100011 + !byte $11,%00000100 + !byte $0F,%01000100 + !byte $0D,%10100101 + !byte $B9,%00010000 + !byte $A9,%10101101 + !byte $83,%11100101 + !byte $77,%11100011 + !byte $71,%01100010 + !byte $71,%10000011; + !byte $6F,%01000010 + !byte $53,%00000000 + !byte $07,%00001000 + !byte $07,%00001100 + !byte $1B,%11110001 + !byte $1D,%00010010 + !byte $9F,%10101011 + !byte $95,%10101001 + !byte $8B,%10100111 + !byte $79,%00000100 + !byte $6D,%00100010 + !byte $2F,%00000000 + !byte $2B,%00100000 + !byte $1D,%11100001 + !byte $1B,%00000010 + !byte $0B,%11100101 + !byte $19,%11010001 + !byte $BD,%01010000 + !byte $BB,%00110000 + !byte $B1,%01001110 + !byte $A5,%00101100 + !byte $85,%00000110 + !byte $7B,%00100100 + !byte $6B,%00000010 + !byte $63,%10100001 + !byte $59,%00100000 + !byte $27,%01000000 + !byte $1F,%11000001 + !byte $19,%00100010 + !byte $13,%11000011 + !byte $09,%01000110 + !byte $07,%11100111 + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $0F,%11001111 + !byte $BF,%01110000 + !byte $BF,%10010001; + !byte $AB,%11001101 + !byte $9B,%00101010 + !byte $91,%00101000 + !byte $7D,%01000100 + !byte $5D,%01000000 + !byte $21,%10100001 + !byte $07,%00101100 + !byte $09,%11001101 + !byte $2B,%11010011 + !byte $A1,%11001011 + !byte $97,%11001001 + !byte $69,%11100001 + !byte $55,%00000000 + !byte $17,%01000010 + !byte $0F,%00100100 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $B3,%01101110 + !byte $B3,%10001111; + !byte $8D,%11000111 + !byte $87,%00100110 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $61,%01100000 + !byte $61,%10000001; + !byte $2D,%00000000 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $15,%01100010 + !byte $15,%10000011; + !byte $07,%11000111 + !byte $0B,%00101110 + !byte $17,%10110001 + !byte $1F,%00110010 + !byte $A7,%01001100 + !byte $9D,%01001010 + !byte $93,%01001000 + !byte $29,%00100000 + !byte $11,%11100011 + !byte $0B,%11000101 + !byte $09,%00100110 + !byte $B5,%10101111 + !byte $AD,%11101101 + !byte $81,%10100101 + !byte $67,%11000001 + !byte $25,%01000000 + !byte $05,%11101001 + !byte $05,%00001010 + !byte $05,%00101010 + !byte $07,%01001100 + !byte $11,%00010000 + !byte $99,%11101001 + !byte $5B,%00100000 + !byte $13,%10100011 + !byte $07,%10100111 + !byte $05,%10101001 + !byte $05,%11001001 + !byte $05,%01001010 + !byte $B7,%11001111 + !byte $AF,%00001110 + !byte $A3,%11101011 + !byte $8F,%11100111 + !byte $89,%01000110 + !byte $57,%00000000 + !byte $1D,%11000001 + !byte $1B,%11100001 + !byte $19,%00000010 + !byte $05,%01101000 + !byte $05,%10001001; + !byte $05,%01101010 + !byte $05,%10001011; + !byte $27,%10110011 + !byte $A9,%01101100 + !byte $A9,%10001101; + !byte $9F,%01101010 + !byte $9F,%10001011; + !byte $83,%11000101 + !byte $75,%10100011 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $71,%01000010 + !byte $65,%10100001 + !byte $5F,%01000000 + !byte $2B,%00000000 + !byte $27,%00100000 + !byte $1F,%10100001 + !byte $0F,%00000100 + !byte $0D,%01000100 + !byte $09,%00000110 + !byte $09,%11101101 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $2F,%11110011 + !byte $B9,%11101111 + !byte $95,%01101000 + !byte $95,%10001001; + !byte $79,%11100011 + !byte $77,%11000011 + !byte $6F,%00100010 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $17,%00100010 + !byte $0B,%10100101 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $05,%01001000 + !byte $05,%10101011 + !byte $B1,%00101110 + !byte $A5,%00001100 + !byte $9B,%00001010 + !byte $91,%00001000 + !byte $8B,%01100110 + !byte $8B,%10000111; + !byte $6D,%00000010 + !byte $15,%01000010 + !byte $11,%11000011 + !byte $05,%00101000 + !byte $07,%01101100 + !byte $07,%10001101; + !byte $21,%01010010 + !byte $BB,%00010000 + !byte $AB,%10101101 + !byte $85,%11100101 + !byte $7B,%00000100 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $23,%01000000 + !byte $05,%11001011 + !byte $0D,%10101111 + !byte $97,%10101001 + !byte $7D,%00100100 + !byte $6B,%11100001 + !byte $5D,%00100000 + !byte $59,%00000000 + !byte $29,%00000000 + !byte $09,%11100101 + !byte $BD,%00110000 + !byte $B3,%01001110 + !byte $A1,%10101011 + !byte $8D,%10100111 + !byte $69,%11000001 + !byte $13,%01100010 + !byte $13,%10000011; + !byte $0D,%00100100 + !byte $07,%01000110 + !byte $05,%00001000 + !byte $0B,%01001110 + !byte $BF,%01010000 + !byte $AD,%11001101 + !byte $A7,%00101100 + !byte $9D,%00101010 + !byte $93,%00101000 + !byte $87,%00000110 + !byte $7F,%01000100 + !byte $25,%00100000 + !byte $0F,%11100011 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $05,%11101011 + !byte $0F,%11101111 + !byte $13,%01010000 + !byte $61,%01000000 + !byte $1D,%10100001 + !byte $1B,%11000001 + !byte $19,%11100001 + !byte $05,%11100111 + !byte $B5,%01101110 + !byte $B5,%10001111; + !byte $A3,%11001011 + !byte $99,%11001001 + !byte $89,%00100110 + !byte $81,%01100100 + !byte $81,%10000101; + !byte $67,%10100001 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $17,%00000010 + !byte $11,%10100011 + !byte $09,%11000101 + !byte $07,%10101101 + !byte $09,%00001110 + !byte $8F,%11000111 + !byte $5B,%00000000 + !byte $27,%00000000 + !byte $15,%00100010 + !byte $07,%00100110 + !byte $05,%00001100 + !byte $AF,%11101101 + !byte $A9,%01001100 + !byte $9F,%01001010 + !byte $95,%01001000 + !byte $83,%10100101 + !byte $21,%01000000 + !byte $05,%11000111 + !byte $B7,%10101111 + !byte $77,%10100011 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $73,%01000010 + !byte $71,%00100010 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $5F,%00100000 + !byte $0D,%00000100 + !byte $0B,%01000100 + !byte $B9,%11001111 + !byte $A5,%11101011 + !byte $9B,%11101001 + !byte $8B,%01000110 + !byte $79,%11000011 + !byte $6F,%00000010 + !byte $23,%00100000 + !byte $13,%01000010 + !byte $0F,%11000011 + !byte $07,%00000110 + !byte $05,%10100111 + !byte $B1,%00001110 + !byte $AB,%01101100 + !byte $AB,%10001101; + !byte $91,%11100111 + !byte $85,%11000101 + !byte $7B,%11100011 + !byte $6D,%11100001 + !byte $09,%10100101 + !byte $05,%00101100 + !byte $A1,%01101010 + !byte $A1,%10001011; + !byte $97,%01101000 + !byte $97,%10001001; + !byte $63,%01000000 + !byte $19,%11000001 + !byte $03,%10101001 + !byte $03,%11001001 + !byte $03,%11101001 + !byte $03,%00001010 + !byte $11,%00110000 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $BB,%11101111 + !byte $8D,%01100110 + !byte $8D,%10000111; + !byte $7D,%00000100 + !byte $6B,%11000001 + !byte $5D,%00000000 + !byte $25,%00000000 + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $1B,%10100001 + !byte $17,%11100001 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $05,%01100110 + !byte $05,%10000111; + !byte $03,%01101000 + !byte $03,%10001001; + !byte $03,%00101010 + !byte $07,%11001101 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $BD,%00010000 + !byte $B3,%00101110 + !byte $A7,%00001100 + !byte $9D,%00001010 + !byte $93,%00001000 + !byte $87,%11100101 + !byte $1F,%01000000 + !byte $0D,%11100011 + !byte $0B,%00100100 + !byte $03,%01001000 + !byte $03,%01001010 + !byte $BF,%00110000 + !byte $AD,%10101101 + !byte $7F,%00100100 + !byte $69,%10100001 + !byte $15,%00000010 + !byte $07,%11100101 + !byte $03,%01101010 + !byte $03,%10001011; + !byte $05,%01001100 + !byte $09,%00101110 + !byte $0D,%11001111 + !byte $A3,%10101011 + !byte $99,%10101001 + !byte $81,%01000100 + !byte $61,%00100000 + !byte $21,%00100000 + !byte $0F,%10100011 + !byte $09,%01100100 + !byte $09,%10000101; + !byte $03,%00101000 + !byte $B5,%01001110 + !byte $8F,%10100111 + !byte $89,%00000110 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $13,%00100010 + !byte $05,%01000110 + !byte $03,%10101011 + !byte $19,%11110001 + !byte $AF,%11001101 + !byte $A9,%00101100 + !byte $9F,%00101010 + !byte $95,%00101000 + !byte $23,%00000000 + !byte $03,%00001000 + !byte $17,%11010001 + !byte $1B,%00010010 + !byte $B7,%01101110 + !byte $B7,%10001111; + !byte $83,%01100100 + !byte $83,%10000101; + !byte $75,%01000010 + !byte $11,%01000010 + !byte $07,%11000101 + !byte $03,%11001011 + !byte $A5,%11001011 + !byte $9B,%11001001 + !byte $8B,%00100110 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $73,%00100010 + !byte $71,%00000010 + !byte $65,%01000000 + !byte $5F,%00000000 + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $19,%10100001 + !byte $0B,%00000100 + !byte $05,%00100110 + !byte $03,%11100111 + !byte $07,%11101101 + !byte $0F,%00010000 + !byte $15,%10110001 + !byte $B9,%10101111 + !byte $B1,%11101101 + !byte $91,%11000111 + !byte $85,%10100101 + !byte $79,%10100011 + !byte $6F,%11100001 + !byte $1D,%01000000 + !byte $17,%11000001 + !byte $15,%11100001 + !byte $0D,%11000011 + !byte $09,%01000100 + !byte $05,%01101100 + !byte $05,%10001101; + !byte $AB,%01001100 + !byte $A1,%01001010 + !byte $97,%01001000 + !byte $7B,%11000011 + !byte $6D,%11000001 + !byte $1F,%00100000 + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $03,%11000111 + !byte $63,%00100000 + !byte $13,%00000010 + !byte $03,%11101011 + !byte $1D,%00110010 + !byte $BB,%11001111 + !byte $B3,%00001110 + !byte $A7,%11101011 + !byte $9D,%11101001 + !byte $93,%11100111 + !byte $8D,%01000110 + !byte $87,%11000101 + !byte $7D,%11100011 + !byte $6B,%10100001 + !byte $21,%00000000 + !byte $07,%10100101 + !byte $05,%00000110 + !byte $AD,%01101100 + !byte $AD,%10001101; + !byte $7F,%00000100 + !byte $03,%10100111 + !byte $09,%01001110 + !byte $0B,%10101111 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $BD,%11101111 + !byte $A3,%01101010 + !byte $A3,%10001011; + !byte $99,%01101000 + !byte $99,%10001001; + !byte $69,%01100000 + !byte $69,%10000001; + !byte $11,%00100010 + !byte $0D,%10100011 + !byte $0B,%11100011 + !byte $09,%00100100 + !byte $03,%00001100 + !byte $29,%11010011 + !byte $BF,%00010000 + !byte $B5,%00101110 + !byte $8F,%01100110 + !byte $8F,%10000111; + !byte $89,%11100101 + !byte $81,%00100100 + !byte $61,%00000000 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $05,%10101101 + !byte $AF,%10101101 + !byte $A9,%00001100 + !byte $9F,%00001010 + !byte $95,%00001000 + !byte $67,%01000000 + !byte $1B,%01000000 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $17,%10100001 + !byte $07,%01100100 + !byte $07,%10000101; + !byte $05,%11100101 + !byte $07,%00001110 + !byte $83,%01000100 + !byte $1D,%00100000 + !byte $15,%11000001 + !byte $0F,%01000010 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $01,%10101001 + !byte $01,%11001001 + !byte $01,%11101001 + !byte $01,%00001010 + !byte $0D,%11101111 + !byte $B7,%01001110 + !byte $A5,%10101011 + !byte $9B,%10101001 + !byte $8B,%00000110 + !byte $75,%00100010 + !byte $13,%11100001 + !byte $03,%01000110 + !byte $01,%01001000 + !byte $01,%00101010 + !byte $91,%10100111 + !byte $85,%01100100 + !byte $85,%10000101; + !byte $77,%01000010 + !byte $73,%00000010 + !byte $71,%11100001 + !byte $65,%00100000 + !byte $1F,%00000000 + !byte $0B,%11000011 + !byte $01,%00101000 + !byte $01,%01001010 + !byte $03,%00101100 + !byte $11,%01010000 + !byte $B1,%11001101 + !byte $AB,%00101100 + !byte $A1,%00101010 + !byte $97,%00101000 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $6F,%11000001 + !byte $09,%00000100 + !byte $05,%11000101 + !byte $1F,%01010010 + !byte $25,%10110011 + !byte $B9,%01101110 + !byte $B9,%10001111; + !byte $8D,%00100110 + !byte $7B,%10100011 + !byte $6D,%10100001 + !byte $11,%00000010 + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $07,%01000100 + !byte $01,%00001000 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $A7,%11001011 + !byte $9D,%11001001 + !byte $93,%11000111 + !byte $7D,%11000011 + !byte $63,%00000000 + !byte $03,%00100110 + !byte $05,%11001101 + !byte $2D,%11110011 + !byte $BB,%10101111 + !byte $B3,%11101101 + !byte $AD,%01001100 + !byte $99,%01001000 + !byte $87,%10100101 + !byte $7F,%11100011 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $19,%01000000 + !byte $0F,%00100010 + !byte $01,%11100111 + !byte $A3,%01001010 + !byte $1B,%00100000 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $15,%10100001 + !byte $05,%10100101 + !byte $01,%10101011 + !byte $03,%01001100 + !byte $BD,%11001111 + !byte $8F,%01000110 + !byte $81,%00000100 + !byte $69,%01000000 + !byte $1D,%00000000 + !byte $0B,%10100011 + !byte $09,%11100011 + !byte $03,%00000110 + !byte $01,%11000111 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $0F,%00110000 + !byte $B5,%00001110 + !byte $A9,%11101011 + !byte $9F,%11101001 + !byte $95,%11100111 + !byte $89,%11000101 + !byte $13,%11000001 + !byte $07,%00100100 + !byte $01,%11001011 + !byte $07,%00101110 + !byte $BF,%11101111 + !byte $AF,%01101100 + !byte $AF,%10001101; + !byte $11,%11100001 + !byte $0D,%01000010 + !byte $01,%10100111 + !byte $0B,%11001111 + !byte $A5,%01101010 + !byte $A5,%10001011; + !byte $9B,%01101000 + !byte $9B,%10001001; + !byte $83,%00100100 + !byte $67,%00100000 + !byte $05,%01100100 + !byte $05,%10000101; + !byte $B7,%00101110 + !byte $91,%01100110 + !byte $91,%10000111; + !byte $8B,%11100101 + !byte $77,%00100010 + !byte $75,%00000010 + !byte $03,%11100101 + !byte $B1,%10101101 + !byte $AB,%00001100 + !byte $A1,%00001010 + !byte $97,%00001000 + !byte $85,%01000100 + !byte $73,%11100001 + !byte $71,%11000001 + !byte $65,%00000000 + !byte $0F,%00000010 + !byte $09,%11000011 + !byte $01,%01100110 + !byte $01,%10000111; + !byte $01,%11101011 + !byte $03,%01101100 + !byte $03,%10001101; + !byte $05,%11101101 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $79,%01000010 + !byte $6F,%10100001 + !byte $17,%01000000 + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $07,%00000100 + !byte $B9,%01001110 + !byte $A7,%10101011 + !byte $9D,%10101001 + !byte $93,%10100111 + !byte $8D,%00000110 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $1B,%00000000 + !byte $19,%00100000 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $BB,%01101110 + !byte $BB,%10001111; + !byte $B3,%11001101 + !byte $AD,%00101100 + !byte $87,%01100100 + !byte $87,%10000101; + !byte $7D,%10100011 + !byte $13,%10100001 + !byte $0D,%00100010 + !byte $05,%01000100 + !byte $03,%11000101 + !byte $01,%01000110 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $A3,%00101010 + !byte $99,%00101000 + !byte $7F,%11000011 + !byte $6B,%01000000 + !byte $01,%00001100 + !byte $0D,%00010000 + !byte $8F,%00100110 + !byte $11,%11000001 + !byte $15,%11010001 + !byte $17,%11110001 + !byte $BD,%10101111 + !byte $B5,%11101101 + !byte $A9,%11001011 + !byte $9F,%11001001 + !byte $95,%11000111 + !byte $89,%10100101 + !byte $81,%11100011 + !byte $69,%00100000 + !byte $09,%10100011 + !byte $07,%11100011 + !byte $01,%00100110 + !byte $03,%10101101 + !byte $13,%10110001 + !byte $AF,%01001100 + !byte $9B,%01001000 + !byte $0F,%11100001 + !byte $0B,%01000010 + !byte $03,%10100101 + !byte $07,%01001110 + !byte $19,%00010010 + !byte $BF,%11001111 + !byte $A5,%01001010 + !byte $91,%01000110 + !byte $8B,%11000101 + !byte $83,%00000100 + !byte $67,%00000000 + !byte $05,%00100100 + !byte $09,%10101111 + !byte $19,%00000000 + !byte $17,%00100000 + !byte $15,%01000000 + !byte $01,%00000110 + !byte $01,%00101100 + !byte $05,%00001110 + !byte $B7,%00001110 + !byte $B1,%01101100 + !byte $B1,%10001101; + !byte $AB,%11101011 + !byte $A1,%11101001 + !byte $97,%11100111 + !byte $85,%00100100 + !byte $77,%00000010 + !byte $75,%11100001 + !byte $73,%11000001 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $0D,%00000010 + !byte $8D,%11100101 + !byte $79,%00100010 + !byte $71,%10100001 + !byte $11,%10100001 + !byte $07,%11000011 + !byte $03,%01100100 + !byte $03,%10000101; + !byte $11,%01110000 + !byte $11,%10010001; + !byte $B9,%00101110 + !byte $A7,%01101010 + !byte $A7,%10001011; + !byte $9D,%01101000 + !byte $9D,%10001001; + !byte $93,%01100110 + !byte $93,%10000111; + !byte $7B,%01000010 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $09,%01100010 + !byte $09,%10000011; + !byte $01,%11100101 + !byte $1B,%00110010 + !byte $AD,%00001100 + !byte $99,%00001000 + !byte $87,%01000100 + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $6D,%01000000 + !byte $0F,%11000001 + !byte $0B,%00100010 + !byte $05,%00000100 + !byte $0B,%11101111 + !byte $BB,%01001110 + !byte $B3,%10101101 + !byte $A3,%00001010 + !byte $7F,%10100011 + !byte $01,%01001100 + !byte $03,%11001101 + !byte $8F,%00000110 + !byte $6B,%00100000 + !byte $A9,%10101011 + !byte $9F,%10101001 + !byte $95,%10100111 + !byte $89,%01100100 + !byte $89,%10000101; + !byte $81,%11000011 + !byte $0D,%11100001 + !byte $03,%01000100 + !byte $01,%11000101 + !byte $0F,%01010000 + !byte $BD,%01101110 + !byte $BD,%10001111; + !byte $B5,%11001101 + !byte $AF,%00101100 + !byte $9B,%00101000 + !byte $69,%00000000 + !byte $17,%00000000 + !byte $15,%00100000 + !byte $13,%01000000 + !byte $07,%10100011 + !byte $A5,%00101010 + !byte $91,%00100110 + !byte $8B,%10100101 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $09,%01000010 + !byte $05,%11100011 + !byte $27,%11010011 + !byte $BF,%10101111 + !byte $B7,%11101101 + !byte $AB,%11001011 + !byte $83,%11100011 + !byte $05,%00101110 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $B1,%01001100 + !byte $A1,%11001001 + !byte $97,%11000111 + !byte $0F,%10100001 + !byte $0B,%00000010 + !byte $03,%00100100 + !byte $01,%10100101 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $85,%00000100 + !byte $77,%11100001 + !byte $75,%11000001 + !byte $73,%10100001 + !byte $0D,%00110000 + !byte $A7,%01001010 + !byte $9D,%01001000 + !byte $93,%01000110 + !byte $8D,%11000101 + !byte $79,%00000010 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $03,%11101101 + !byte $09,%11001111 + !byte $1D,%01010010 + !byte $B9,%00001110 + !byte $AD,%11101011 + !byte $A3,%11101001 + !byte $87,%00100100 + !byte $7D,%01000010 + !byte $7B,%00100010 + !byte $6F,%01000000 + !byte $0D,%11000001 + !byte $07,%01100010 + !byte $07,%10000011; + !byte $05,%11000011 + !byte $B3,%01101100 + !byte $B3,%10001101; + !byte $99,%11100111 + !byte $6D,%00100000 + !byte $15,%00000000 + !byte $09,%00100010 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $23,%10110011 + !byte $8F,%11100101 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $13,%00100000 + !byte $03,%00000100 + !byte $BB,%00101110 + !byte $A9,%01101010 + !byte $A9,%10001011; + !byte $9F,%01101000 + !byte $9F,%10001001; + !byte $95,%01100110 + !byte $95,%10000111; + !byte $89,%01000100 + !byte $6B,%00000000 + !byte $11,%01000000 + !byte $0B,%11100001 + !byte $B5,%10101101 + !byte $AF,%00001100 + !byte $81,%10100011 + !byte $01,%10101101 + !byte $BD,%01001110 + !byte $A5,%00001010 + !byte $9B,%00001000 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $07,%01000010 + !byte $05,%10100011 + !byte $01,%01000100 + !byte $97,%10100111 + !byte $91,%00000110 + !byte $8B,%01100100 + !byte $8B,%10000101; + !byte $83,%11000011 + !byte $0B,%00010000 + !byte $2B,%11110011 + !byte $BF,%01101110 + !byte $BF,%10001111; + !byte $B1,%00101100 + !byte $AB,%10101011 + !byte $A1,%10101001 + !byte $0D,%10100001 + !byte $09,%00000010 + !byte $03,%11100011 + !byte $05,%01001110 + !byte $B7,%11001101 + !byte $9D,%00101000 + !byte $85,%11100011 + !byte $03,%00001110 + !byte $A7,%00101010 + !byte $93,%00100110 + !byte $8D,%10100101 + !byte $79,%11100001 + !byte $77,%11000001 + !byte $75,%10100001 + !byte $73,%01100000 + !byte $73,%10000001; + !byte $13,%00000000 + !byte $0B,%11000001 + !byte $01,%00100100 + !byte $07,%10101111 + !byte $99,%11000111 + !byte $7B,%00000010 + !byte $71,%01000000 + !byte $11,%00100000 + !byte $13,%11010001 + !byte $B9,%11101101 + !byte $B3,%01001100 + !byte $AD,%11001011 + !byte $A3,%11001001 + !byte $87,%00000100 + !byte $6F,%00100000 + !byte $07,%00100010 + !byte $05,%01100010 + !byte $05,%10000011; + !byte $03,%11000011 + !byte $15,%11110001 + !byte $9F,%01001000 + !byte $95,%01000110 + !byte $8F,%11000101 + !byte $7F,%01000010 + !byte $7D,%00100010 + !byte $6D,%00000000 + !byte $0F,%01000000 + !byte $11,%10110001 + !byte $BB,%00001110 + !byte $A9,%01001010 + !byte $89,%00100100 + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $09,%11100001 + !byte $01,%11001101 + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $B5,%01101100 + !byte $B5,%10001101; + !byte $AF,%11101011 + !byte $9B,%11100111 + !byte $81,%01100010 + !byte $81,%10000011; + !byte $01,%00000100 + !byte $17,%00010010 + !byte $A5,%11101001 + !byte $91,%11100101 + !byte $09,%11101111 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $BD,%00101110 + !byte $A1,%01101000 + !byte $A1,%10001001; + !byte $97,%01100110 + !byte $97,%10000111; + !byte $8B,%01000100 + !byte $83,%10100011 + !byte $0B,%10100001 + !byte $05,%01000010 + !byte $B1,%00001100 + !byte $AB,%01101010 + !byte $AB,%10001011; + !byte $11,%00000000 + !byte $07,%00000010 + !byte $03,%10100011 + !byte $B7,%10101101 + !byte $9D,%00001000 + !byte $01,%11100011 + !byte $BF,%01001110 + !byte $A7,%00001010 + !byte $93,%00000110 + !byte $8D,%01100100 + !byte $8D,%10000101; + !byte $85,%11000011 + !byte $0F,%00100000 + !byte $09,%11000001 + !byte $03,%00101110 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $AD,%10101011 + !byte $99,%10100111 + !byte $79,%11000001 + !byte $77,%10100001 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $73,%01000000 + !byte $71,%00100000 + !byte $0D,%01010000 + !byte $19,%00110010 + !byte $B9,%11001101 + !byte $B3,%00101100 + !byte $A3,%10101001 + !byte $87,%11100011 + !byte $7B,%11100001 + !byte $0D,%01000000 + !byte $01,%11101101 + !byte $9F,%00101000 + !byte $8F,%10100101 + !byte $7D,%00000010 + !byte $6F,%00000000 + !byte $05,%00100010 + !byte $03,%01100010 + !byte $03,%10000011; + !byte $A9,%00101010 + !byte $95,%00100110 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $07,%11100001 + !byte $01,%11000011 + !byte $07,%11001111 + !byte $BB,%11101101 + !byte $AF,%11001011 + !byte $9B,%11000111 + !byte $89,%00000100 + !byte $7F,%00100010 + !byte $B5,%01001100 + !byte $A5,%11001001 + !byte $81,%01000010 + !byte $BD,%00001110 + !byte $A1,%01001000 + !byte $97,%01000110 + !byte $91,%11000101 + !byte $83,%01100010 + !byte $83,%10000011; + !byte $0F,%00000000 + !byte $09,%10100001 + !byte $0B,%00110000 + !byte $AB,%01001010 + !byte $8B,%00100100 + !byte $B7,%01101100 + !byte $B7,%10001101; + !byte $B1,%11101011 + !byte $A7,%11101001 + !byte $9D,%11100111 + !byte $0D,%00100000 + !byte $05,%00000010 + !byte $03,%01000010 + !byte $01,%10100011 + !byte $BF,%00101110 + !byte $93,%11100101 + !byte $8D,%01000100 + !byte $85,%10100011 + !byte $07,%11000001 + !byte $AD,%01101010 + !byte $AD,%10001011; + !byte $99,%01100110 + !byte $99,%10000111; + !byte $75,%01000000 + !byte $0B,%01000000 + !byte $B9,%10101101 + !byte $A3,%01101000 + !byte $A3,%10001001; + !byte $87,%11000011 + !byte $7B,%11000001 + !byte $79,%10100001 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $73,%00100000 + !byte $03,%01001110 + !byte $1B,%01010010 + !byte $25,%11010011 + !byte $B3,%00001100 + !byte $A9,%00001010 + !byte $71,%00000000 + !byte $09,%01100000 + !byte $09,%10000001; + !byte $01,%00001110 + !byte $09,%00010000 + !byte $9F,%00001000 + !byte $95,%00000110 + !byte $8F,%01100100 + !byte $8F,%10000101; + !byte $7D,%11100001 + !byte $03,%00100010 + !byte $BB,%11001101 + !byte $AF,%10101011 + !byte $A5,%10101001 + !byte $9B,%10100111 + !byte $89,%11100011 + !byte $7F,%00000010 + !byte $05,%11100001 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $05,%10101111 + !byte $B5,%00101100 + !byte $81,%00100010 + !byte $0D,%00000000 + !byte $21,%10110011 + !byte $A1,%00101000 + !byte $91,%10100101 + !byte $8B,%00000100 + !byte $07,%10100001 + !byte $BD,%11101101 + !byte $AB,%00101010 + !byte $97,%00100110 + !byte $83,%01000010 + !byte $0B,%00100000 + !byte $B1,%11001011 + !byte $A7,%11001001 + !byte $9D,%11000111 + !byte $B7,%01001100 + !byte $8D,%00100100 + !byte $85,%01100010 + !byte $85,%10000011; + !byte $09,%01000000 + !byte $03,%00000010 + !byte $01,%01000010 + !byte $BF,%00001110 + !byte $AD,%01001010 + !byte $A3,%01001000 + !byte $99,%01000110 + !byte $93,%11000101 + !byte $05,%11000001 + !byte $07,%11101111 + !byte $11,%11010001 + !byte $13,%11110001 + !byte $0F,%10110001 + !byte $B9,%01101100 + !byte $B9,%10001101; + !byte $B3,%11101011 + !byte $9F,%11100111 + !byte $87,%10100011 + !byte $7B,%10100001 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $77,%01000000 + !byte $75,%00100000 + !byte $73,%00000000 + !byte $07,%01100000 + !byte $07,%10000001; + !byte $01,%00101110 + !byte $A9,%11101001 + !byte $95,%11100101 + !byte $8F,%01000100 + !byte $7D,%11000001 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $29,%11110011 + !byte $BB,%10101101 + !byte $AF,%01101010 + !byte $AF,%10001011; + !byte $A5,%01101000 + !byte $A5,%10001001; + !byte $9B,%01100110 + !byte $9B,%10000111; + !byte $89,%11000011 + !byte $7F,%11100001 + !byte $0B,%00000000 + !byte $03,%11100001 + !byte $01,%00100010 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $B5,%00001100 + !byte $15,%00010010 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $AB,%00001010 + !byte $A1,%00001000 + !byte $97,%00000110 + !byte $91,%01100100 + !byte $91,%10000101; + !byte $81,%00000010 + !byte $09,%00100000 + !byte $05,%10100001 + !byte $0B,%01010000 + !byte $8B,%11100011 + !byte $83,%00100010 + !byte $BD,%11001101 + !byte $B1,%10101011 + !byte $A7,%10101001 + !byte $9D,%10100111 + !byte $B7,%00101100 + !byte $93,%10100101 + !byte $8D,%00000100 + !byte $85,%01000010 + !byte $07,%01000000 + !byte $01,%00000010 + !byte $BF,%11101101 + !byte $A3,%00101000 + !byte $03,%11000001 + !byte $05,%11001111 + !byte $B3,%11001011 + !byte $AD,%00101010 + !byte $99,%00100110 + !byte $B9,%01001100 + !byte $A9,%11001001 + !byte $9F,%11000111 + !byte $87,%01100010 + !byte $87,%10000011; + !byte $05,%01100000 + !byte $05,%10000001; + !byte $09,%00110000 + !byte $17,%00110010 + !byte $95,%11000101 + !byte $8F,%00100100 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $79,%01000000 + !byte $77,%00100000 + !byte $75,%00000000 + !byte $09,%00000000 + !byte $AF,%01001010 + !byte $A5,%01001000 + !byte $9B,%01000110 + !byte $89,%10100011 + !byte $7D,%10100001 + !byte $BB,%01101100 + !byte $BB,%10001101; + !byte $B5,%11101011 + !byte $7F,%11000001 + !byte $07,%00100000 + !byte $01,%11100001 + !byte $01,%01001110 + !byte $A1,%11100111 + !byte $91,%01000100 + !byte $03,%10100001 + !byte $AB,%11101001 + !byte $97,%11100101 + !byte $8B,%11000011 + !byte $81,%11100001 + !byte $BD,%10101101 + !byte $B1,%01101010 + !byte $B1,%10001011; + !byte $A7,%01101000 + !byte $A7,%10001001; + !byte $9D,%01100110 + !byte $9D,%10000111; + !byte $83,%00000010 + !byte $05,%01000000 + !byte $B7,%00001100 + !byte $93,%01100100 + !byte $93,%10000101; + !byte $03,%10101111 + !byte $07,%00010000 + !byte $AD,%00001010 + !byte $A3,%00001000 + !byte $99,%00000110 + !byte $8D,%11100011 + !byte $85,%00100010 + !byte $BF,%11001101 + !byte $01,%11000001 + !byte $B9,%00101100 + !byte $B3,%10101011 + !byte $A9,%10101001 + !byte $9F,%10100111 + !byte $87,%01000010 + !byte $07,%00000000 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $95,%10100101 + !byte $8F,%00000100 + !byte $77,%00000000 + !byte $19,%01010010 + !byte $AF,%00101010 + !byte $A5,%00101000 + !byte $9B,%00100110 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $7B,%01000000 + !byte $79,%00100000 + !byte $BB,%01001100 + !byte $B5,%11001011 + !byte $A1,%11000111 + !byte $89,%01100010 + !byte $89,%10000011; + !byte $05,%00100000 + !byte $AB,%11001001 + !byte $97,%11000101 + !byte $91,%00100100 + !byte $7F,%10100001 + !byte $05,%11101111 + !byte $23,%11010011 + !byte $8B,%10100011 + !byte $81,%11000001 + !byte $01,%10100001 + !byte $BD,%01101100 + !byte $BD,%10001101; + !byte $B1,%01001010 + !byte $A7,%01001000 + !byte $9D,%01000110 + !byte $B7,%11101011 + !byte $93,%01000100 + !byte $83,%11100001 + !byte $03,%01000000 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $0D,%10110001 + !byte $0F,%11010001 + !byte $1F,%10110011 + !byte $AD,%11101001 + !byte $A3,%11100111 + !byte $99,%11100101 + !byte $8D,%11000011 + !byte $85,%00000010 + !byte $11,%11110001 + !byte $BF,%10101101 + !byte $05,%00000000 + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $B9,%00001100 + !byte $B3,%01101010 + !byte $B3,%10001011; + !byte $A9,%01101000 + !byte $A9,%10001001; + !byte $9F,%01100110 + !byte $9F,%10000111; + !byte $95,%01100100 + !byte $95,%10000101; + !byte $8F,%11100011 + !byte $87,%00100010 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $AF,%00001010 + !byte $A5,%00001000 + !byte $9B,%00000110 + !byte $79,%00000000 + !byte $03,%11001111 + !byte $BB,%00101100 + !byte $B5,%10101011 + !byte $89,%01000010 + !byte $7D,%01000000 + !byte $7B,%00100000 + !byte $03,%00100000 + !byte $09,%01010000 + !byte $AB,%10101001 + !byte $A1,%10100111 + !byte $91,%00000100 + !byte $13,%00010010 + !byte $97,%10100101 + !byte $81,%10100001 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $B1,%00101010 + !byte $A7,%00101000 + !byte $9D,%00100110 + !byte $8B,%01100010 + !byte $8B,%10000011; + !byte $BD,%01001100 + !byte $B7,%11001011 + !byte $A3,%11000111 + !byte $93,%00100100 + !byte $83,%11000001 + !byte $01,%01000000 + !byte $AD,%11001001 + !byte $99,%11000101 + !byte $07,%00110000 + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $27,%11110011 + !byte $B3,%01001010 + !byte $8D,%10100011 + !byte $85,%11100001 + !byte $03,%00000000 + !byte $BF,%01101100 + !byte $BF,%10001101; + !byte $A9,%01001000 + !byte $9F,%01000110 + !byte $B9,%11101011 + !byte $9B,%11100101 + !byte $95,%01000100 + !byte $87,%00000010 + !byte $AF,%11101001 + !byte $A5,%11100111 + !byte $8F,%11000011 + !byte $01,%10101111 + !byte $15,%00110010 + !byte $B5,%01101010 + !byte $B5,%10001011; + !byte $89,%00100010 + !byte $7B,%00000000 + !byte $01,%00100000 + !byte $BB,%00001100 + !byte $AB,%01101000 + !byte $AB,%10001001; + !byte $A1,%01100110 + !byte $A1,%10000111; + !byte $91,%11100011 + !byte $7D,%00100000 + !byte $05,%00010000 + !byte $9D,%00000110 + !byte $97,%01100100 + !byte $97,%10000101; + !byte $7F,%01000000 + !byte $B1,%00001010 + !byte $A7,%00001000 + !byte $8B,%01000010 + !byte $81,%01100000 + !byte $81,%10000001; + !byte $B7,%10101011 + !byte $93,%00000100 + !byte $83,%10100001 + !byte $BD,%00101100 + !byte $AD,%10101001 + !byte $A3,%10100111 + !byte $9F,%00100110 + !byte $99,%10100101 + !byte $8D,%01100010 + !byte $8D,%10000011; + !byte $01,%00000000 + !byte $BF,%01001100 + !byte $B3,%00101010 + !byte $A9,%00101000 + !byte $85,%11000001 + !byte $03,%11101111 + !byte $B9,%11001011 + !byte $AF,%11001001 + !byte $95,%00100100 + !byte $8F,%10100011 + !byte $A5,%11000111 + !byte $9B,%11000101 + !byte $87,%11100001 + !byte $B5,%01001010 + !byte $A1,%01000110 + !byte $89,%00000010 + !byte $17,%01010010 + !byte $BB,%11101011 + !byte $AB,%01001000 + !byte $97,%01000100 + !byte $91,%11000011 + !byte $7D,%00000000 + !byte $B1,%11101001 + !byte $A7,%11100111 + !byte $9D,%11100101 + !byte $7F,%00100000 + !byte $0B,%10110001 + !byte $B7,%01101010 + !byte $B7,%10001011; + !byte $8B,%00100010 + !byte $81,%01000000 + !byte $09,%01110000 + !byte $09,%10010001; + !byte $0D,%11010001 + !byte $BD,%00001100 + !byte $AD,%01101000 + !byte $AD,%10001001; + !byte $A3,%01100110 + !byte $A3,%10000111; + !byte $99,%01100100 + !byte $99,%10000101; + !byte $93,%11100011 + !byte $01,%11001111 + !byte $A9,%00001000 + !byte $9F,%00000110 + !byte $8D,%01000010 + !byte $83,%01100000 + !byte $83,%10000001; + !byte $0F,%11110001 + !byte $B3,%00001010 + !byte $85,%10100001 + !byte $07,%01010000 + !byte $21,%11010011 + !byte $BF,%00101100 + !byte $B9,%10101011 + !byte $AF,%10101001 + !byte $9B,%10100101 + !byte $95,%00000100 + !byte $1D,%10110011 + !byte $A5,%10100111 + !byte $8F,%01100010 + !byte $8F,%10000011; + !byte $87,%11000001 + !byte $A1,%00100110 + !byte $BB,%11001011 + !byte $B5,%00101010 + !byte $AB,%00101000 + !byte $97,%00100100 + !byte $89,%11100001 + !byte $11,%00010010 + !byte $A7,%11000111 + !byte $9D,%11000101 + !byte $91,%10100011 + !byte $05,%00110000 + !byte $B1,%11001001 + !byte $B7,%01001010 + !byte $A3,%01000110 + !byte $8B,%00000010 + !byte $7F,%00000000 + !byte $BD,%11101011 + !byte $AD,%01001000 + !byte $99,%01000100 + !byte $93,%11000011 + !byte $81,%00100000 + !byte $8D,%00100010 + !byte $83,%01000000 + !byte $B3,%11101001 + !byte $A9,%11100111 + !byte $9F,%11100101 + !byte $85,%01100000 + !byte $85,%10000001; + !byte $03,%00010000 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $BF,%00001100 + !byte $B9,%01101010 + !byte $B9,%10001011; + !byte $AF,%01101000 + !byte $AF,%10001001; + !byte $A5,%01100110 + !byte $A5,%10000111; + !byte $9B,%01100100 + !byte $9B,%10000101; + !byte $95,%11100011 + !byte $8F,%01000010 + !byte $87,%10100001 + !byte $B5,%00001010 + !byte $AB,%00001000 + !byte $A1,%00000110 + !byte $13,%00110010 + !byte $BB,%10101011 + !byte $89,%11000001 + !byte $A7,%10100111 + !byte $97,%00000100 + !byte $91,%01100010 + !byte $91,%10000011; + !byte $25,%11110011 + !byte $B1,%10101001 + !byte $9D,%10100101 + !byte $A3,%00100110 + !byte $8B,%11100001 + !byte $01,%11101111 + !byte $BD,%11001011 + !byte $B7,%00101010 + !byte $AD,%00101000 + !byte $99,%00100100 + !byte $93,%10100011 + !byte $B3,%11001001 + !byte $A9,%11000111 + !byte $9F,%11000101 + !byte $8D,%00000010 + !byte $81,%00000000 + !byte $83,%00100000 + !byte $B9,%01001010 + !byte $AF,%01001000 + !byte $A5,%01000110 + !byte $95,%11000011 + !byte $BF,%11101011 + !byte $9B,%01000100 + !byte $8F,%00100010 + !byte $85,%01000000 + !byte $AB,%11100111 + !byte $A1,%11100101 + !byte $87,%01100000 + !byte $87,%10000001; + !byte $BB,%01101010 + !byte $BB,%10001011; + !byte $B5,%11101001 + !byte $09,%10110001 + !byte $A7,%01100110 + !byte $A7,%10000111; + !byte $9D,%01100100 + !byte $9D,%10000101; + !byte $97,%11100011 + !byte $91,%01000010 + !byte $89,%10100001 + !byte $07,%01110000 + !byte $07,%10010001; + !byte $B1,%01101000 + !byte $B1,%10001001; + !byte $0B,%11010001 + !byte $15,%01010010 + !byte $B7,%00001010 + !byte $AD,%00001000 + !byte $A3,%00000110 + !byte $8B,%11000001 + !byte $99,%00000100 + !byte $05,%01010000 + !byte $BD,%10101011 + !byte $B3,%10101001 + !byte $A9,%10100111 + !byte $9F,%10100101 + !byte $93,%01100010 + !byte $93,%10000011; + !byte $0D,%11110001 + !byte $8D,%11100001 + !byte $83,%00000000 + !byte $B9,%00101010 + !byte $A5,%00100110 + !byte $95,%10100011 + !byte $BF,%11001011 + !byte $AF,%00101000 + !byte $9B,%00100100 + !byte $85,%00100000 + !byte $03,%00110000 + !byte $A1,%11000101 + !byte $8F,%00000010 + !byte $BB,%01001010 + !byte $B5,%11001001 + !byte $AB,%11000111 + !byte $87,%01000000 + !byte $B1,%01001000 + !byte $A7,%01000110 + !byte $9D,%01000100 + !byte $97,%11000011 + !byte $1B,%10110011 + !byte $91,%00100010 + !byte $89,%01100000 + !byte $89,%10000001; + !byte $0F,%00010010 + !byte $1F,%11010011 + !byte $B7,%11101001 + !byte $AD,%11100111 + !byte $A3,%11100101 + !byte $01,%00010000 + !byte $99,%11100011 + !byte $93,%01000010 + !byte $8B,%10100001 + !byte $BD,%01101010 + !byte $BD,%10001011; + !byte $B3,%01101000 + !byte $B3,%10001001; + !byte $A9,%01100110 + !byte $A9,%10000111; + !byte $9F,%01100100 + !byte $9F,%10000101; + !byte $8D,%11000001 + !byte $B9,%00001010 + !byte $AF,%00001000 + !byte $A5,%00000110 + !byte $BF,%10101011 + !byte $9B,%00000100 + !byte $95,%01100010 + !byte $95,%10000011; + !byte $B5,%10101001 + !byte $AB,%10100111 + !byte $A1,%10100101 + !byte $8F,%11100001 + !byte $85,%00000000 + !byte $A7,%00100110 + !byte $87,%00100000 + !byte $BB,%00101010 + !byte $B1,%00101000 + !byte $9D,%00100100 + !byte $97,%10100011 + !byte $91,%00000010 + !byte $11,%00110010 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $A3,%11000101 + !byte $89,%01000000 + !byte $AD,%11000111 + !byte $BD,%01001010 + !byte $B7,%11001001 + !byte $99,%11000011 + !byte $8B,%01100000 + !byte $8B,%10000001; + !byte $B3,%01001000 + !byte $A9,%01000110 + !byte $9F,%01000100 + !byte $93,%00100010 + !byte $8D,%10100001 + !byte $B9,%11101001 + !byte $A5,%11100101 + !byte $95,%01000010 + !byte $BF,%01101010 + !byte $BF,%10001011; + !byte $AF,%11100111 + !byte $9B,%11100011 + !byte $23,%11110011 + !byte $B5,%01101000 + !byte $B5,%10001001; + !byte $AB,%01100110 + !byte $AB,%10000111; + !byte $A1,%01100100 + !byte $A1,%10000101; + !byte $BB,%00001010 + !byte $8F,%11000001 + !byte $07,%10110001 + !byte $B1,%00001000 + !byte $A7,%00000110 + !byte $9D,%00000100 + !byte $97,%01100010 + !byte $97,%10000011; + !byte $87,%00000000 + !byte $05,%01110000 + !byte $05,%10010001; + !byte $91,%11100001 + !byte $89,%00100000 + !byte $09,%11010001 + !byte $AD,%10100111 + !byte $A3,%10100101 + !byte $03,%01010000 + !byte $BD,%00101010 + !byte $B7,%10101001 + !byte $B3,%00101000 + !byte $A9,%00100110 + !byte $9F,%00100100 + !byte $99,%10100011 + !byte $93,%00000010 + !byte $8B,%01000000 + !byte $13,%01010010 + !byte $01,%00110000 + !byte $0B,%11110001 + !byte $B9,%11001001 + !byte $AF,%11000111 + !byte $A5,%11000101 + !byte $8D,%01100000 + !byte $8D,%10000001; + !byte $BF,%01001010 + !byte $9B,%11000011 + !byte $95,%00100010 + !byte $B5,%01001000 + !byte $AB,%01000110 + !byte $A1,%01000100 + !byte $8F,%10100001 + !byte $BB,%11101001 + !byte $B1,%11100111 + !byte $A7,%11100101 + !byte $9D,%11100011 + !byte $97,%01000010 + !byte $91,%11000001 + !byte $B7,%01101000 + !byte $B7,%10001001; + !byte $AD,%01100110 + !byte $AD,%10000111; + !byte $A3,%01100100 + !byte $A3,%10000101; + !byte $89,%00000000 + !byte $0D,%00010010 + !byte $BD,%00001010 + !byte $99,%01100010 + !byte $99,%10000011; + !byte $B3,%00001000 + !byte $A9,%00000110 + !byte $9F,%00000100 + !byte $93,%11100001 + !byte $8B,%00100000 + !byte $A5,%10100101 + !byte $19,%10110011 + !byte $B9,%10101001 + !byte $AF,%10100111 + !byte $9B,%10100011 + !byte $8D,%01000000 + !byte $BF,%00101010 + !byte $A1,%00100100 + !byte $95,%00000010 + !byte $1D,%11010011 + !byte $B5,%00101000 + !byte $AB,%00100110 + !byte $B1,%11000111 + !byte $A7,%11000101 + !byte $8F,%01100000 + !byte $8F,%10000001; + !byte $BB,%11001001 + !byte $9D,%11000011 + !byte $97,%00100010 + !byte $A3,%01000100 + !byte $B7,%01001000 + !byte $AD,%01000110 + !byte $91,%10100001 + !byte $A9,%11100101 + !byte $0F,%00110010 + !byte $15,%01110010 + !byte $15,%10010011; + !byte $BD,%11101001 + !byte $B3,%11100111 + !byte $9F,%11100011 + !byte $99,%01000010 + !byte $93,%11000001 + !byte $8B,%00000000 + !byte $AF,%01100110 + !byte $AF,%10000111; + !byte $A5,%01100100 + !byte $A5,%10000101; + !byte $B9,%01101000 + !byte $B9,%10001001; + !byte $A1,%00000100 + !byte $9B,%01100010 + !byte $9B,%10000011; + !byte $95,%11100001 + !byte $8D,%00100000 + !byte $BF,%00001010 + !byte $B5,%00001000 + !byte $AB,%00000110 + !byte $03,%01110000 + !byte $03,%10010001; + !byte $05,%10110001 + !byte $01,%01010000 + !byte $BB,%10101001 + !byte $B1,%10100111 + !byte $A7,%10100101 + !byte $97,%00000010 + !byte $8F,%01000000 + !byte $9D,%10100011 + !byte $07,%11010001 + !byte $B7,%00101000 + !byte $AD,%00100110 + !byte $A3,%00100100 + !byte $91,%01100000 + !byte $91,%10000001; + !byte $BD,%11001001 + !byte $B3,%11000111 + !byte $A9,%11000101 + !byte $9F,%11000011 + !byte $99,%00100010 + !byte $21,%11110011 + !byte $B9,%01001000 + !byte $AF,%01000110 + !byte $93,%10100001 + !byte $A5,%01000100 + !byte $09,%11110001 + !byte $11,%01010010 + !byte $BF,%11101001 + !byte $AB,%11100101 + !byte $A1,%11100011 + !byte $9B,%01000010 + !byte $B5,%11100111 + !byte $95,%11000001 + !byte $8D,%00000000 + !byte $A7,%01100100 + !byte $A7,%10000101; + !byte $BB,%01101000 + !byte $BB,%10001001; + !byte $B1,%01100110 + !byte $B1,%10000111; + !byte $8F,%00100000 + !byte $9D,%01100010 + !byte $9D,%10000011; + !byte $97,%11100001 + !byte $B7,%00001000 + !byte $AD,%00000110 + !byte $A3,%00000100 + !byte $91,%01000000 + !byte $0B,%00010010 + !byte $A9,%10100101 + !byte $BD,%10101001 + !byte $B3,%10100111 + !byte $9F,%10100011 + !byte $99,%00000010 + !byte $AF,%00100110 + !byte $93,%01100000 + !byte $93,%10000001; + !byte $B9,%00101000 + !byte $A5,%00100100 + !byte $BF,%11001001 + !byte $B5,%11000111 + !byte $A1,%11000011 + !byte $9B,%00100010 + !byte $AB,%11000101 + !byte $95,%10100001 + !byte $BB,%01001000 + !byte $B1,%01000110 + !byte $A7,%01000100 + !byte $9D,%01000010 + !byte $8F,%00000000 + !byte $17,%10110011 + !byte $AD,%11100101 + !byte $97,%11000001 + !byte $B7,%11100111 + !byte $A3,%11100011 + !byte $1B,%11010011 + !byte $99,%11100001 + !byte $91,%00100000 + !byte $BD,%01101000 + !byte $BD,%10001001; + !byte $B3,%01100110 + !byte $B3,%10000111; + !byte $A9,%01100100 + !byte $A9,%10000101; + !byte $9F,%01100010 + !byte $9F,%10000011; + !byte $0D,%00110010 + !byte $B9,%00001000 + !byte $A5,%00000100 + !byte $AF,%00000110 + !byte $93,%01000000 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $BF,%10101001 + !byte $AB,%10100101 + !byte $9B,%00000010 + !byte $B5,%10100111 + !byte $A1,%10100011 + !byte $95,%01100000 + !byte $95,%10000001; + !byte $01,%01110000 + !byte $01,%10010001; + !byte $B1,%00100110 + !byte $A7,%00100100 + !byte $03,%10110001 + !byte $BB,%00101000 + !byte $97,%10100001 + !byte $B7,%11000111 + !byte $A3,%11000011 + !byte $9D,%00100010 + !byte $05,%11010001 + !byte $AD,%11000101 + !byte $BD,%01001000 + !byte $A9,%01000100 + !byte $91,%00000000 + !byte $B3,%01000110 + !byte $9F,%01000010 + !byte $99,%11000001 + !byte $AF,%11100101 + !byte $A5,%11100011 + !byte $B9,%11100111 + !byte $93,%00100000 + !byte $BF,%01101000 + !byte $BF,%10001001; + !byte $B5,%01100110 + !byte $B5,%10000111; + !byte $AB,%01100100 + !byte $AB,%10000101; + !byte $07,%11110001 + !byte $A1,%01100010 + !byte $A1,%10000011; + !byte $9B,%11100001 + !byte $95,%01000000 + !byte $BB,%00001000 + !byte $B1,%00000110 + !byte $A7,%00000100 + !byte $AD,%10100101 + !byte $9D,%00000010 + !byte $0F,%01010010 + !byte $B7,%10100111 + !byte $A3,%10100011 + !byte $97,%01100000 + !byte $97,%10000001; + !byte $1F,%11110011 + !byte $A9,%00100100 + !byte $BD,%00101000 + !byte $B3,%00100110 + !byte $B9,%11000111 + !byte $AF,%11000101 + !byte $A5,%11000011 + !byte $9F,%00100010 + !byte $99,%10100001 + !byte $09,%00010010 + !byte $93,%00000000 + !byte $B5,%01000110 + !byte $AB,%01000100 + !byte $9B,%11000001 + !byte $BF,%01001000 + !byte $A1,%01000010 + !byte $95,%00100000 + !byte $A7,%11100011 + !byte $BB,%11100111 + !byte $B1,%11100101 + !byte $B7,%01100110 + !byte $B7,%10000111; + !byte $AD,%01100100 + !byte $AD,%10000101; + !byte $A3,%01100010 + !byte $A3,%10000011; + !byte $9D,%11100001 + !byte $97,%01000000 + !byte $A9,%00000100 + !byte $BD,%00001000 + !byte $B3,%00000110 + !byte $9F,%00000010 + !byte $B9,%10100111 + !byte $AF,%10100101 + !byte $99,%01100000 + !byte $99,%10000001; + !byte $15,%10110011 + !byte $A5,%10100011 + !byte $BF,%00101000 + !byte $B5,%00100110 + !byte $AB,%00100100 + !byte $0B,%00110010 + !byte $B1,%11000101 + !byte $A1,%00100010 + !byte $9B,%10100001 + !byte $BB,%11000111 + !byte $A7,%11000011 + !byte $95,%00000000 + !byte $01,%10110001 + !byte $19,%11010011 + !byte $9D,%11000001 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $B7,%01000110 + !byte $AD,%01000100 + !byte $A9,%11100011 + !byte $A3,%01000010 + !byte $97,%00100000 + !byte $03,%11010001 + !byte $B3,%11100101 + !byte $BD,%11100111 + !byte $99,%01000000 + !byte $B9,%01100110 + !byte $B9,%10000111; + !byte $AF,%01100100 + !byte $AF,%10000101; + !byte $A5,%01100010 + !byte $A5,%10000011; + !byte $9F,%11100001 + !byte $AB,%00000100 + !byte $B5,%00000110 + !byte $05,%11110001 + !byte $BF,%00001000 + !byte $A1,%00000010 + !byte $9B,%01100000 + !byte $9B,%10000001; + !byte $BB,%10100111 + !byte $B1,%10100101 + !byte $A7,%10100011 + !byte $AD,%00100100 + !byte $B7,%00100110 + !byte $A3,%00100010 + !byte $9D,%10100001 + !byte $A9,%11000011 + !byte $97,%00000000 + !byte $BD,%11000111 + !byte $B3,%11000101 + !byte $0D,%01010010 + !byte $AF,%01000100 + !byte $9F,%11000001 + !byte $99,%00100000 + !byte $B9,%01000110 + !byte $A5,%01000010 + !byte $07,%00010010 + !byte $AB,%11100011 + !byte $BF,%11100111 + !byte $B5,%11100101 + !byte $B1,%01100100 + !byte $B1,%10000101; + !byte $A7,%01100010 + !byte $A7,%10000011; + !byte $A1,%11100001 + !byte $9B,%01000000 + !byte $BB,%01100110 + !byte $BB,%10000111; + !byte $1D,%11110011 + !byte $AD,%00000100 + !byte $B7,%00000110 + !byte $B3,%10100101 + !byte $A9,%10100011 + !byte $A3,%00000010 + !byte $9D,%01100000 + !byte $9D,%10000001; + !byte $BD,%10100111 + !byte $AF,%00100100 + !byte $B9,%00100110 + !byte $A5,%00100010 + !byte $9F,%10100001 + !byte $99,%00000000 + !byte $BF,%11000111 + !byte $B5,%11000101 + !byte $AB,%11000011 + !byte $B1,%01000100 + !byte $A1,%11000001 + !byte $9B,%00100000 + !byte $BB,%01000110 + !byte $A7,%01000010 + !byte $09,%00110010 + !byte $AD,%11100011 + !byte $13,%10110011 + !byte $B7,%11100101 + !byte $A3,%11100001 + !byte $01,%11010001 + !byte $9D,%01000000 + !byte $BD,%01100110 + !byte $BD,%10000111; + !byte $B3,%01100100 + !byte $B3,%10000101; + !byte $A9,%01100010 + !byte $A9,%10000011; + !byte $AF,%00000100 + !byte $17,%11010011 + !byte $B9,%00000110 + !byte $A5,%00000010 + !byte $9F,%01100000 + !byte $9F,%10000001; + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $BF,%10100111 + !byte $AB,%10100011 + !byte $B5,%10100101 + !byte $9B,%00000000 + !byte $BB,%00100110 + !byte $B1,%00100100 + !byte $A7,%00100010 + !byte $A1,%10100001 + !byte $03,%11110001 + !byte $AD,%11000011 + !byte $B7,%11000101 + !byte $9D,%00100000 + !byte $A3,%11000001 + !byte $BD,%01000110 + !byte $B3,%01000100 + !byte $A9,%01000010 + !byte $B9,%11100101 + !byte $AF,%11100011 + !byte $A5,%11100001 + !byte $9F,%01000000 + !byte $BF,%01100110 + !byte $BF,%10000111; + !byte $B5,%01100100 + !byte $B5,%10000101; + !byte $0B,%01010010 + !byte $AB,%01100010 + !byte $AB,%10000011; + !byte $A7,%00000010 + !byte $A1,%01100000 + !byte $A1,%10000001; + !byte $05,%00010010 + !byte $BB,%00000110 + !byte $B1,%00000100 + !byte $B7,%10100101 + !byte $AD,%10100011 + !byte $A3,%10100001 + !byte $9D,%00000000 + !byte $B3,%00100100 + !byte $A9,%00100010 + !byte $BD,%00100110 + !byte $AF,%11000011 + !byte $9F,%00100000 + !byte $B9,%11000101 + !byte $A5,%11000001 + !byte $1B,%11110011 + !byte $BF,%01000110 + !byte $B5,%01000100 + !byte $AB,%01000010 + !byte $BB,%11100101 + !byte $A1,%01000000 + !byte $B1,%11100011 + !byte $A7,%11100001 + !byte $AD,%01100010 + !byte $AD,%10000011; + !byte $B7,%01100100 + !byte $B7,%10000101; + !byte $B3,%00000100 + !byte $A9,%00000010 + !byte $A3,%01100000 + !byte $A3,%10000001; + !byte $07,%00110010 + !byte $BD,%00000110 + !byte $B9,%10100101 + !byte $AF,%10100011 + !byte $9F,%00000000 + !byte $11,%10110011 + !byte $BF,%00100110 + !byte $AB,%00100010 + !byte $A5,%10100001 + !byte $B5,%00100100 + !byte $B1,%11000011 + !byte $A7,%11000001 + !byte $A1,%00100000 + !byte $BB,%11000101 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $B7,%01000100 + !byte $01,%11110001 + !byte $15,%11010011 + !byte $B3,%11100011 + !byte $AD,%01000010 + !byte $BD,%11100101 + !byte $A3,%01000000 + !byte $AF,%01100010 + !byte $AF,%10000011; + !byte $A9,%11100001 + !byte $B9,%01100100 + !byte $B9,%10000101; + !byte $A5,%01100000 + !byte $A5,%10000001; + !byte $B5,%00000100 + !byte $AB,%00000010 + !byte $BF,%00000110 + !byte $BB,%10100101 + !byte $B1,%10100011 + !byte $A7,%10100001 + !byte $A1,%00000000 + !byte $B7,%00100100 + !byte $AD,%00100010 + !byte $03,%00010010 + !byte $09,%01010010 + !byte $B3,%11000011 + !byte $A9,%11000001 + !byte $A3,%00100000 + !byte $BD,%11000101 + !byte $B9,%01000100 + !byte $AF,%01000010 + !byte $A5,%01000000 + !byte $BF,%11100101 + !byte $B5,%11100011 + !byte $AB,%11100001 + !byte $BB,%01100100 + !byte $BB,%10000101; + !byte $B1,%01100010 + !byte $B1,%10000011; + !byte $A7,%01100000 + !byte $A7,%10000001; + !byte $B7,%00000100 + !byte $AD,%00000010 + !byte $BD,%10100101 + !byte $B3,%10100011 + !byte $A3,%00000000 + !byte $A9,%10100001 + !byte $B9,%00100100 + !byte $19,%11110011 + !byte $AF,%00100010 + !byte $05,%00110010 + !byte $BF,%11000101 + !byte $B5,%11000011 + !byte $AB,%11000001 + !byte $A5,%00100000 + !byte $B1,%01000010 + !byte $BB,%01000100 + !byte $A7,%01000000 + !byte $0F,%10110011 + !byte $B7,%11100011 + !byte $AD,%11100001 + !byte $BD,%01100100 + !byte $BD,%10000101; + !byte $B3,%01100010 + !byte $B3,%10000011; + !byte $B9,%00000100 + !byte $AF,%00000010 + !byte $A9,%01100000 + !byte $A9,%10000001; + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $BF,%10100101 + !byte $B5,%10100011 + !byte $AB,%10100001 + !byte $A5,%00000000 + !byte $BB,%00100100 + !byte $B1,%00100010 + !byte $13,%11010011 + !byte $AD,%11000001 + !byte $A7,%00100000 + !byte $B7,%11000011 + !byte $BD,%01000100 + !byte $B3,%01000010 + !byte $A9,%01000000 + !byte $01,%00010010 + !byte $07,%01010010 + !byte $B9,%11100011 + !byte $AF,%11100001 + !byte $BF,%01100100 + !byte $BF,%10000101; + !byte $B5,%01100010 + !byte $B5,%10000011; + !byte $BB,%00000100 + !byte $AB,%01100000 + !byte $AB,%10000001; + !byte $B1,%00000010 + !byte $B7,%10100011 + !byte $A7,%00000000 + !byte $AD,%10100001 + !byte $BD,%00100100 + !byte $B3,%00100010 + !byte $A9,%00100000 + !byte $B9,%11000011 + !byte $AF,%11000001 + !byte $BF,%01000100 + !byte $B5,%01000010 + !byte $AB,%01000000 + !byte $BB,%11100011 + !byte $B1,%11100001 + !byte $03,%00110010 + !byte $B7,%01100010 + !byte $B7,%10000011; + !byte $AD,%01100000 + !byte $AD,%10000001; + !byte $17,%11110011 + !byte $BD,%00000100 + !byte $B3,%00000010 + !byte $B9,%10100011 + !byte $A9,%00000000 + !byte $AF,%10100001 + !byte $BF,%00100100 + !byte $B5,%00100010 + !byte $AB,%00100000 + !byte $0D,%10110011 + !byte $BB,%11000011 + !byte $B1,%11000001 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $B7,%01000010 + !byte $AD,%01000000 + !byte $BD,%11100011 + !byte $B3,%11100001 + !byte $B9,%01100010 + !byte $B9,%10000011; + !byte $AF,%01100000 + !byte $AF,%10000001; + !byte $11,%11010011 + !byte $BF,%00000100 + !byte $B5,%00000010 + !byte $AB,%00000000 + !byte $BB,%10100011 + !byte $B1,%10100001 + !byte $05,%01010010 + !byte $B7,%00100010 + !byte $AD,%00100000 + !byte $BD,%11000011 + !byte $B3,%11000001 + !byte $B9,%01000010 + !byte $AF,%01000000 + !byte $BF,%11100011 + !byte $B5,%11100001 + !byte $BB,%01100010 + !byte $BB,%10000011; + !byte $B1,%01100000 + !byte $B1,%10000001; + !byte $B7,%00000010 + !byte $01,%00110010 + !byte $AD,%00000000 + !byte $BD,%10100011 + !byte $B3,%10100001 + !byte $B9,%00100010 + !byte $AF,%00100000 + !byte $BF,%11000011 + !byte $B5,%11000001 + !byte $BB,%01000010 + !byte $B1,%01000000 + !byte $B7,%11100001 + !byte $15,%11110011 + !byte $BD,%01100010 + !byte $BD,%10000011; + !byte $B3,%01100000 + !byte $B3,%10000001; + !byte $0B,%10110011 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $B9,%00000010 + !byte $AF,%00000000 + !byte $BF,%10100011 + !byte $B5,%10100001 + !byte $BB,%00100010 + !byte $B1,%00100000 + !byte $0F,%11010011 + !byte $B7,%11000001 + !byte $03,%01010010 + !byte $BD,%01000010 + !byte $B3,%01000000 + !byte $B9,%11100001 + !byte $BF,%01100010 + !byte $BF,%10000011; + !byte $B5,%01100000 + !byte $B5,%10000001; + !byte $BB,%00000010 + !byte $B1,%00000000 + !byte $B7,%10100001 + !byte $BD,%00100010 + !byte $B3,%00100000 + !byte $B9,%11000001 + !byte $BF,%01000010 + !byte $B5,%01000000 + !byte $BB,%11100001 + !byte $B7,%01100000 + !byte $B7,%10000001; + !byte $BD,%00000010 + !byte $B3,%00000000 + !byte $B9,%10100001 + !byte $BF,%00100010 + !byte $B5,%00100000 + !byte $13,%11110011 + !byte $BB,%11000001 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $09,%10110011 + !byte $B7,%01000000 + !byte $BD,%11100001 + !byte $B9,%01100000 + !byte $B9,%10000001; + !byte $BF,%00000010 + !byte $B5,%00000000 + !byte $01,%01010010 + !byte $0D,%11010011 + !byte $BB,%10100001 + !byte $B7,%00100000 + !byte $BD,%11000001 + !byte $B9,%01000000 + !byte $BF,%11100001 + !byte $BB,%01100000 + !byte $BB,%10000001; + !byte $B7,%00000000 + !byte $BD,%10100001 + !byte $B9,%00100000 + !byte $BF,%11000001 + !byte $BB,%01000000 + !byte $BD,%01100000 + !byte $BD,%10000001; + !byte $03,%01110010 + !byte $03,%10010011; + !byte $07,%10110011 + !byte $B9,%00000000 + !byte $BF,%10100001 + !byte $11,%11110011 + !byte $BB,%00100000 + !byte $BD,%01000000 + !byte $0B,%11010011 + !byte $BF,%01100000 + !byte $BF,%10000001; + !byte $BB,%00000000 + !byte $BD,%00100000 + !byte $BF,%01000000 + !byte $BD,%00000000 + !byte $BF,%00100000 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $05,%10110011 + !byte $0F,%11110011 + !byte $BF,%00000000 + !byte $09,%11010011 + !byte $03,%10110011 + !byte $0D,%11110011 + !byte $07,%11010011 + !byte $01,%10110011 + !byte $0B,%11110011 + !byte $05,%11010011 + !byte $09,%11110011 + !byte $03,%11010011 + !byte $07,%11110011 + !byte $01,%11010011 + !byte $05,%11110011 + !byte $03,%11110011 + !byte $01,%11110011 diff --git a/src/fx/fx.hgr.heart.in.a b/src/fx/fx.hgr.heart.in.a new file mode 100644 index 0000000..b556c6b --- /dev/null +++ b/src/fx/fx.hgr.heart.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/HEART.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/HEART.DATA" diff --git a/src/fx/fx.hgr.heart.ripple.a b/src/fx/fx.hgr.heart.ripple.a new file mode 100644 index 0000000..a2015c5 --- /dev/null +++ b/src/fx/fx.hgr.heart.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/HEART.RIPPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/HEART.DATA" diff --git a/src/fx/fx.hgr.interlock.lr.a b/src/fx/fx.hgr.interlock.lr.a new file mode 100644 index 0000000..01a9397 --- /dev/null +++ b/src/fx/fx.hgr.interlock.lr.a @@ -0,0 +1,44 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/INTERLOCK.LR",plain +*=$6000 + +row = $FF + + lda #$00 + sta @h1 + lda #$27 + sta @h2 +@outerloop + lda #$BF + sta row +@loop lda row + jsr HGRCalc +@h1=*+1 + ldy #$00 + lda ($3c),y + sta ($26),y + dec row + lda row + jsr HGRCalc +@h2=*+1 + ldy #$27 + lda ($3c),y + sta ($26),y + dec row + lda row + cmp #$FF + bne @loop + lda #$20 + jsr WaitForKeyWithTimeout + bmi @exit + inc @h1 + dec @h2 + bpl @outerloop +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.interlock.ud.a b/src/fx/fx.hgr.interlock.ud.a new file mode 100644 index 0000000..e8fd89e --- /dev/null +++ b/src/fx/fx.hgr.interlock.ud.a @@ -0,0 +1,43 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/INTERLOCK.UD",plain +*=$6000 + +row1 = $fe +row2 = $ff + + lda #$00 + sta row1 + lda #$5F + sta row2 +@loop lda row1 + asl + jsr HGRCalc + ldy #$27 +- lda ($3c),y + sta ($26),y + dey + bpl - + lda row2 + asl + clc + adc #$01 + jsr HGRCalc + ldy #$27 +- lda ($3c),y + sta ($26),y + dey + bpl - + lda #$30 + jsr WaitForKeyWithTimeout + bmi @exit + inc row1 + dec row2 + bpl @loop +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.iris.a b/src/fx/fx.hgr.iris.a new file mode 100644 index 0000000..d4132ed --- /dev/null +++ b/src/fx/fx.hgr.iris.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/IRIS",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + + +FX_INITONCE_1BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_1BIT Coordinates1Bit + +CoordinatesFile + !byte 12 + !text "FX/IRIS.DATA" diff --git a/src/fx/fx.hgr.iris.data.a b/src/fx/fx.hgr.iris.data.a new file mode 100644 index 0000000..ce3da76 --- /dev/null +++ b/src/fx/fx.hgr.iris.data.a @@ -0,0 +1,6728 @@ +!cpu 6502 +!to "build/FX/IRIS.DATA",plain +*=$8600 + !byte $5E,%10110011 + !byte $5E,%11010011 + !byte $5E,%10010011 + !byte $5E,%01110011 + !byte $5C,%10110011 + !byte $5C,%11010011 + !byte $5E,%01010011 + !byte $5C,%01110011 + !byte $5C,%10010011 + !byte $5E,%00110011 + !byte $5C,%01010011 + !byte $5A,%10110011 + !byte $5A,%11010011 + !byte $5E,%00010011 + !byte $5C,%00110011 + !byte $5A,%01110011 + !byte $5A,%10010011 + !byte $5E,%11010010 + !byte $5C,%11010010 + !byte $5C,%00010011 + !byte $5A,%00110011 + !byte $5A,%01010011 + !byte $58,%11010011 + !byte $5E,%10110010 + !byte $5C,%10110010 + !byte $5A,%00010011 + !byte $58,%01110011 + !byte $58,%10010011 + !byte $58,%10110011 + !byte $5E,%10010010 + !byte $5C,%10010010 + !byte $5A,%10110010 + !byte $5A,%11010010 + !byte $58,%00110011 + !byte $58,%01010011 + !byte $5E,%01110010 + !byte $5C,%01110010 + !byte $5A,%10010010 + !byte $58,%11010010 + !byte $58,%00010011 + !byte $56,%01110011 + !byte $56,%10010011 + !byte $56,%10110011 + !byte $56,%11010011 + !byte $5E,%01010010 + !byte $5C,%01010010 + !byte $5A,%01110010 + !byte $58,%10110010 + !byte $56,%00110011 + !byte $56,%01010011 + !byte $5E,%00110010 + !byte $5C,%00110010 + !byte $5A,%01010010 + !byte $58,%10010010 + !byte $56,%11010010 + !byte $56,%00010011 + !byte $54,%01110011 + !byte $54,%10010011 + !byte $54,%10110011 + !byte $54,%11010011 + !byte $5E,%00010010 + !byte $5C,%00010010 + !byte $5A,%00110010 + !byte $58,%01010010 + !byte $58,%01110010 + !byte $56,%10010010 + !byte $56,%10110010 + !byte $54,%00110011 + !byte $54,%01010011 + !byte $5E,%11010001 + !byte $5C,%11010001 + !byte $5A,%00010010 + !byte $58,%00110010 + !byte $56,%01110010 + !byte $54,%11010010 + !byte $54,%00010011 + !byte $52,%10110011 + !byte $52,%11010011 + !byte $5E,%10110001 + !byte $5C,%10110001 + !byte $5A,%11010001 + !byte $58,%00010010 + !byte $56,%01010010 + !byte $54,%10010010 + !byte $54,%10110010 + !byte $52,%00110011 + !byte $52,%01010011 + !byte $52,%01110011 + !byte $52,%10010011 + !byte $5E,%10010001 + !byte $5C,%10010001 + !byte $5A,%10110001 + !byte $58,%11010001 + !byte $56,%00010010 + !byte $56,%00110010 + !byte $54,%01010010 + !byte $54,%01110010 + !byte $52,%11010010 + !byte $52,%00010011 + !byte $5E,%01110001 + !byte $5C,%01110001 + !byte $5A,%10010001 + !byte $58,%10110001 + !byte $56,%11010001 + !byte $54,%00110010 + !byte $52,%10010010 + !byte $52,%10110010 + !byte $50,%01010011 + !byte $50,%01110011 + !byte $50,%10010011 + !byte $50,%10110011 + !byte $50,%11010011 + !byte $5E,%01010001 + !byte $5C,%01010001 + !byte $5A,%01110001 + !byte $58,%01110001 + !byte $58,%10010001 + !byte $56,%10110001 + !byte $54,%00010010 + !byte $52,%01010010 + !byte $52,%01110010 + !byte $50,%11010010 + !byte $50,%00010011 + !byte $50,%00110011 + !byte $5E,%00110001 + !byte $5C,%00110001 + !byte $5A,%00110001 + !byte $5A,%01010001 + !byte $58,%01010001 + !byte $56,%10010001 + !byte $54,%10110001 + !byte $54,%11010001 + !byte $52,%00110010 + !byte $50,%10010010 + !byte $50,%10110010 + !byte $4E,%01010011 + !byte $4E,%01110011 + !byte $4E,%10010011 + !byte $4E,%10110011 + !byte $4E,%11010011 + !byte $5E,%00010001 + !byte $5C,%00010001 + !byte $5A,%00010001 + !byte $58,%00110001 + !byte $56,%01010001 + !byte $56,%01110001 + !byte $54,%10010001 + !byte $52,%11010001 + !byte $52,%00010010 + !byte $50,%01010010 + !byte $50,%01110010 + !byte $4E,%11010010 + !byte $4E,%00010011 + !byte $4E,%00110011 + !byte $5E,%11010000 + !byte $5C,%11010000 + !byte $5A,%11010000 + !byte $58,%00010001 + !byte $56,%00110001 + !byte $54,%01110001 + !byte $52,%10110001 + !byte $50,%00010010 + !byte $50,%00110010 + !byte $4E,%10010010 + !byte $4E,%10110010 + !byte $4C,%01110011 + !byte $4C,%10010011 + !byte $4C,%10110011 + !byte $4C,%11010011 + !byte $5E,%10110000 + !byte $5C,%10110000 + !byte $5A,%10110000 + !byte $58,%11010000 + !byte $56,%00010001 + !byte $54,%01010001 + !byte $52,%01110001 + !byte $52,%10010001 + !byte $50,%11010001 + !byte $4E,%01010010 + !byte $4E,%01110010 + !byte $4C,%11010010 + !byte $4C,%00010011 + !byte $4C,%00110011 + !byte $4C,%01010011 + !byte $5E,%10010000 + !byte $5C,%10010000 + !byte $5A,%10010000 + !byte $58,%10110000 + !byte $56,%11010000 + !byte $54,%00010001 + !byte $54,%00110001 + !byte $52,%01010001 + !byte $50,%10010001 + !byte $50,%10110001 + !byte $4E,%00010010 + !byte $4E,%00110010 + !byte $4C,%10010010 + !byte $4C,%10110010 + !byte $4A,%11010011 + !byte $5E,%01110000 + !byte $5C,%01110000 + !byte $5A,%01110000 + !byte $58,%10010000 + !byte $56,%10110000 + !byte $54,%11010000 + !byte $52,%00110001 + !byte $50,%01110001 + !byte $4E,%10110001 + !byte $4E,%11010001 + !byte $4C,%00110010 + !byte $4C,%01010010 + !byte $4C,%01110010 + !byte $4A,%00010011 + !byte $4A,%00110011 + !byte $4A,%01010011 + !byte $4A,%01110011 + !byte $4A,%10010011 + !byte $4A,%10110011 + !byte $5E,%01010000 + !byte $5C,%01010000 + !byte $5A,%01010000 + !byte $58,%01110000 + !byte $56,%10010000 + !byte $54,%10110000 + !byte $52,%00010001 + !byte $50,%00110001 + !byte $50,%01010001 + !byte $4E,%10010001 + !byte $4C,%00010010 + !byte $4A,%10010010 + !byte $4A,%10110010 + !byte $4A,%11010010 + !byte $5E,%00110000 + !byte $5C,%00110000 + !byte $5A,%00110000 + !byte $58,%01010000 + !byte $56,%01110000 + !byte $54,%10010000 + !byte $52,%10110000 + !byte $52,%11010000 + !byte $50,%00010001 + !byte $4E,%01010001 + !byte $4E,%01110001 + !byte $4C,%10110001 + !byte $4C,%11010001 + !byte $4A,%01010010 + !byte $4A,%01110010 + !byte $48,%00110011 + !byte $48,%01010011 + !byte $48,%01110011 + !byte $48,%10010011 + !byte $48,%10110011 + !byte $48,%11010011 + !byte $5E,%00010000 + !byte $5C,%00010000 + !byte $5A,%00010000 + !byte $58,%00110000 + !byte $56,%01010000 + !byte $54,%01110000 + !byte $52,%10010000 + !byte $50,%11010000 + !byte $4E,%00110001 + !byte $4C,%01110001 + !byte $4C,%10010001 + !byte $4A,%00010010 + !byte $4A,%00110010 + !byte $48,%10110010 + !byte $48,%11010010 + !byte $48,%00010011 + !byte $5E,%11001111 + !byte $5C,%11001111 + !byte $5A,%11001111 + !byte $58,%00010000 + !byte $56,%00110000 + !byte $54,%01010000 + !byte $52,%01110000 + !byte $50,%10110000 + !byte $4E,%11010000 + !byte $4E,%00010001 + !byte $4C,%01010001 + !byte $4A,%10110001 + !byte $4A,%11010001 + !byte $48,%01010010 + !byte $48,%01110010 + !byte $48,%10010010 + !byte $46,%01010011 + !byte $46,%01110011 + !byte $46,%10010011 + !byte $46,%10110011 + !byte $46,%11010011 + !byte $5E,%10101111 + !byte $5C,%10101111 + !byte $5A,%10101111 + !byte $58,%11001111 + !byte $56,%00010000 + !byte $54,%00010000 + !byte $54,%00110000 + !byte $52,%01010000 + !byte $50,%01110000 + !byte $50,%10010000 + !byte $4E,%10110000 + !byte $4C,%00010001 + !byte $4C,%00110001 + !byte $4A,%01110001 + !byte $4A,%10010001 + !byte $48,%00010010 + !byte $48,%00110010 + !byte $46,%10110010 + !byte $46,%11010010 + !byte $46,%00010011 + !byte $46,%00110011 + !byte $5E,%10001111 + !byte $5C,%10001111 + !byte $5A,%10001111 + !byte $58,%10101111 + !byte $56,%10101111 + !byte $56,%11001111 + !byte $54,%11001111 + !byte $52,%00110000 + !byte $50,%01010000 + !byte $4E,%10010000 + !byte $4C,%11010000 + !byte $4A,%00110001 + !byte $4A,%01010001 + !byte $48,%10110001 + !byte $48,%11010001 + !byte $46,%01010010 + !byte $46,%01110010 + !byte $46,%10010010 + !byte $44,%10010011 + !byte $44,%10110011 + !byte $44,%11010011 + !byte $5E,%01101111 + !byte $5C,%01101111 + !byte $5A,%01101111 + !byte $58,%10001111 + !byte $56,%10001111 + !byte $54,%10101111 + !byte $52,%11001111 + !byte $52,%00010000 + !byte $50,%00110000 + !byte $4E,%01010000 + !byte $4E,%01110000 + !byte $4C,%10110000 + !byte $4A,%00010001 + !byte $48,%01110001 + !byte $48,%10010001 + !byte $46,%00010010 + !byte $46,%00110010 + !byte $44,%11010010 + !byte $44,%00010011 + !byte $44,%00110011 + !byte $44,%01010011 + !byte $44,%01110011 + !byte $5E,%01001111 + !byte $5C,%01001111 + !byte $5A,%01001111 + !byte $58,%01101111 + !byte $56,%01101111 + !byte $54,%10001111 + !byte $52,%10101111 + !byte $50,%00010000 + !byte $4E,%00110000 + !byte $4C,%01110000 + !byte $4C,%10010000 + !byte $4A,%10110000 + !byte $4A,%11010000 + !byte $48,%00110001 + !byte $48,%01010001 + !byte $46,%10110001 + !byte $46,%11010001 + !byte $44,%01010010 + !byte $44,%01110010 + !byte $44,%10010010 + !byte $44,%10110010 + !byte $5E,%00101111 + !byte $5C,%00101111 + !byte $5A,%00101111 + !byte $58,%01001111 + !byte $56,%01001111 + !byte $54,%01101111 + !byte $52,%10001111 + !byte $50,%11001111 + !byte $4E,%00010000 + !byte $4C,%01010000 + !byte $4A,%10010000 + !byte $48,%11010000 + !byte $48,%00010001 + !byte $46,%01110001 + !byte $46,%10010001 + !byte $44,%00010010 + !byte $44,%00110010 + !byte $42,%00010011 + !byte $42,%00110011 + !byte $42,%01010011 + !byte $42,%01110011 + !byte $42,%10010011 + !byte $42,%10110011 + !byte $42,%11010011 + !byte $5E,%00001111 + !byte $5C,%00001111 + !byte $5A,%00001111 + !byte $58,%00101111 + !byte $56,%00101111 + !byte $54,%01001111 + !byte $52,%01101111 + !byte $50,%10001111 + !byte $50,%10101111 + !byte $4E,%11001111 + !byte $4C,%00010000 + !byte $4C,%00110000 + !byte $4A,%01110000 + !byte $48,%10110000 + !byte $46,%00110001 + !byte $46,%01010001 + !byte $44,%10110001 + !byte $44,%11010001 + !byte $42,%01110010 + !byte $42,%10010010 + !byte $42,%10110010 + !byte $42,%11010010 + !byte $5E,%11001110 + !byte $5C,%11001110 + !byte $5A,%11001110 + !byte $58,%00001111 + !byte $56,%00001111 + !byte $54,%00101111 + !byte $52,%01001111 + !byte $50,%01101111 + !byte $4E,%10101111 + !byte $4C,%11001111 + !byte $4A,%00110000 + !byte $4A,%01010000 + !byte $48,%01110000 + !byte $48,%10010000 + !byte $46,%11010000 + !byte $46,%00010001 + !byte $44,%01110001 + !byte $44,%10010001 + !byte $42,%00010010 + !byte $42,%00110010 + !byte $42,%01010010 + !byte $40,%00110011 + !byte $40,%01010011 + !byte $40,%01110011 + !byte $40,%10010011 + !byte $40,%10110011 + !byte $40,%11010011 + !byte $5E,%10101110 + !byte $5C,%10101110 + !byte $5A,%10101110 + !byte $58,%11001110 + !byte $56,%11001110 + !byte $54,%00001111 + !byte $52,%00101111 + !byte $50,%01001111 + !byte $4E,%01101111 + !byte $4E,%10001111 + !byte $4C,%10101111 + !byte $4A,%00010000 + !byte $48,%01010000 + !byte $46,%10110000 + !byte $44,%00110001 + !byte $44,%01010001 + !byte $42,%10110001 + !byte $42,%11010001 + !byte $40,%10010010 + !byte $40,%10110010 + !byte $40,%11010010 + !byte $40,%00010011 + !byte $5E,%10001110 + !byte $5C,%10001110 + !byte $5A,%10001110 + !byte $58,%10001110 + !byte $58,%10101110 + !byte $56,%10101110 + !byte $54,%11001110 + !byte $52,%00001111 + !byte $50,%00101111 + !byte $4E,%01001111 + !byte $4C,%10001111 + !byte $4A,%10101111 + !byte $4A,%11001111 + !byte $48,%00010000 + !byte $48,%00110000 + !byte $46,%01110000 + !byte $46,%10010000 + !byte $44,%11010000 + !byte $44,%00010001 + !byte $42,%01010001 + !byte $42,%01110001 + !byte $42,%10010001 + !byte $40,%00110010 + !byte $40,%01010010 + !byte $40,%01110010 + !byte $3E,%01110011 + !byte $3E,%10010011 + !byte $3E,%10110011 + !byte $3E,%11010011 + !byte $5E,%01101110 + !byte $5C,%01101110 + !byte $5A,%01101110 + !byte $58,%01101110 + !byte $56,%10001110 + !byte $54,%10101110 + !byte $52,%11001110 + !byte $50,%00001111 + !byte $4E,%00101111 + !byte $4C,%01001111 + !byte $4C,%01101111 + !byte $4A,%10001111 + !byte $48,%11001111 + !byte $46,%00110000 + !byte $46,%01010000 + !byte $44,%10010000 + !byte $44,%10110000 + !byte $42,%00110001 + !byte $40,%10110001 + !byte $40,%11010001 + !byte $40,%00010010 + !byte $3E,%10010010 + !byte $3E,%10110010 + !byte $3E,%11010010 + !byte $3E,%00010011 + !byte $3E,%00110011 + !byte $3E,%01010011 + !byte $5E,%01001110 + !byte $5C,%01001110 + !byte $5A,%01001110 + !byte $58,%01001110 + !byte $56,%01101110 + !byte $54,%10001110 + !byte $52,%10101110 + !byte $50,%11001110 + !byte $4E,%00001111 + !byte $4C,%00101111 + !byte $4A,%01101111 + !byte $48,%10101111 + !byte $46,%00010000 + !byte $44,%01110000 + !byte $42,%11010000 + !byte $42,%00010001 + !byte $40,%01110001 + !byte $40,%10010001 + !byte $3E,%00110010 + !byte $3E,%01010010 + !byte $3E,%01110010 + !byte $5E,%00101110 + !byte $5C,%00101110 + !byte $5A,%00101110 + !byte $58,%00101110 + !byte $56,%01001110 + !byte $54,%01101110 + !byte $52,%10001110 + !byte $50,%10101110 + !byte $4E,%11001110 + !byte $4C,%00001111 + !byte $4A,%01001111 + !byte $48,%01101111 + !byte $48,%10001111 + !byte $46,%10101111 + !byte $46,%11001111 + !byte $44,%00110000 + !byte $44,%01010000 + !byte $42,%10010000 + !byte $42,%10110000 + !byte $40,%00010001 + !byte $40,%00110001 + !byte $40,%01010001 + !byte $3E,%10110001 + !byte $3E,%11010001 + !byte $3E,%00010010 + !byte $3C,%10110010 + !byte $3C,%11010010 + !byte $3C,%00010011 + !byte $3C,%00110011 + !byte $3C,%01010011 + !byte $3C,%01110011 + !byte $3C,%10010011 + !byte $3C,%10110011 + !byte $3C,%11010011 + !byte $5E,%00001110 + !byte $5C,%00001110 + !byte $5A,%00001110 + !byte $58,%00001110 + !byte $56,%00101110 + !byte $54,%01001110 + !byte $52,%01001110 + !byte $52,%01101110 + !byte $50,%01101110 + !byte $50,%10001110 + !byte $4E,%10101110 + !byte $4C,%11001110 + !byte $4A,%00001111 + !byte $4A,%00101111 + !byte $48,%01001111 + !byte $46,%10001111 + !byte $44,%11001111 + !byte $44,%00010000 + !byte $42,%01010000 + !byte $42,%01110000 + !byte $40,%10110000 + !byte $40,%11010000 + !byte $3E,%01110001 + !byte $3E,%10010001 + !byte $3C,%00110010 + !byte $3C,%01010010 + !byte $3C,%01110010 + !byte $3C,%10010010 + !byte $5E,%11001101 + !byte $5C,%11001101 + !byte $5A,%11001101 + !byte $58,%11001101 + !byte $56,%00001110 + !byte $54,%00101110 + !byte $52,%00101110 + !byte $50,%01001110 + !byte $4E,%01101110 + !byte $4E,%10001110 + !byte $4C,%10101110 + !byte $4A,%11001110 + !byte $48,%00101111 + !byte $46,%01101111 + !byte $44,%10101111 + !byte $42,%00110000 + !byte $40,%10010000 + !byte $3E,%00110001 + !byte $3E,%01010001 + !byte $3C,%10110001 + !byte $3C,%11010001 + !byte $3C,%00010010 + !byte $3A,%00010011 + !byte $3A,%00110011 + !byte $3A,%01010011 + !byte $3A,%01110011 + !byte $3A,%10010011 + !byte $3A,%10110011 + !byte $3A,%11010011 + !byte $5E,%10101101 + !byte $5C,%10101101 + !byte $5A,%10101101 + !byte $58,%10101101 + !byte $56,%11001101 + !byte $54,%00001110 + !byte $52,%00001110 + !byte $50,%00101110 + !byte $4E,%01001110 + !byte $4C,%10001110 + !byte $4A,%10101110 + !byte $48,%00001111 + !byte $46,%01001111 + !byte $44,%10001111 + !byte $42,%11001111 + !byte $42,%00010000 + !byte $40,%01010000 + !byte $40,%01110000 + !byte $3E,%11010000 + !byte $3E,%00010001 + !byte $3C,%01110001 + !byte $3C,%10010001 + !byte $3A,%01010010 + !byte $3A,%01110010 + !byte $3A,%10010010 + !byte $3A,%10110010 + !byte $3A,%11010010 + !byte $5E,%10001101 + !byte $5C,%10001101 + !byte $5A,%10001101 + !byte $58,%10001101 + !byte $56,%10101101 + !byte $54,%10101101 + !byte $54,%11001101 + !byte $52,%11001101 + !byte $50,%00001110 + !byte $4E,%00101110 + !byte $4C,%01001110 + !byte $4C,%01101110 + !byte $4A,%10001110 + !byte $48,%10101110 + !byte $48,%11001110 + !byte $46,%00001111 + !byte $46,%00101111 + !byte $44,%01001111 + !byte $44,%01101111 + !byte $42,%10001111 + !byte $42,%10101111 + !byte $40,%00010000 + !byte $40,%00110000 + !byte $3E,%10010000 + !byte $3E,%10110000 + !byte $3C,%00110001 + !byte $3C,%01010001 + !byte $3A,%11010001 + !byte $3A,%00010010 + !byte $3A,%00110010 + !byte $38,%01010011 + !byte $38,%01110011 + !byte $38,%10010011 + !byte $38,%10110011 + !byte $38,%11010011 + !byte $5E,%01101101 + !byte $5C,%01101101 + !byte $5A,%01101101 + !byte $58,%01101101 + !byte $56,%10001101 + !byte $54,%10001101 + !byte $52,%10101101 + !byte $50,%11001101 + !byte $4E,%00001110 + !byte $4C,%00101110 + !byte $4A,%01101110 + !byte $48,%10001110 + !byte $46,%11001110 + !byte $44,%00101111 + !byte $42,%01101111 + !byte $40,%11001111 + !byte $3E,%01010000 + !byte $3E,%01110000 + !byte $3C,%11010000 + !byte $3C,%00010001 + !byte $3A,%01110001 + !byte $3A,%10010001 + !byte $3A,%10110001 + !byte $38,%01110010 + !byte $38,%10010010 + !byte $38,%10110010 + !byte $38,%11010010 + !byte $38,%00010011 + !byte $38,%00110011 + !byte $5E,%01001101 + !byte $5C,%01001101 + !byte $5A,%01001101 + !byte $58,%01001101 + !byte $56,%01101101 + !byte $54,%01101101 + !byte $52,%10001101 + !byte $50,%10101101 + !byte $4E,%11001101 + !byte $4C,%00001110 + !byte $4A,%00101110 + !byte $4A,%01001110 + !byte $48,%01101110 + !byte $46,%10101110 + !byte $44,%00001111 + !byte $42,%01001111 + !byte $40,%10001111 + !byte $40,%10101111 + !byte $3E,%00010000 + !byte $3E,%00110000 + !byte $3C,%10010000 + !byte $3C,%10110000 + !byte $3A,%00110001 + !byte $3A,%01010001 + !byte $38,%00010010 + !byte $38,%00110010 + !byte $38,%01010010 + !byte $36,%10110011 + !byte $36,%11010011 + !byte $5E,%00101101 + !byte $5C,%00101101 + !byte $5A,%00101101 + !byte $58,%00101101 + !byte $56,%01001101 + !byte $54,%01001101 + !byte $52,%01101101 + !byte $50,%10001101 + !byte $4E,%10101101 + !byte $4C,%11001101 + !byte $4A,%00001110 + !byte $48,%01001110 + !byte $46,%01101110 + !byte $46,%10001110 + !byte $44,%10101110 + !byte $44,%11001110 + !byte $42,%00001111 + !byte $42,%00101111 + !byte $40,%01101111 + !byte $3E,%10101111 + !byte $3E,%11001111 + !byte $3C,%01010000 + !byte $3C,%01110000 + !byte $3A,%10110000 + !byte $3A,%11010000 + !byte $3A,%00010001 + !byte $38,%10010001 + !byte $38,%10110001 + !byte $38,%11010001 + !byte $36,%10010010 + !byte $36,%10110010 + !byte $36,%11010010 + !byte $36,%00010011 + !byte $36,%00110011 + !byte $36,%01010011 + !byte $36,%01110011 + !byte $36,%10010011 + !byte $5E,%00001101 + !byte $5C,%00001101 + !byte $5A,%00001101 + !byte $58,%00001101 + !byte $56,%00101101 + !byte $54,%00101101 + !byte $52,%01001101 + !byte $50,%01101101 + !byte $4E,%10001101 + !byte $4C,%10101101 + !byte $4A,%11001101 + !byte $48,%00101110 + !byte $46,%01001110 + !byte $44,%10001110 + !byte $42,%11001110 + !byte $40,%00101111 + !byte $40,%01001111 + !byte $3E,%10001111 + !byte $3C,%00010000 + !byte $3C,%00110000 + !byte $3A,%01110000 + !byte $3A,%10010000 + !byte $38,%00110001 + !byte $38,%01010001 + !byte $38,%01110001 + !byte $36,%00010010 + !byte $36,%00110010 + !byte $36,%01010010 + !byte $36,%01110010 + !byte $5E,%11001100 + !byte $5C,%11001100 + !byte $5A,%11001100 + !byte $58,%11001100 + !byte $56,%00001101 + !byte $54,%00001101 + !byte $52,%00101101 + !byte $50,%01001101 + !byte $4E,%01101101 + !byte $4C,%10001101 + !byte $4A,%10101101 + !byte $48,%11001101 + !byte $48,%00001110 + !byte $46,%00101110 + !byte $44,%01101110 + !byte $42,%10001110 + !byte $42,%10101110 + !byte $40,%00001111 + !byte $3E,%01001111 + !byte $3E,%01101111 + !byte $3C,%10101111 + !byte $3C,%11001111 + !byte $3A,%01010000 + !byte $38,%11010000 + !byte $38,%00010001 + !byte $36,%10010001 + !byte $36,%10110001 + !byte $36,%11010001 + !byte $34,%11010010 + !byte $34,%00010011 + !byte $34,%00110011 + !byte $34,%01010011 + !byte $34,%01110011 + !byte $34,%10010011 + !byte $34,%10110011 + !byte $34,%11010011 + !byte $5E,%10101100 + !byte $5C,%10101100 + !byte $5A,%10101100 + !byte $58,%10101100 + !byte $56,%11001100 + !byte $54,%11001100 + !byte $52,%00001101 + !byte $50,%00101101 + !byte $4E,%01001101 + !byte $4C,%01101101 + !byte $4A,%10001101 + !byte $48,%10101101 + !byte $46,%00001110 + !byte $44,%00101110 + !byte $44,%01001110 + !byte $42,%01101110 + !byte $40,%10101110 + !byte $40,%11001110 + !byte $3E,%00101111 + !byte $3C,%10001111 + !byte $3A,%00010000 + !byte $3A,%00110000 + !byte $38,%01110000 + !byte $38,%10010000 + !byte $38,%10110000 + !byte $36,%00110001 + !byte $36,%01010001 + !byte $36,%01110001 + !byte $34,%00110010 + !byte $34,%01010010 + !byte $34,%01110010 + !byte $34,%10010010 + !byte $34,%10110010 + !byte $5E,%10001100 + !byte $5C,%10001100 + !byte $5A,%10001100 + !byte $58,%10001100 + !byte $56,%10101100 + !byte $54,%10101100 + !byte $52,%11001100 + !byte $50,%00001101 + !byte $4E,%00101101 + !byte $4C,%01001101 + !byte $4A,%01101101 + !byte $48,%10001101 + !byte $46,%10101101 + !byte $46,%11001101 + !byte $44,%00001110 + !byte $42,%01001110 + !byte $40,%10001110 + !byte $3E,%11001110 + !byte $3E,%00001111 + !byte $3C,%01001111 + !byte $3C,%01101111 + !byte $3A,%10101111 + !byte $3A,%11001111 + !byte $38,%00110000 + !byte $38,%01010000 + !byte $36,%11010000 + !byte $36,%00010001 + !byte $34,%10010001 + !byte $34,%10110001 + !byte $34,%11010001 + !byte $34,%00010010 + !byte $32,%00110011 + !byte $32,%01010011 + !byte $32,%01110011 + !byte $32,%10010011 + !byte $32,%10110011 + !byte $32,%11010011 + !byte $5E,%01101100 + !byte $5C,%01101100 + !byte $5A,%01101100 + !byte $58,%01101100 + !byte $56,%10001100 + !byte $54,%10001100 + !byte $52,%10101100 + !byte $50,%11001100 + !byte $4E,%11001100 + !byte $4E,%00001101 + !byte $4C,%00001101 + !byte $4C,%00101101 + !byte $4A,%01001101 + !byte $48,%01101101 + !byte $46,%10001101 + !byte $44,%11001101 + !byte $42,%00101110 + !byte $40,%01001110 + !byte $40,%01101110 + !byte $3E,%10101110 + !byte $3C,%00001111 + !byte $3C,%00101111 + !byte $3A,%01101111 + !byte $3A,%10001111 + !byte $38,%00010000 + !byte $36,%10010000 + !byte $36,%10110000 + !byte $34,%00110001 + !byte $34,%01010001 + !byte $34,%01110001 + !byte $32,%01010010 + !byte $32,%01110010 + !byte $32,%10010010 + !byte $32,%10110010 + !byte $32,%11010010 + !byte $32,%00010011 + !byte $5E,%01001100 + !byte $5C,%01001100 + !byte $5A,%01001100 + !byte $58,%01001100 + !byte $56,%01101100 + !byte $54,%01101100 + !byte $52,%10001100 + !byte $50,%10101100 + !byte $4E,%10101100 + !byte $4C,%11001100 + !byte $4A,%00001101 + !byte $4A,%00101101 + !byte $48,%01001101 + !byte $46,%01101101 + !byte $44,%10101101 + !byte $42,%11001101 + !byte $42,%00001110 + !byte $40,%00101110 + !byte $3E,%01101110 + !byte $3E,%10001110 + !byte $3C,%11001110 + !byte $3A,%01001111 + !byte $38,%10101111 + !byte $38,%11001111 + !byte $36,%00110000 + !byte $36,%01010000 + !byte $36,%01110000 + !byte $34,%11010000 + !byte $34,%00010001 + !byte $32,%10110001 + !byte $32,%11010001 + !byte $32,%00010010 + !byte $32,%00110010 + !byte $30,%01110011 + !byte $30,%10010011 + !byte $30,%10110011 + !byte $30,%11010011 + !byte $5E,%00101100 + !byte $5C,%00101100 + !byte $5A,%00101100 + !byte $58,%00101100 + !byte $56,%01001100 + !byte $54,%01001100 + !byte $52,%01101100 + !byte $50,%01101100 + !byte $50,%10001100 + !byte $4E,%10001100 + !byte $4C,%10101100 + !byte $4A,%11001100 + !byte $48,%00101101 + !byte $46,%01001101 + !byte $44,%01101101 + !byte $44,%10001101 + !byte $42,%10101101 + !byte $40,%00001110 + !byte $3E,%01001110 + !byte $3C,%10001110 + !byte $3C,%10101110 + !byte $3A,%00001111 + !byte $3A,%00101111 + !byte $38,%01101111 + !byte $38,%10001111 + !byte $36,%11001111 + !byte $36,%00010000 + !byte $34,%10010000 + !byte $34,%10110000 + !byte $32,%01010001 + !byte $32,%01110001 + !byte $32,%10010001 + !byte $30,%01110010 + !byte $30,%10010010 + !byte $30,%10110010 + !byte $30,%11010010 + !byte $30,%00010011 + !byte $30,%00110011 + !byte $30,%01010011 + !byte $5E,%00001100 + !byte $5C,%00001100 + !byte $5A,%00001100 + !byte $58,%00001100 + !byte $56,%00101100 + !byte $54,%00101100 + !byte $52,%01001100 + !byte $50,%01001100 + !byte $4E,%01101100 + !byte $4C,%10001100 + !byte $4A,%10101100 + !byte $48,%11001100 + !byte $48,%00001101 + !byte $46,%00101101 + !byte $44,%01001101 + !byte $42,%10001101 + !byte $40,%11001101 + !byte $3E,%00101110 + !byte $3C,%01101110 + !byte $3A,%10101110 + !byte $3A,%11001110 + !byte $38,%00101111 + !byte $38,%01001111 + !byte $36,%10001111 + !byte $36,%10101111 + !byte $34,%01010000 + !byte $34,%01110000 + !byte $32,%11010000 + !byte $32,%00010001 + !byte $32,%00110001 + !byte $30,%11010001 + !byte $30,%00010010 + !byte $30,%00110010 + !byte $30,%01010010 + !byte $5E,%11001011 + !byte $5C,%11001011 + !byte $5A,%11001011 + !byte $58,%11001011 + !byte $56,%00001100 + !byte $54,%00001100 + !byte $52,%00101100 + !byte $50,%00101100 + !byte $4E,%01001100 + !byte $4C,%01101100 + !byte $4A,%10001100 + !byte $48,%10101100 + !byte $46,%00001101 + !byte $44,%00101101 + !byte $42,%01001101 + !byte $42,%01101101 + !byte $40,%10001101 + !byte $40,%10101101 + !byte $3E,%11001101 + !byte $3E,%00001110 + !byte $3C,%00101110 + !byte $3C,%01001110 + !byte $3A,%10001110 + !byte $38,%00001111 + !byte $36,%01101111 + !byte $34,%11001111 + !byte $34,%00010000 + !byte $34,%00110000 + !byte $32,%10010000 + !byte $32,%10110000 + !byte $30,%01110001 + !byte $30,%10010001 + !byte $30,%10110001 + !byte $2E,%10010010 + !byte $2E,%10110010 + !byte $2E,%11010010 + !byte $2E,%00010011 + !byte $2E,%00110011 + !byte $2E,%01010011 + !byte $2E,%01110011 + !byte $2E,%10010011 + !byte $2E,%10110011 + !byte $2E,%11010011 + !byte $5E,%10101011 + !byte $5C,%10101011 + !byte $5A,%10101011 + !byte $58,%10101011 + !byte $56,%11001011 + !byte $54,%11001011 + !byte $52,%00001100 + !byte $50,%00001100 + !byte $4E,%00101100 + !byte $4C,%01001100 + !byte $4A,%01101100 + !byte $48,%10001100 + !byte $46,%10101100 + !byte $46,%11001100 + !byte $44,%00001101 + !byte $42,%00101101 + !byte $40,%01101101 + !byte $3E,%10101101 + !byte $3C,%00001110 + !byte $3A,%01001110 + !byte $3A,%01101110 + !byte $38,%10101110 + !byte $38,%11001110 + !byte $36,%00101111 + !byte $36,%01001111 + !byte $34,%10001111 + !byte $34,%10101111 + !byte $32,%00110000 + !byte $32,%01010000 + !byte $32,%01110000 + !byte $30,%00010001 + !byte $30,%00110001 + !byte $30,%01010001 + !byte $2E,%00010010 + !byte $2E,%00110010 + !byte $2E,%01010010 + !byte $2E,%01110010 + !byte $5E,%10001011 + !byte $5C,%10001011 + !byte $5A,%10001011 + !byte $58,%10001011 + !byte $56,%10101011 + !byte $54,%10101011 + !byte $52,%11001011 + !byte $50,%11001011 + !byte $4E,%00001100 + !byte $4C,%00101100 + !byte $4A,%01001100 + !byte $48,%01101100 + !byte $46,%10001100 + !byte $44,%11001100 + !byte $42,%00001101 + !byte $40,%01001101 + !byte $3E,%10001101 + !byte $3C,%11001101 + !byte $3A,%00101110 + !byte $38,%01101110 + !byte $38,%10001110 + !byte $36,%11001110 + !byte $36,%00001111 + !byte $34,%01001111 + !byte $34,%01101111 + !byte $32,%00010000 + !byte $30,%10010000 + !byte $30,%10110000 + !byte $30,%11010000 + !byte $2E,%01110001 + !byte $2E,%10010001 + !byte $2E,%10110001 + !byte $2E,%11010001 + !byte $2C,%11010010 + !byte $2C,%00010011 + !byte $2C,%00110011 + !byte $2C,%01010011 + !byte $2C,%01110011 + !byte $2C,%10010011 + !byte $2C,%10110011 + !byte $2C,%11010011 + !byte $5E,%01101011 + !byte $5C,%01101011 + !byte $5A,%01101011 + !byte $58,%01101011 + !byte $56,%01101011 + !byte $56,%10001011 + !byte $54,%10001011 + !byte $52,%10101011 + !byte $50,%10101011 + !byte $4E,%11001011 + !byte $4C,%00001100 + !byte $4A,%00101100 + !byte $48,%01001100 + !byte $46,%01101100 + !byte $44,%10001100 + !byte $44,%10101100 + !byte $42,%11001100 + !byte $40,%00001101 + !byte $40,%00101101 + !byte $3E,%01001101 + !byte $3E,%01101101 + !byte $3C,%10001101 + !byte $3C,%10101101 + !byte $3A,%11001101 + !byte $3A,%00001110 + !byte $38,%01001110 + !byte $36,%10101110 + !byte $34,%00101111 + !byte $32,%10001111 + !byte $32,%10101111 + !byte $32,%11001111 + !byte $30,%01010000 + !byte $30,%01110000 + !byte $2E,%00010001 + !byte $2E,%00110001 + !byte $2E,%01010001 + !byte $2C,%00110010 + !byte $2C,%01010010 + !byte $2C,%01110010 + !byte $2C,%10010010 + !byte $2C,%10110010 + !byte $5E,%01001011 + !byte $5C,%01001011 + !byte $5A,%01001011 + !byte $58,%01001011 + !byte $56,%01001011 + !byte $54,%01101011 + !byte $52,%01101011 + !byte $52,%10001011 + !byte $50,%10001011 + !byte $4E,%10101011 + !byte $4C,%11001011 + !byte $4A,%00001100 + !byte $48,%00101100 + !byte $46,%01001100 + !byte $44,%01101100 + !byte $42,%10101100 + !byte $40,%11001100 + !byte $3E,%00101101 + !byte $3C,%01101101 + !byte $3A,%10101101 + !byte $38,%00001110 + !byte $38,%00101110 + !byte $36,%01101110 + !byte $36,%10001110 + !byte $34,%11001110 + !byte $34,%00001111 + !byte $32,%01001111 + !byte $32,%01101111 + !byte $30,%11001111 + !byte $30,%00010000 + !byte $30,%00110000 + !byte $2E,%10010000 + !byte $2E,%10110000 + !byte $2E,%11010000 + !byte $2C,%10010001 + !byte $2C,%10110001 + !byte $2C,%11010001 + !byte $2C,%00010010 + !byte $2A,%01010011 + !byte $2A,%01110011 + !byte $2A,%10010011 + !byte $2A,%10110011 + !byte $2A,%11010011 + !byte $5E,%00101011 + !byte $5C,%00101011 + !byte $5A,%00101011 + !byte $58,%00101011 + !byte $56,%00101011 + !byte $54,%01001011 + !byte $52,%01001011 + !byte $50,%01101011 + !byte $4E,%10001011 + !byte $4C,%10101011 + !byte $4A,%11001011 + !byte $48,%00001100 + !byte $46,%00101100 + !byte $44,%01001100 + !byte $42,%01101100 + !byte $42,%10001100 + !byte $40,%10101100 + !byte $3E,%00001101 + !byte $3C,%01001101 + !byte $3A,%10001101 + !byte $38,%11001101 + !byte $36,%00101110 + !byte $36,%01001110 + !byte $34,%10001110 + !byte $34,%10101110 + !byte $32,%00101111 + !byte $30,%10001111 + !byte $30,%10101111 + !byte $2E,%01010000 + !byte $2E,%01110000 + !byte $2C,%00010001 + !byte $2C,%00110001 + !byte $2C,%01010001 + !byte $2C,%01110001 + !byte $2A,%01010010 + !byte $2A,%01110010 + !byte $2A,%10010010 + !byte $2A,%10110010 + !byte $2A,%11010010 + !byte $2A,%00010011 + !byte $2A,%00110011 + !byte $5E,%00001011 + !byte $5C,%00001011 + !byte $5A,%00001011 + !byte $58,%00001011 + !byte $56,%00001011 + !byte $54,%00101011 + !byte $52,%00101011 + !byte $50,%01001011 + !byte $4E,%01101011 + !byte $4C,%10001011 + !byte $4A,%10101011 + !byte $48,%11001011 + !byte $46,%00001100 + !byte $44,%00101100 + !byte $42,%01001100 + !byte $40,%10001100 + !byte $3E,%11001100 + !byte $3C,%00001101 + !byte $3C,%00101101 + !byte $3A,%01001101 + !byte $3A,%01101101 + !byte $38,%10101101 + !byte $36,%00001110 + !byte $34,%01101110 + !byte $32,%11001110 + !byte $32,%00001111 + !byte $30,%01101111 + !byte $2E,%00010000 + !byte $2E,%00110000 + !byte $2C,%10110000 + !byte $2C,%11010000 + !byte $2A,%10010001 + !byte $2A,%10110001 + !byte $2A,%11010001 + !byte $2A,%00010010 + !byte $2A,%00110010 + !byte $5E,%11001010 + !byte $5C,%11001010 + !byte $5A,%11001010 + !byte $58,%11001010 + !byte $56,%11001010 + !byte $54,%00001011 + !byte $52,%00001011 + !byte $50,%00101011 + !byte $4E,%01001011 + !byte $4C,%01101011 + !byte $4A,%01101011 + !byte $4A,%10001011 + !byte $48,%10001011 + !byte $48,%10101011 + !byte $46,%11001011 + !byte $44,%00001100 + !byte $42,%00101100 + !byte $40,%01101100 + !byte $3E,%10001100 + !byte $3E,%10101100 + !byte $3C,%11001100 + !byte $3A,%00101101 + !byte $38,%01101101 + !byte $38,%10001101 + !byte $36,%11001101 + !byte $34,%00101110 + !byte $34,%01001110 + !byte $32,%10001110 + !byte $32,%10101110 + !byte $30,%00101111 + !byte $30,%01001111 + !byte $2E,%10001111 + !byte $2E,%10101111 + !byte $2E,%11001111 + !byte $2C,%01010000 + !byte $2C,%01110000 + !byte $2C,%10010000 + !byte $2A,%00110001 + !byte $2A,%01010001 + !byte $2A,%01110001 + !byte $28,%01110010 + !byte $28,%10010010 + !byte $28,%10110010 + !byte $28,%11010010 + !byte $28,%00010011 + !byte $28,%00110011 + !byte $28,%01010011 + !byte $28,%01110011 + !byte $28,%10010011 + !byte $28,%10110011 + !byte $28,%11010011 + !byte $5E,%10101010 + !byte $5C,%10101010 + !byte $5A,%10101010 + !byte $58,%10101010 + !byte $56,%10101010 + !byte $54,%11001010 + !byte $52,%11001010 + !byte $50,%00001011 + !byte $4E,%00101011 + !byte $4C,%00101011 + !byte $4C,%01001011 + !byte $4A,%01001011 + !byte $48,%01101011 + !byte $46,%10001011 + !byte $46,%10101011 + !byte $44,%11001011 + !byte $42,%00001100 + !byte $40,%00101100 + !byte $40,%01001100 + !byte $3E,%01101100 + !byte $3C,%10101100 + !byte $3A,%00001101 + !byte $38,%01001101 + !byte $36,%10001101 + !byte $36,%10101101 + !byte $34,%00001110 + !byte $32,%01001110 + !byte $32,%01101110 + !byte $30,%11001110 + !byte $30,%00001111 + !byte $2E,%01001111 + !byte $2E,%01101111 + !byte $2C,%00010000 + !byte $2C,%00110000 + !byte $2A,%10110000 + !byte $2A,%11010000 + !byte $2A,%00010001 + !byte $28,%10110001 + !byte $28,%11010001 + !byte $28,%00010010 + !byte $28,%00110010 + !byte $28,%01010010 + !byte $5E,%10001010 + !byte $5C,%10001010 + !byte $5A,%10001010 + !byte $58,%10001010 + !byte $56,%10001010 + !byte $54,%10101010 + !byte $52,%10101010 + !byte $50,%11001010 + !byte $4E,%00001011 + !byte $4C,%00001011 + !byte $4A,%00101011 + !byte $48,%01001011 + !byte $46,%01101011 + !byte $44,%10101011 + !byte $42,%11001011 + !byte $40,%00001100 + !byte $3E,%01001100 + !byte $3C,%10001100 + !byte $3A,%10101100 + !byte $3A,%11001100 + !byte $38,%00001101 + !byte $38,%00101101 + !byte $36,%01101101 + !byte $34,%10101101 + !byte $34,%11001101 + !byte $32,%00101110 + !byte $30,%10001110 + !byte $30,%10101110 + !byte $2E,%00001111 + !byte $2E,%00101111 + !byte $2C,%10101111 + !byte $2C,%11001111 + !byte $2A,%01010000 + !byte $2A,%01110000 + !byte $2A,%10010000 + !byte $28,%01010001 + !byte $28,%01110001 + !byte $28,%10010001 + !byte $26,%10110010 + !byte $26,%11010010 + !byte $26,%00010011 + !byte $26,%00110011 + !byte $26,%01010011 + !byte $26,%01110011 + !byte $26,%10010011 + !byte $26,%10110011 + !byte $26,%11010011 + !byte $5E,%01101010 + !byte $5C,%01101010 + !byte $5A,%01101010 + !byte $58,%01101010 + !byte $56,%01101010 + !byte $54,%10001010 + !byte $52,%10001010 + !byte $50,%10101010 + !byte $4E,%11001010 + !byte $4C,%11001010 + !byte $4A,%00001011 + !byte $48,%00101011 + !byte $46,%01001011 + !byte $44,%01101011 + !byte $44,%10001011 + !byte $42,%10101011 + !byte $40,%11001011 + !byte $3E,%00001100 + !byte $3E,%00101100 + !byte $3C,%01001100 + !byte $3C,%01101100 + !byte $3A,%10001100 + !byte $38,%11001100 + !byte $36,%00101101 + !byte $36,%01001101 + !byte $34,%10001101 + !byte $32,%11001101 + !byte $32,%00001110 + !byte $30,%01001110 + !byte $30,%01101110 + !byte $2E,%11001110 + !byte $2C,%01001111 + !byte $2C,%01101111 + !byte $2C,%10001111 + !byte $2A,%00010000 + !byte $2A,%00110000 + !byte $28,%11010000 + !byte $28,%00010001 + !byte $28,%00110001 + !byte $26,%11010001 + !byte $26,%00010010 + !byte $26,%00110010 + !byte $26,%01010010 + !byte $26,%01110010 + !byte $26,%10010010 + !byte $5E,%01001010 + !byte $5C,%01001010 + !byte $5A,%01001010 + !byte $58,%01001010 + !byte $56,%01001010 + !byte $54,%01101010 + !byte $52,%01101010 + !byte $50,%10001010 + !byte $4E,%10101010 + !byte $4C,%10101010 + !byte $4A,%11001010 + !byte $48,%00001011 + !byte $46,%00101011 + !byte $44,%01001011 + !byte $42,%01101011 + !byte $42,%10001011 + !byte $40,%10101011 + !byte $3E,%11001011 + !byte $3C,%00101100 + !byte $3A,%01101100 + !byte $38,%10101100 + !byte $36,%00001101 + !byte $34,%01001101 + !byte $34,%01101101 + !byte $32,%10101101 + !byte $30,%00101110 + !byte $2E,%10001110 + !byte $2E,%10101110 + !byte $2C,%00001111 + !byte $2C,%00101111 + !byte $2A,%10101111 + !byte $2A,%11001111 + !byte $28,%01110000 + !byte $28,%10010000 + !byte $28,%10110000 + !byte $26,%01110001 + !byte $26,%10010001 + !byte $26,%10110001 + !byte $24,%00010011 + !byte $24,%00110011 + !byte $24,%01010011 + !byte $24,%01110011 + !byte $24,%10010011 + !byte $24,%10110011 + !byte $24,%11010011 + !byte $5E,%00101010 + !byte $5C,%00101010 + !byte $5A,%00101010 + !byte $58,%00101010 + !byte $56,%00101010 + !byte $54,%01001010 + !byte $52,%01001010 + !byte $50,%01101010 + !byte $4E,%01101010 + !byte $4E,%10001010 + !byte $4C,%10001010 + !byte $4A,%10101010 + !byte $48,%11001010 + !byte $46,%00001011 + !byte $44,%00101011 + !byte $42,%01001011 + !byte $40,%10001011 + !byte $3E,%10101011 + !byte $3C,%00001100 + !byte $3A,%00101100 + !byte $3A,%01001100 + !byte $38,%01101100 + !byte $38,%10001100 + !byte $36,%10101100 + !byte $36,%11001100 + !byte $34,%00101101 + !byte $32,%01101101 + !byte $32,%10001101 + !byte $30,%11001101 + !byte $30,%00001110 + !byte $2E,%01001110 + !byte $2E,%01101110 + !byte $2C,%10101110 + !byte $2C,%11001110 + !byte $2A,%01101111 + !byte $2A,%10001111 + !byte $28,%00010000 + !byte $28,%00110000 + !byte $28,%01010000 + !byte $26,%11010000 + !byte $26,%00010001 + !byte $26,%00110001 + !byte $26,%01010001 + !byte $24,%00110010 + !byte $24,%01010010 + !byte $24,%01110010 + !byte $24,%10010010 + !byte $24,%10110010 + !byte $24,%11010010 + !byte $5E,%00001010 + !byte $5C,%00001010 + !byte $5A,%00001010 + !byte $58,%00001010 + !byte $56,%00001010 + !byte $54,%00101010 + !byte $52,%00101010 + !byte $50,%01001010 + !byte $4E,%01001010 + !byte $4C,%01101010 + !byte $4A,%10001010 + !byte $48,%10101010 + !byte $46,%11001010 + !byte $44,%00001011 + !byte $42,%00101011 + !byte $40,%01001011 + !byte $40,%01101011 + !byte $3E,%10001011 + !byte $3C,%10101011 + !byte $3C,%11001011 + !byte $3A,%00001100 + !byte $38,%01001100 + !byte $36,%10001100 + !byte $34,%11001100 + !byte $34,%00001101 + !byte $32,%01001101 + !byte $30,%10001101 + !byte $30,%10101101 + !byte $2E,%00001110 + !byte $2E,%00101110 + !byte $2C,%10001110 + !byte $2A,%00001111 + !byte $2A,%00101111 + !byte $2A,%01001111 + !byte $28,%10101111 + !byte $28,%11001111 + !byte $26,%01110000 + !byte $26,%10010000 + !byte $26,%10110000 + !byte $24,%01110001 + !byte $24,%10010001 + !byte $24,%10110001 + !byte $24,%11010001 + !byte $24,%00010010 + !byte $22,%10010011 + !byte $22,%10110011 + !byte $22,%11010011 + !byte $5E,%11001001 + !byte $5C,%11001001 + !byte $5A,%11001001 + !byte $58,%11001001 + !byte $56,%11001001 + !byte $54,%00001010 + !byte $52,%00001010 + !byte $50,%00101010 + !byte $4E,%00101010 + !byte $4C,%01001010 + !byte $4A,%01101010 + !byte $48,%10001010 + !byte $46,%10101010 + !byte $44,%11001010 + !byte $42,%00001011 + !byte $40,%00101011 + !byte $3E,%01101011 + !byte $3C,%10001011 + !byte $3A,%11001011 + !byte $38,%00101100 + !byte $36,%01101100 + !byte $34,%10101100 + !byte $32,%00001101 + !byte $32,%00101101 + !byte $30,%01101101 + !byte $2E,%11001101 + !byte $2C,%01001110 + !byte $2C,%01101110 + !byte $2A,%10101110 + !byte $2A,%11001110 + !byte $28,%01001111 + !byte $28,%01101111 + !byte $28,%10001111 + !byte $26,%00010000 + !byte $26,%00110000 + !byte $26,%01010000 + !byte $24,%11010000 + !byte $24,%00010001 + !byte $24,%00110001 + !byte $24,%01010001 + !byte $22,%01010010 + !byte $22,%01110010 + !byte $22,%10010010 + !byte $22,%10110010 + !byte $22,%11010010 + !byte $22,%00010011 + !byte $22,%00110011 + !byte $22,%01010011 + !byte $22,%01110011 + !byte $5E,%10101001 + !byte $5C,%10101001 + !byte $5A,%10101001 + !byte $58,%10101001 + !byte $56,%10101001 + !byte $54,%11001001 + !byte $52,%11001001 + !byte $50,%00001010 + !byte $4E,%00001010 + !byte $4C,%00101010 + !byte $4A,%01001010 + !byte $48,%01101010 + !byte $46,%10001010 + !byte $44,%10101010 + !byte $42,%11001010 + !byte $40,%00001011 + !byte $3E,%01001011 + !byte $3C,%01101011 + !byte $3A,%10101011 + !byte $38,%11001011 + !byte $38,%00001100 + !byte $36,%00101100 + !byte $36,%01001100 + !byte $34,%01101100 + !byte $34,%10001100 + !byte $32,%11001100 + !byte $30,%00101101 + !byte $30,%01001101 + !byte $2E,%10001101 + !byte $2E,%10101101 + !byte $2C,%00001110 + !byte $2C,%00101110 + !byte $2A,%01101110 + !byte $2A,%10001110 + !byte $28,%00001111 + !byte $28,%00101111 + !byte $26,%10101111 + !byte $26,%11001111 + !byte $24,%01110000 + !byte $24,%10010000 + !byte $24,%10110000 + !byte $22,%10010001 + !byte $22,%10110001 + !byte $22,%11010001 + !byte $22,%00010010 + !byte $22,%00110010 + !byte $5E,%10001001 + !byte $5C,%10001001 + !byte $5A,%10001001 + !byte $58,%10001001 + !byte $56,%10001001 + !byte $54,%10101001 + !byte $52,%10101001 + !byte $50,%11001001 + !byte $4E,%11001001 + !byte $4C,%00001010 + !byte $4A,%00101010 + !byte $48,%01001010 + !byte $46,%01101010 + !byte $44,%10001010 + !byte $42,%10101010 + !byte $40,%11001010 + !byte $3E,%00001011 + !byte $3E,%00101011 + !byte $3C,%01001011 + !byte $3A,%01101011 + !byte $3A,%10001011 + !byte $38,%10101011 + !byte $36,%00001100 + !byte $34,%01001100 + !byte $32,%10001100 + !byte $32,%10101100 + !byte $30,%00001101 + !byte $2E,%01001101 + !byte $2E,%01101101 + !byte $2C,%10101101 + !byte $2C,%11001101 + !byte $2A,%00101110 + !byte $2A,%01001110 + !byte $28,%10101110 + !byte $28,%11001110 + !byte $26,%01101111 + !byte $26,%10001111 + !byte $24,%00110000 + !byte $24,%01010000 + !byte $22,%00010001 + !byte $22,%00110001 + !byte $22,%01010001 + !byte $22,%01110001 + !byte $20,%10010010 + !byte $20,%10110010 + !byte $20,%11010010 + !byte $20,%00010011 + !byte $20,%00110011 + !byte $20,%01010011 + !byte $20,%01110011 + !byte $20,%10010011 + !byte $20,%10110011 + !byte $20,%11010011 + !byte $5E,%01101001 + !byte $5C,%01101001 + !byte $5A,%01101001 + !byte $58,%01101001 + !byte $56,%01101001 + !byte $54,%10001001 + !byte $52,%10001001 + !byte $50,%10101001 + !byte $4E,%10101001 + !byte $4C,%11001001 + !byte $4A,%00001010 + !byte $48,%00101010 + !byte $46,%01001010 + !byte $44,%01101010 + !byte $42,%10001010 + !byte $40,%10101010 + !byte $3E,%11001010 + !byte $3C,%00101011 + !byte $3A,%01001011 + !byte $38,%10001011 + !byte $36,%11001011 + !byte $34,%00101100 + !byte $32,%01101100 + !byte $30,%10101100 + !byte $30,%11001100 + !byte $2E,%00101101 + !byte $2C,%10001101 + !byte $2A,%00001110 + !byte $28,%01101110 + !byte $28,%10001110 + !byte $26,%00001111 + !byte $26,%00101111 + !byte $26,%01001111 + !byte $24,%10101111 + !byte $24,%11001111 + !byte $24,%00010000 + !byte $22,%10010000 + !byte $22,%10110000 + !byte $22,%11010000 + !byte $20,%10110001 + !byte $20,%11010001 + !byte $20,%00010010 + !byte $20,%00110010 + !byte $20,%01010010 + !byte $20,%01110010 + !byte $5E,%01001001 + !byte $5C,%01001001 + !byte $5A,%01001001 + !byte $58,%01001001 + !byte $56,%01001001 + !byte $54,%01101001 + !byte $52,%01101001 + !byte $50,%10001001 + !byte $4E,%10001001 + !byte $4C,%10101001 + !byte $4A,%11001001 + !byte $48,%00001010 + !byte $46,%00001010 + !byte $46,%00101010 + !byte $44,%00101010 + !byte $44,%01001010 + !byte $42,%01101010 + !byte $40,%10001010 + !byte $3E,%10101010 + !byte $3C,%11001010 + !byte $3C,%00001011 + !byte $3A,%00101011 + !byte $38,%01101011 + !byte $36,%10001011 + !byte $36,%10101011 + !byte $34,%11001011 + !byte $34,%00001100 + !byte $32,%01001100 + !byte $30,%10001100 + !byte $2E,%11001100 + !byte $2E,%00001101 + !byte $2C,%01001101 + !byte $2C,%01101101 + !byte $2A,%10101101 + !byte $2A,%11001101 + !byte $28,%00101110 + !byte $28,%01001110 + !byte $26,%10101110 + !byte $26,%11001110 + !byte $24,%01101111 + !byte $24,%10001111 + !byte $22,%00110000 + !byte $22,%01010000 + !byte $22,%01110000 + !byte $20,%00110001 + !byte $20,%01010001 + !byte $20,%01110001 + !byte $20,%10010001 + !byte $1E,%11010010 + !byte $1E,%00010011 + !byte $1E,%00110011 + !byte $1E,%01010011 + !byte $1E,%01110011 + !byte $1E,%10010011 + !byte $1E,%10110011 + !byte $1E,%11010011 + !byte $5E,%00101001 + !byte $5C,%00101001 + !byte $5A,%00101001 + !byte $58,%00101001 + !byte $56,%00101001 + !byte $54,%01001001 + !byte $52,%01001001 + !byte $50,%01101001 + !byte $4E,%01101001 + !byte $4C,%10001001 + !byte $4A,%10101001 + !byte $48,%10101001 + !byte $48,%11001001 + !byte $46,%11001001 + !byte $44,%00001010 + !byte $42,%00101010 + !byte $42,%01001010 + !byte $40,%01101010 + !byte $3E,%10001010 + !byte $3C,%10101010 + !byte $3A,%00001011 + !byte $38,%00101011 + !byte $38,%01001011 + !byte $36,%01101011 + !byte $34,%10101011 + !byte $32,%00001100 + !byte $32,%00101100 + !byte $30,%01001100 + !byte $30,%01101100 + !byte $2E,%10101100 + !byte $2C,%00001101 + !byte $2C,%00101101 + !byte $2A,%01101101 + !byte $2A,%10001101 + !byte $28,%00001110 + !byte $26,%01101110 + !byte $26,%10001110 + !byte $24,%00101111 + !byte $24,%01001111 + !byte $22,%10101111 + !byte $22,%11001111 + !byte $22,%00010000 + !byte $20,%10110000 + !byte $20,%11010000 + !byte $20,%00010001 + !byte $1E,%11010001 + !byte $1E,%00010010 + !byte $1E,%00110010 + !byte $1E,%01010010 + !byte $1E,%01110010 + !byte $1E,%10010010 + !byte $1E,%10110010 + !byte $5E,%00001001 + !byte $5C,%00001001 + !byte $5A,%00001001 + !byte $58,%00001001 + !byte $56,%00001001 + !byte $54,%00101001 + !byte $52,%00101001 + !byte $50,%01001001 + !byte $4E,%01001001 + !byte $4C,%01101001 + !byte $4A,%10001001 + !byte $48,%10001001 + !byte $46,%10101001 + !byte $44,%11001001 + !byte $42,%00001010 + !byte $40,%00101010 + !byte $40,%01001010 + !byte $3E,%01101010 + !byte $3C,%10001010 + !byte $3A,%11001010 + !byte $38,%00001011 + !byte $36,%01001011 + !byte $34,%10001011 + !byte $32,%11001011 + !byte $30,%00101100 + !byte $2E,%01101100 + !byte $2E,%10001100 + !byte $2C,%11001100 + !byte $2A,%01001101 + !byte $28,%10101101 + !byte $28,%11001101 + !byte $26,%00101110 + !byte $26,%01001110 + !byte $24,%10101110 + !byte $24,%11001110 + !byte $24,%00001111 + !byte $22,%01101111 + !byte $22,%10001111 + !byte $20,%01010000 + !byte $20,%01110000 + !byte $20,%10010000 + !byte $1E,%01010001 + !byte $1E,%01110001 + !byte $1E,%10010001 + !byte $1E,%10110001 + !byte $1C,%01010011 + !byte $1C,%01110011 + !byte $1C,%10010011 + !byte $1C,%10110011 + !byte $1C,%11010011 + !byte $5E,%11001000 + !byte $5C,%11001000 + !byte $5A,%11001000 + !byte $58,%11001000 + !byte $56,%11001000 + !byte $54,%00001001 + !byte $52,%00001001 + !byte $50,%00101001 + !byte $4E,%00101001 + !byte $4C,%01001001 + !byte $4A,%01001001 + !byte $4A,%01101001 + !byte $48,%01101001 + !byte $46,%10001001 + !byte $44,%10101001 + !byte $42,%11001001 + !byte $40,%00001010 + !byte $3E,%01001010 + !byte $3C,%01101010 + !byte $3A,%10001010 + !byte $3A,%10101010 + !byte $38,%11001010 + !byte $36,%00101011 + !byte $34,%01001011 + !byte $34,%01101011 + !byte $32,%10001011 + !byte $32,%10101011 + !byte $30,%00001100 + !byte $2E,%01001100 + !byte $2C,%10001100 + !byte $2C,%10101100 + !byte $2A,%00001101 + !byte $2A,%00101101 + !byte $28,%01101101 + !byte $28,%10001101 + !byte $26,%00001110 + !byte $24,%01101110 + !byte $24,%10001110 + !byte $22,%00101111 + !byte $22,%01001111 + !byte $20,%11001111 + !byte $20,%00010000 + !byte $20,%00110000 + !byte $1E,%10110000 + !byte $1E,%11010000 + !byte $1E,%00010001 + !byte $1E,%00110001 + !byte $1C,%00110010 + !byte $1C,%01010010 + !byte $1C,%01110010 + !byte $1C,%10010010 + !byte $1C,%10110010 + !byte $1C,%11010010 + !byte $1C,%00010011 + !byte $1C,%00110011 + !byte $5E,%10101000 + !byte $5C,%10101000 + !byte $5A,%10101000 + !byte $58,%10101000 + !byte $56,%10101000 + !byte $54,%11001000 + !byte $52,%11001000 + !byte $50,%00001001 + !byte $4E,%00001001 + !byte $4C,%00101001 + !byte $4A,%00101001 + !byte $48,%01001001 + !byte $46,%01101001 + !byte $44,%10001001 + !byte $42,%10101001 + !byte $40,%11001001 + !byte $3E,%00001010 + !byte $3E,%00101010 + !byte $3C,%01001010 + !byte $3A,%01101010 + !byte $38,%10101010 + !byte $36,%11001010 + !byte $36,%00001011 + !byte $34,%00101011 + !byte $32,%01101011 + !byte $30,%10101011 + !byte $30,%11001011 + !byte $2E,%00001100 + !byte $2E,%00101100 + !byte $2C,%01101100 + !byte $2A,%10101100 + !byte $2A,%11001100 + !byte $28,%00101101 + !byte $28,%01001101 + !byte $26,%10101101 + !byte $26,%11001101 + !byte $24,%00101110 + !byte $24,%01001110 + !byte $22,%10101110 + !byte $22,%11001110 + !byte $22,%00001111 + !byte $20,%01101111 + !byte $20,%10001111 + !byte $20,%10101111 + !byte $1E,%01010000 + !byte $1E,%01110000 + !byte $1E,%10010000 + !byte $1C,%01110001 + !byte $1C,%10010001 + !byte $1C,%10110001 + !byte $1C,%11010001 + !byte $1C,%00010010 + !byte $5E,%10001000 + !byte $5C,%10001000 + !byte $5A,%10001000 + !byte $58,%10001000 + !byte $56,%10001000 + !byte $54,%10101000 + !byte $52,%10101000 + !byte $50,%10101000 + !byte $50,%11001000 + !byte $4E,%11001000 + !byte $4C,%00001001 + !byte $4A,%00001001 + !byte $48,%00101001 + !byte $46,%01001001 + !byte $44,%01101001 + !byte $42,%10001001 + !byte $40,%10101001 + !byte $3E,%11001001 + !byte $3C,%00101010 + !byte $3A,%01001010 + !byte $38,%01101010 + !byte $38,%10001010 + !byte $36,%10101010 + !byte $34,%00001011 + !byte $32,%01001011 + !byte $30,%10001011 + !byte $2E,%11001011 + !byte $2C,%00101100 + !byte $2C,%01001100 + !byte $2A,%10001100 + !byte $28,%00001101 + !byte $26,%01101101 + !byte $26,%10001101 + !byte $24,%11001101 + !byte $24,%00001110 + !byte $22,%01101110 + !byte $22,%10001110 + !byte $20,%00101111 + !byte $20,%01001111 + !byte $1E,%11001111 + !byte $1E,%00010000 + !byte $1E,%00110000 + !byte $1C,%11010000 + !byte $1C,%00010001 + !byte $1C,%00110001 + !byte $1C,%01010001 + !byte $1A,%01110010 + !byte $1A,%10010010 + !byte $1A,%10110010 + !byte $1A,%11010010 + !byte $1A,%00010011 + !byte $1A,%00110011 + !byte $1A,%01010011 + !byte $1A,%01110011 + !byte $1A,%10010011 + !byte $1A,%10110011 + !byte $1A,%11010011 + !byte $5E,%01101000 + !byte $5C,%01101000 + !byte $5A,%01101000 + !byte $58,%01101000 + !byte $56,%01101000 + !byte $54,%10001000 + !byte $52,%10001000 + !byte $50,%10001000 + !byte $4E,%10101000 + !byte $4C,%11001000 + !byte $4A,%11001000 + !byte $48,%00001001 + !byte $46,%00101001 + !byte $44,%01001001 + !byte $42,%01101001 + !byte $40,%10001001 + !byte $3E,%10101001 + !byte $3C,%11001001 + !byte $3C,%00001010 + !byte $3A,%00101010 + !byte $38,%01001010 + !byte $36,%10001010 + !byte $34,%11001010 + !byte $32,%00101011 + !byte $30,%01001011 + !byte $30,%01101011 + !byte $2E,%10101011 + !byte $2C,%00001100 + !byte $2A,%01001100 + !byte $2A,%01101100 + !byte $28,%10101100 + !byte $28,%11001100 + !byte $26,%00101101 + !byte $26,%01001101 + !byte $24,%10101101 + !byte $22,%00101110 + !byte $22,%01001110 + !byte $20,%10101110 + !byte $20,%11001110 + !byte $20,%00001111 + !byte $1E,%01101111 + !byte $1E,%10001111 + !byte $1E,%10101111 + !byte $1C,%01010000 + !byte $1C,%01110000 + !byte $1C,%10010000 + !byte $1C,%10110000 + !byte $1A,%10010001 + !byte $1A,%10110001 + !byte $1A,%11010001 + !byte $1A,%00010010 + !byte $1A,%00110010 + !byte $1A,%01010010 + !byte $5E,%01001000 + !byte $5C,%01001000 + !byte $5A,%01001000 + !byte $58,%01001000 + !byte $56,%01001000 + !byte $54,%01101000 + !byte $52,%01101000 + !byte $50,%01101000 + !byte $4E,%10001000 + !byte $4C,%10101000 + !byte $4A,%10101000 + !byte $48,%11001000 + !byte $46,%00001001 + !byte $44,%00101001 + !byte $42,%01001001 + !byte $40,%01101001 + !byte $3E,%10001001 + !byte $3C,%10101001 + !byte $3A,%00001010 + !byte $38,%00101010 + !byte $36,%01101010 + !byte $34,%10001010 + !byte $34,%10101010 + !byte $32,%11001010 + !byte $32,%00001011 + !byte $30,%00101011 + !byte $2E,%01101011 + !byte $2E,%10001011 + !byte $2C,%10101011 + !byte $2C,%11001011 + !byte $2A,%00101100 + !byte $28,%10001100 + !byte $26,%00001101 + !byte $24,%01101101 + !byte $24,%10001101 + !byte $22,%11001101 + !byte $22,%00001110 + !byte $20,%01101110 + !byte $20,%10001110 + !byte $1E,%00101111 + !byte $1E,%01001111 + !byte $1C,%00010000 + !byte $1C,%00110000 + !byte $1A,%00010001 + !byte $1A,%00110001 + !byte $1A,%01010001 + !byte $1A,%01110001 + !byte $18,%10110010 + !byte $18,%11010010 + !byte $18,%00010011 + !byte $18,%00110011 + !byte $18,%01010011 + !byte $18,%01110011 + !byte $18,%10010011 + !byte $18,%10110011 + !byte $18,%11010011 + !byte $5E,%00101000 + !byte $5C,%00101000 + !byte $5A,%00101000 + !byte $58,%00101000 + !byte $56,%00101000 + !byte $54,%01001000 + !byte $52,%01001000 + !byte $50,%01001000 + !byte $4E,%01101000 + !byte $4C,%10001000 + !byte $4A,%10001000 + !byte $48,%10101000 + !byte $46,%11001000 + !byte $44,%00001001 + !byte $42,%00101001 + !byte $40,%01001001 + !byte $3E,%01101001 + !byte $3C,%10001001 + !byte $3A,%10101001 + !byte $3A,%11001001 + !byte $38,%00001010 + !byte $36,%00101010 + !byte $36,%01001010 + !byte $34,%01101010 + !byte $32,%10101010 + !byte $30,%00001011 + !byte $2E,%01001011 + !byte $2C,%10001011 + !byte $2A,%11001011 + !byte $2A,%00001100 + !byte $28,%01001100 + !byte $28,%01101100 + !byte $26,%10101100 + !byte $26,%11001100 + !byte $24,%00101101 + !byte $24,%01001101 + !byte $22,%10001101 + !byte $22,%10101101 + !byte $20,%00101110 + !byte $20,%01001110 + !byte $1E,%11001110 + !byte $1E,%00001111 + !byte $1C,%10001111 + !byte $1C,%10101111 + !byte $1C,%11001111 + !byte $1A,%01110000 + !byte $1A,%10010000 + !byte $1A,%10110000 + !byte $1A,%11010000 + !byte $18,%10110001 + !byte $18,%11010001 + !byte $18,%00010010 + !byte $18,%00110010 + !byte $18,%01010010 + !byte $18,%01110010 + !byte $18,%10010010 + !byte $5E,%00001000 + !byte $5C,%00001000 + !byte $5A,%00001000 + !byte $58,%00001000 + !byte $56,%00001000 + !byte $54,%00101000 + !byte $52,%00101000 + !byte $50,%00101000 + !byte $4E,%01001000 + !byte $4C,%01101000 + !byte $4A,%01101000 + !byte $48,%10001000 + !byte $46,%10101000 + !byte $44,%11001000 + !byte $42,%00001001 + !byte $40,%00101001 + !byte $3E,%01001001 + !byte $3C,%01101001 + !byte $3A,%10001001 + !byte $38,%11001001 + !byte $36,%00001010 + !byte $34,%01001010 + !byte $32,%10001010 + !byte $30,%11001010 + !byte $2E,%00001011 + !byte $2E,%00101011 + !byte $2C,%01101011 + !byte $2A,%10101011 + !byte $28,%00101100 + !byte $26,%01101100 + !byte $26,%10001100 + !byte $24,%11001100 + !byte $24,%00001101 + !byte $22,%01101101 + !byte $20,%11001101 + !byte $20,%00001110 + !byte $1E,%01101110 + !byte $1E,%10001110 + !byte $1E,%10101110 + !byte $1C,%00101111 + !byte $1C,%01001111 + !byte $1C,%01101111 + !byte $1A,%00010000 + !byte $1A,%00110000 + !byte $1A,%01010000 + !byte $18,%00110001 + !byte $18,%01010001 + !byte $18,%01110001 + !byte $18,%10010001 + !byte $16,%00110011 + !byte $16,%01010011 + !byte $16,%01110011 + !byte $16,%10010011 + !byte $16,%10110011 + !byte $16,%11010011 + !byte $5E,%11000111 + !byte $5C,%11000111 + !byte $5A,%11000111 + !byte $58,%11000111 + !byte $56,%11000111 + !byte $54,%00001000 + !byte $52,%00001000 + !byte $50,%00001000 + !byte $4E,%00101000 + !byte $4C,%00101000 + !byte $4C,%01001000 + !byte $4A,%01001000 + !byte $48,%01101000 + !byte $46,%10001000 + !byte $44,%10101000 + !byte $42,%11001000 + !byte $40,%00001001 + !byte $3E,%00101001 + !byte $3C,%01001001 + !byte $3A,%01101001 + !byte $38,%10001001 + !byte $38,%10101001 + !byte $36,%11001001 + !byte $34,%00101010 + !byte $32,%01001010 + !byte $32,%01101010 + !byte $30,%10001010 + !byte $30,%10101010 + !byte $2E,%11001010 + !byte $2C,%00101011 + !byte $2C,%01001011 + !byte $2A,%01101011 + !byte $2A,%10001011 + !byte $28,%11001011 + !byte $28,%00001100 + !byte $26,%01001100 + !byte $24,%10101100 + !byte $22,%00101101 + !byte $22,%01001101 + !byte $20,%10001101 + !byte $20,%10101101 + !byte $1E,%00101110 + !byte $1E,%01001110 + !byte $1C,%11001110 + !byte $1C,%00001111 + !byte $1A,%10001111 + !byte $1A,%10101111 + !byte $1A,%11001111 + !byte $18,%10010000 + !byte $18,%10110000 + !byte $18,%11010000 + !byte $18,%00010001 + !byte $16,%00010010 + !byte $16,%00110010 + !byte $16,%01010010 + !byte $16,%01110010 + !byte $16,%10010010 + !byte $16,%10110010 + !byte $16,%11010010 + !byte $16,%00010011 + !byte $5E,%10100111 + !byte $5C,%10100111 + !byte $5A,%10100111 + !byte $58,%10100111 + !byte $56,%10100111 + !byte $54,%11000111 + !byte $52,%11000111 + !byte $50,%11000111 + !byte $4E,%00001000 + !byte $4C,%00001000 + !byte $4A,%00101000 + !byte $48,%01001000 + !byte $46,%01101000 + !byte $44,%01101000 + !byte $44,%10001000 + !byte $42,%10001000 + !byte $42,%10101000 + !byte $40,%10101000 + !byte $40,%11001000 + !byte $3E,%00001001 + !byte $3C,%00101001 + !byte $3A,%01001001 + !byte $38,%01101001 + !byte $36,%10101001 + !byte $34,%11001001 + !byte $34,%00001010 + !byte $32,%00101010 + !byte $30,%01101010 + !byte $2E,%10101010 + !byte $2C,%00001011 + !byte $2A,%01001011 + !byte $28,%10001011 + !byte $28,%10101011 + !byte $26,%00001100 + !byte $26,%00101100 + !byte $24,%01101100 + !byte $24,%10001100 + !byte $22,%11001100 + !byte $22,%00001101 + !byte $20,%01001101 + !byte $20,%01101101 + !byte $1E,%11001101 + !byte $1E,%00001110 + !byte $1C,%10001110 + !byte $1C,%10101110 + !byte $1A,%00101111 + !byte $1A,%01001111 + !byte $1A,%01101111 + !byte $18,%00110000 + !byte $18,%01010000 + !byte $18,%01110000 + !byte $16,%00110001 + !byte $16,%01010001 + !byte $16,%01110001 + !byte $16,%10010001 + !byte $16,%10110001 + !byte $16,%11010001 + !byte $5E,%10000111 + !byte $5C,%10000111 + !byte $5A,%10000111 + !byte $58,%10000111 + !byte $56,%10000111 + !byte $54,%10000111 + !byte $54,%10100111 + !byte $52,%10100111 + !byte $50,%10100111 + !byte $4E,%11000111 + !byte $4C,%11000111 + !byte $4A,%00001000 + !byte $48,%00101000 + !byte $46,%01001000 + !byte $44,%01001000 + !byte $42,%01101000 + !byte $40,%10001000 + !byte $3E,%10101000 + !byte $3E,%11001000 + !byte $3C,%00001001 + !byte $3A,%00101001 + !byte $38,%01001001 + !byte $36,%10001001 + !byte $34,%10101001 + !byte $32,%00001010 + !byte $30,%01001010 + !byte $2E,%01101010 + !byte $2E,%10001010 + !byte $2C,%11001010 + !byte $2A,%00101011 + !byte $28,%01101011 + !byte $26,%11001011 + !byte $24,%00101100 + !byte $24,%01001100 + !byte $22,%10001100 + !byte $22,%10101100 + !byte $20,%00101101 + !byte $1E,%10001101 + !byte $1E,%10101101 + !byte $1C,%00101110 + !byte $1C,%01001110 + !byte $1C,%01101110 + !byte $1A,%11001110 + !byte $1A,%00001111 + !byte $18,%10101111 + !byte $18,%11001111 + !byte $18,%00010000 + !byte $16,%10110000 + !byte $16,%11010000 + !byte $16,%00010001 + !byte $14,%00110010 + !byte $14,%01010010 + !byte $14,%01110010 + !byte $14,%10010010 + !byte $14,%10110010 + !byte $14,%11010010 + !byte $14,%00010011 + !byte $14,%00110011 + !byte $14,%01010011 + !byte $14,%01110011 + !byte $14,%10010011 + !byte $14,%10110011 + !byte $14,%11010011 + !byte $5E,%01100111 + !byte $5C,%01100111 + !byte $5A,%01100111 + !byte $58,%01100111 + !byte $56,%01100111 + !byte $54,%01100111 + !byte $52,%10000111 + !byte $50,%10000111 + !byte $4E,%10100111 + !byte $4C,%10100111 + !byte $4A,%11000111 + !byte $48,%00001000 + !byte $46,%00001000 + !byte $46,%00101000 + !byte $44,%00101000 + !byte $42,%01001000 + !byte $40,%01101000 + !byte $3E,%10001000 + !byte $3C,%10101000 + !byte $3C,%11001000 + !byte $3A,%00001001 + !byte $38,%00101001 + !byte $36,%01001001 + !byte $36,%01101001 + !byte $34,%10001001 + !byte $32,%11001001 + !byte $30,%00001010 + !byte $30,%00101010 + !byte $2E,%01001010 + !byte $2C,%10001010 + !byte $2C,%10101010 + !byte $2A,%11001010 + !byte $2A,%00001011 + !byte $28,%01001011 + !byte $26,%10001011 + !byte $26,%10101011 + !byte $24,%00001100 + !byte $22,%01101100 + !byte $20,%11001100 + !byte $20,%00001101 + !byte $1E,%01001101 + !byte $1E,%01101101 + !byte $1C,%11001101 + !byte $1C,%00001110 + !byte $1A,%10001110 + !byte $1A,%10101110 + !byte $18,%01001111 + !byte $18,%01101111 + !byte $18,%10001111 + !byte $16,%00110000 + !byte $16,%01010000 + !byte $16,%01110000 + !byte $16,%10010000 + !byte $14,%01110001 + !byte $14,%10010001 + !byte $14,%10110001 + !byte $14,%11010001 + !byte $14,%00010010 + !byte $5E,%01000111 + !byte $5C,%01000111 + !byte $5A,%01000111 + !byte $58,%01000111 + !byte $56,%01000111 + !byte $54,%01000111 + !byte $52,%01100111 + !byte $50,%01100111 + !byte $4E,%10000111 + !byte $4C,%10000111 + !byte $4A,%10100111 + !byte $48,%11000111 + !byte $46,%11000111 + !byte $44,%00001000 + !byte $42,%00101000 + !byte $40,%01001000 + !byte $3E,%01101000 + !byte $3C,%10001000 + !byte $3A,%11001000 + !byte $38,%00001001 + !byte $36,%00101001 + !byte $34,%01101001 + !byte $32,%10001001 + !byte $32,%10101001 + !byte $30,%11001001 + !byte $2E,%00101010 + !byte $2C,%01101010 + !byte $2A,%10101010 + !byte $28,%00001011 + !byte $28,%00101011 + !byte $26,%01001011 + !byte $26,%01101011 + !byte $24,%10101011 + !byte $24,%11001011 + !byte $22,%00101100 + !byte $22,%01001100 + !byte $20,%10001100 + !byte $20,%10101100 + !byte $1E,%00001101 + !byte $1E,%00101101 + !byte $1C,%10001101 + !byte $1C,%10101101 + !byte $1A,%00101110 + !byte $1A,%01001110 + !byte $1A,%01101110 + !byte $18,%11001110 + !byte $18,%00001111 + !byte $18,%00101111 + !byte $16,%10101111 + !byte $16,%11001111 + !byte $16,%00010000 + !byte $14,%10110000 + !byte $14,%11010000 + !byte $14,%00010001 + !byte $14,%00110001 + !byte $14,%01010001 + !byte $12,%01110010 + !byte $12,%10010010 + !byte $12,%10110010 + !byte $12,%11010010 + !byte $12,%00010011 + !byte $12,%00110011 + !byte $12,%01010011 + !byte $12,%01110011 + !byte $12,%10010011 + !byte $12,%10110011 + !byte $12,%11010011 + !byte $5E,%00100111 + !byte $5C,%00100111 + !byte $5A,%00100111 + !byte $58,%00100111 + !byte $56,%00100111 + !byte $54,%00100111 + !byte $52,%01000111 + !byte $50,%01000111 + !byte $4E,%01100111 + !byte $4C,%01100111 + !byte $4A,%10000111 + !byte $48,%10100111 + !byte $46,%10100111 + !byte $44,%11000111 + !byte $42,%00001000 + !byte $40,%00101000 + !byte $3E,%01001000 + !byte $3C,%01101000 + !byte $3A,%10001000 + !byte $3A,%10101000 + !byte $38,%11001000 + !byte $36,%00001001 + !byte $34,%01001001 + !byte $32,%01101001 + !byte $30,%10101001 + !byte $2E,%00001010 + !byte $2C,%00101010 + !byte $2C,%01001010 + !byte $2A,%10001010 + !byte $28,%11001010 + !byte $26,%00101011 + !byte $24,%10001011 + !byte $22,%11001011 + !byte $22,%00001100 + !byte $20,%01001100 + !byte $20,%01101100 + !byte $1E,%11001100 + !byte $1C,%01001101 + !byte $1C,%01101101 + !byte $1A,%11001101 + !byte $1A,%00001110 + !byte $18,%10001110 + !byte $18,%10101110 + !byte $16,%01001111 + !byte $16,%01101111 + !byte $16,%10001111 + !byte $14,%01010000 + !byte $14,%01110000 + !byte $14,%10010000 + !byte $12,%10010001 + !byte $12,%10110001 + !byte $12,%11010001 + !byte $12,%00010010 + !byte $12,%00110010 + !byte $12,%01010010 + !byte $5E,%00000111 + !byte $5C,%00000111 + !byte $5A,%00000111 + !byte $58,%00000111 + !byte $56,%00000111 + !byte $54,%00000111 + !byte $52,%00100111 + !byte $50,%00100111 + !byte $4E,%01000111 + !byte $4C,%01000111 + !byte $4A,%01100111 + !byte $48,%10000111 + !byte $46,%10000111 + !byte $44,%10100111 + !byte $42,%11000111 + !byte $40,%00001000 + !byte $3E,%00101000 + !byte $3C,%01001000 + !byte $3A,%01101000 + !byte $38,%10101000 + !byte $36,%11001000 + !byte $34,%00001001 + !byte $34,%00101001 + !byte $32,%01001001 + !byte $30,%10001001 + !byte $2E,%10101001 + !byte $2E,%11001001 + !byte $2C,%00001010 + !byte $2A,%01001010 + !byte $2A,%01101010 + !byte $28,%10001010 + !byte $28,%10101010 + !byte $26,%00001011 + !byte $24,%01001011 + !byte $24,%01101011 + !byte $22,%10101011 + !byte $20,%00101100 + !byte $1E,%10001100 + !byte $1E,%10101100 + !byte $1C,%00001101 + !byte $1C,%00101101 + !byte $1A,%10001101 + !byte $1A,%10101101 + !byte $18,%00101110 + !byte $18,%01001110 + !byte $18,%01101110 + !byte $16,%00001111 + !byte $16,%00101111 + !byte $14,%11001111 + !byte $14,%00010000 + !byte $14,%00110000 + !byte $12,%11010000 + !byte $12,%00010001 + !byte $12,%00110001 + !byte $12,%01010001 + !byte $12,%01110001 + !byte $10,%11010010 + !byte $10,%00010011 + !byte $10,%00110011 + !byte $10,%01010011 + !byte $10,%01110011 + !byte $10,%10010011 + !byte $10,%10110011 + !byte $10,%11010011 + !byte $5E,%11000110 + !byte $5C,%11000110 + !byte $5A,%11000110 + !byte $58,%11000110 + !byte $56,%11000110 + !byte $54,%11000110 + !byte $52,%00000111 + !byte $50,%00000111 + !byte $4E,%00100111 + !byte $4C,%00100111 + !byte $4A,%01000111 + !byte $48,%01100111 + !byte $46,%01100111 + !byte $44,%10000111 + !byte $42,%10100111 + !byte $40,%11000111 + !byte $3E,%00001000 + !byte $3C,%00101000 + !byte $3A,%01001000 + !byte $38,%01101000 + !byte $38,%10001000 + !byte $36,%10101000 + !byte $34,%11001000 + !byte $32,%00101001 + !byte $30,%01001001 + !byte $30,%01101001 + !byte $2E,%10001001 + !byte $2C,%11001001 + !byte $2A,%00101010 + !byte $28,%01101010 + !byte $26,%10101010 + !byte $26,%11001010 + !byte $24,%00101011 + !byte $22,%01101011 + !byte $22,%10001011 + !byte $20,%11001011 + !byte $20,%00001100 + !byte $1E,%01001100 + !byte $1E,%01101100 + !byte $1C,%10101100 + !byte $1C,%11001100 + !byte $1A,%01001101 + !byte $1A,%01101101 + !byte $18,%11001101 + !byte $18,%00001110 + !byte $16,%10001110 + !byte $16,%10101110 + !byte $16,%11001110 + !byte $14,%01101111 + !byte $14,%10001111 + !byte $14,%10101111 + !byte $12,%01010000 + !byte $12,%01110000 + !byte $12,%10010000 + !byte $12,%10110000 + !byte $10,%10110001 + !byte $10,%11010001 + !byte $10,%00010010 + !byte $10,%00110010 + !byte $10,%01010010 + !byte $10,%01110010 + !byte $10,%10010010 + !byte $10,%10110010 + !byte $5E,%10100110 + !byte $5C,%10100110 + !byte $5A,%10100110 + !byte $58,%10100110 + !byte $56,%10100110 + !byte $54,%10100110 + !byte $52,%11000110 + !byte $50,%11000110 + !byte $4E,%00000111 + !byte $4C,%00000111 + !byte $4A,%00100111 + !byte $48,%00100111 + !byte $48,%01000111 + !byte $46,%01000111 + !byte $44,%01100111 + !byte $42,%10000111 + !byte $40,%10100111 + !byte $3E,%11000111 + !byte $3C,%00001000 + !byte $3A,%00101000 + !byte $38,%01001000 + !byte $36,%10001000 + !byte $34,%10101000 + !byte $32,%00001001 + !byte $30,%00101001 + !byte $2E,%01101001 + !byte $2C,%10101001 + !byte $2A,%11001001 + !byte $2A,%00001010 + !byte $28,%01001010 + !byte $26,%10001010 + !byte $24,%11001010 + !byte $24,%00001011 + !byte $22,%01001011 + !byte $20,%10001011 + !byte $20,%10101011 + !byte $1E,%00001100 + !byte $1E,%00101100 + !byte $1C,%10001100 + !byte $1A,%00001101 + !byte $1A,%00101101 + !byte $18,%10001101 + !byte $18,%10101101 + !byte $16,%01001110 + !byte $16,%01101110 + !byte $14,%00001111 + !byte $14,%00101111 + !byte $14,%01001111 + !byte $12,%11001111 + !byte $12,%00010000 + !byte $12,%00110000 + !byte $10,%00010001 + !byte $10,%00110001 + !byte $10,%01010001 + !byte $10,%01110001 + !byte $10,%10010001 + !byte $0E,%10010011 + !byte $0E,%10110011 + !byte $0E,%11010011 + !byte $5E,%10000110 + !byte $5C,%10000110 + !byte $5A,%10000110 + !byte $58,%10000110 + !byte $56,%10000110 + !byte $54,%10000110 + !byte $52,%10100110 + !byte $50,%10100110 + !byte $4E,%11000110 + !byte $4C,%11000110 + !byte $4A,%00000111 + !byte $48,%00000111 + !byte $46,%00100111 + !byte $44,%01000111 + !byte $42,%01100111 + !byte $40,%10000111 + !byte $3E,%10100111 + !byte $3C,%11000111 + !byte $3A,%00001000 + !byte $38,%00101000 + !byte $36,%01001000 + !byte $36,%01101000 + !byte $34,%10001000 + !byte $32,%10101000 + !byte $32,%11001000 + !byte $30,%00001001 + !byte $2E,%00101001 + !byte $2E,%01001001 + !byte $2C,%01101001 + !byte $2C,%10001001 + !byte $2A,%10101001 + !byte $28,%00001010 + !byte $28,%00101010 + !byte $26,%01001010 + !byte $26,%01101010 + !byte $24,%10101010 + !byte $22,%00001011 + !byte $22,%00101011 + !byte $20,%01101011 + !byte $1E,%11001011 + !byte $1C,%01001100 + !byte $1C,%01101100 + !byte $1A,%10101100 + !byte $1A,%11001100 + !byte $18,%01001101 + !byte $18,%01101101 + !byte $16,%11001101 + !byte $16,%00001110 + !byte $16,%00101110 + !byte $14,%10001110 + !byte $14,%10101110 + !byte $14,%11001110 + !byte $12,%01101111 + !byte $12,%10001111 + !byte $12,%10101111 + !byte $10,%01110000 + !byte $10,%10010000 + !byte $10,%10110000 + !byte $10,%11010000 + !byte $0E,%00010010 + !byte $0E,%00110010 + !byte $0E,%01010010 + !byte $0E,%01110010 + !byte $0E,%10010010 + !byte $0E,%10110010 + !byte $0E,%11010010 + !byte $0E,%00010011 + !byte $0E,%00110011 + !byte $0E,%01010011 + !byte $0E,%01110011 + !byte $5E,%01100110 + !byte $5C,%01100110 + !byte $5A,%01100110 + !byte $58,%01100110 + !byte $56,%01100110 + !byte $54,%01100110 + !byte $52,%10000110 + !byte $50,%10000110 + !byte $4E,%10100110 + !byte $4C,%10100110 + !byte $4A,%11000110 + !byte $48,%11000110 + !byte $46,%00000111 + !byte $44,%00100111 + !byte $42,%01000111 + !byte $40,%01100111 + !byte $3E,%10000111 + !byte $3C,%10100111 + !byte $3A,%11000111 + !byte $38,%00001000 + !byte $36,%00101000 + !byte $34,%01101000 + !byte $32,%10001000 + !byte $30,%11001000 + !byte $2E,%00001001 + !byte $2C,%01001001 + !byte $2A,%10001001 + !byte $28,%11001001 + !byte $26,%00101010 + !byte $24,%01101010 + !byte $24,%10001010 + !byte $22,%11001010 + !byte $20,%00101011 + !byte $20,%01001011 + !byte $1E,%10001011 + !byte $1E,%10101011 + !byte $1C,%00001100 + !byte $1C,%00101100 + !byte $1A,%10001100 + !byte $18,%00001101 + !byte $18,%00101101 + !byte $16,%10001101 + !byte $16,%10101101 + !byte $14,%01001110 + !byte $14,%01101110 + !byte $12,%00001111 + !byte $12,%00101111 + !byte $12,%01001111 + !byte $10,%00010000 + !byte $10,%00110000 + !byte $10,%01010000 + !byte $0E,%00110001 + !byte $0E,%01010001 + !byte $0E,%01110001 + !byte $0E,%10010001 + !byte $0E,%10110001 + !byte $0E,%11010001 + !byte $5E,%01000110 + !byte $5C,%01000110 + !byte $5A,%01000110 + !byte $58,%01000110 + !byte $56,%01000110 + !byte $54,%01000110 + !byte $52,%01100110 + !byte $50,%01100110 + !byte $4E,%10000110 + !byte $4C,%10000110 + !byte $4A,%10100110 + !byte $48,%10100110 + !byte $46,%11000110 + !byte $44,%00000111 + !byte $42,%00100111 + !byte $40,%01000111 + !byte $3E,%01100111 + !byte $3C,%10000111 + !byte $3A,%10100111 + !byte $38,%11000111 + !byte $36,%00001000 + !byte $34,%00101000 + !byte $34,%01001000 + !byte $32,%01101000 + !byte $30,%10001000 + !byte $30,%10101000 + !byte $2E,%11001000 + !byte $2C,%00101001 + !byte $2A,%01101001 + !byte $28,%10101001 + !byte $26,%00001010 + !byte $24,%01001010 + !byte $22,%10001010 + !byte $22,%10101010 + !byte $20,%00001011 + !byte $1E,%01101011 + !byte $1C,%10101011 + !byte $1C,%11001011 + !byte $1A,%01001100 + !byte $1A,%01101100 + !byte $18,%10101100 + !byte $18,%11001100 + !byte $16,%01001101 + !byte $16,%01101101 + !byte $14,%00001110 + !byte $14,%00101110 + !byte $12,%10001110 + !byte $12,%10101110 + !byte $12,%11001110 + !byte $10,%10001111 + !byte $10,%10101111 + !byte $10,%11001111 + !byte $0E,%10010000 + !byte $0E,%10110000 + !byte $0E,%11010000 + !byte $0E,%00010001 + !byte $0C,%01010010 + !byte $0C,%01110010 + !byte $0C,%10010010 + !byte $0C,%10110010 + !byte $0C,%11010010 + !byte $0C,%00010011 + !byte $0C,%00110011 + !byte $0C,%01010011 + !byte $0C,%01110011 + !byte $0C,%10010011 + !byte $0C,%10110011 + !byte $0C,%11010011 + !byte $5E,%00100110 + !byte $5C,%00100110 + !byte $5A,%00100110 + !byte $58,%00100110 + !byte $56,%00100110 + !byte $54,%00100110 + !byte $52,%01000110 + !byte $50,%01000110 + !byte $4E,%01100110 + !byte $4C,%01100110 + !byte $4A,%10000110 + !byte $48,%10000110 + !byte $46,%10100110 + !byte $44,%11000110 + !byte $42,%00000111 + !byte $40,%00000111 + !byte $40,%00100111 + !byte $3E,%00100111 + !byte $3E,%01000111 + !byte $3C,%01000111 + !byte $3C,%01100111 + !byte $3A,%10000111 + !byte $38,%10100111 + !byte $36,%11000111 + !byte $34,%00001000 + !byte $32,%01001000 + !byte $30,%01101000 + !byte $2E,%10101000 + !byte $2C,%11001000 + !byte $2C,%00001001 + !byte $2A,%00101001 + !byte $2A,%01001001 + !byte $28,%01101001 + !byte $28,%10001001 + !byte $26,%10101001 + !byte $26,%11001001 + !byte $24,%00001010 + !byte $24,%00101010 + !byte $22,%01101010 + !byte $20,%10101010 + !byte $20,%11001010 + !byte $1E,%00101011 + !byte $1E,%01001011 + !byte $1C,%10001011 + !byte $1A,%00001100 + !byte $1A,%00101100 + !byte $18,%01101100 + !byte $18,%10001100 + !byte $16,%00001101 + !byte $16,%00101101 + !byte $14,%10001101 + !byte $14,%10101101 + !byte $14,%11001101 + !byte $12,%01001110 + !byte $12,%01101110 + !byte $10,%00101111 + !byte $10,%01001111 + !byte $10,%01101111 + !byte $0E,%00110000 + !byte $0E,%01010000 + !byte $0E,%01110000 + !byte $0C,%01110001 + !byte $0C,%10010001 + !byte $0C,%10110001 + !byte $0C,%11010001 + !byte $0C,%00010010 + !byte $0C,%00110010 + !byte $5E,%00000110 + !byte $5C,%00000110 + !byte $5A,%00000110 + !byte $58,%00000110 + !byte $56,%00000110 + !byte $54,%00000110 + !byte $52,%00100110 + !byte $50,%00100110 + !byte $4E,%01000110 + !byte $4C,%01000110 + !byte $4A,%01100110 + !byte $48,%01100110 + !byte $46,%10000110 + !byte $44,%10100110 + !byte $42,%10100110 + !byte $42,%11000110 + !byte $40,%11000110 + !byte $3E,%00000111 + !byte $3C,%00100111 + !byte $3A,%01000111 + !byte $3A,%01100111 + !byte $38,%10000111 + !byte $36,%10100111 + !byte $34,%11000111 + !byte $32,%00001000 + !byte $32,%00101000 + !byte $30,%01001000 + !byte $2E,%10001000 + !byte $2C,%10101000 + !byte $2A,%00001001 + !byte $28,%01001001 + !byte $26,%10001001 + !byte $24,%11001001 + !byte $22,%00101010 + !byte $22,%01001010 + !byte $20,%10001010 + !byte $1E,%11001010 + !byte $1E,%00001011 + !byte $1C,%01001011 + !byte $1C,%01101011 + !byte $1A,%10101011 + !byte $1A,%11001011 + !byte $18,%01001100 + !byte $16,%10101100 + !byte $16,%11001100 + !byte $14,%01001101 + !byte $14,%01101101 + !byte $12,%00001110 + !byte $12,%00101110 + !byte $10,%10101110 + !byte $10,%11001110 + !byte $10,%00001111 + !byte $0E,%10001111 + !byte $0E,%10101111 + !byte $0E,%11001111 + !byte $0E,%00010000 + !byte $0C,%10110000 + !byte $0C,%11010000 + !byte $0C,%00010001 + !byte $0C,%00110001 + !byte $0C,%01010001 + !byte $0A,%10110010 + !byte $0A,%11010010 + !byte $0A,%00010011 + !byte $0A,%00110011 + !byte $0A,%01010011 + !byte $0A,%01110011 + !byte $0A,%10010011 + !byte $0A,%10110011 + !byte $0A,%11010011 + !byte $5E,%11000101 + !byte $5C,%11000101 + !byte $5A,%11000101 + !byte $58,%11000101 + !byte $56,%11000101 + !byte $54,%11000101 + !byte $52,%00000110 + !byte $50,%00000110 + !byte $4E,%00100110 + !byte $4C,%00100110 + !byte $4A,%01000110 + !byte $48,%01000110 + !byte $46,%01100110 + !byte $44,%10000110 + !byte $42,%10000110 + !byte $40,%10100110 + !byte $3E,%11000110 + !byte $3C,%00000111 + !byte $3A,%00100111 + !byte $38,%01000111 + !byte $38,%01100111 + !byte $36,%10000111 + !byte $34,%10100111 + !byte $32,%11000111 + !byte $30,%00101000 + !byte $2E,%01001000 + !byte $2E,%01101000 + !byte $2C,%10001000 + !byte $2A,%11001000 + !byte $28,%00101001 + !byte $26,%01101001 + !byte $24,%10101001 + !byte $22,%00001010 + !byte $20,%01001010 + !byte $20,%01101010 + !byte $1E,%10101010 + !byte $1C,%00101011 + !byte $1A,%10001011 + !byte $18,%00001100 + !byte $18,%00101100 + !byte $16,%01101100 + !byte $16,%10001100 + !byte $14,%00001101 + !byte $14,%00101101 + !byte $12,%10001101 + !byte $12,%10101101 + !byte $12,%11001101 + !byte $10,%01001110 + !byte $10,%01101110 + !byte $10,%10001110 + !byte $0E,%00101111 + !byte $0E,%01001111 + !byte $0E,%01101111 + !byte $0C,%00110000 + !byte $0C,%01010000 + !byte $0C,%01110000 + !byte $0C,%10010000 + !byte $0A,%10010001 + !byte $0A,%10110001 + !byte $0A,%11010001 + !byte $0A,%00010010 + !byte $0A,%00110010 + !byte $0A,%01010010 + !byte $0A,%01110010 + !byte $0A,%10010010 + !byte $5E,%10100101 + !byte $5C,%10100101 + !byte $5A,%10100101 + !byte $58,%10100101 + !byte $56,%10100101 + !byte $54,%10100101 + !byte $52,%11000101 + !byte $50,%11000101 + !byte $4E,%00000110 + !byte $4C,%00000110 + !byte $4A,%00100110 + !byte $48,%00100110 + !byte $46,%01000110 + !byte $44,%01100110 + !byte $42,%01100110 + !byte $40,%10000110 + !byte $3E,%10100110 + !byte $3C,%11000110 + !byte $3A,%00000111 + !byte $38,%00100111 + !byte $36,%01100111 + !byte $34,%10000111 + !byte $32,%10100111 + !byte $30,%00001000 + !byte $2E,%00101000 + !byte $2C,%01101000 + !byte $2A,%10001000 + !byte $2A,%10101000 + !byte $28,%11001000 + !byte $28,%00001001 + !byte $26,%00101001 + !byte $26,%01001001 + !byte $24,%01101001 + !byte $24,%10001001 + !byte $22,%10101001 + !byte $22,%11001001 + !byte $20,%00101010 + !byte $1E,%01101010 + !byte $1E,%10001010 + !byte $1C,%11001010 + !byte $1C,%00001011 + !byte $1A,%01001011 + !byte $1A,%01101011 + !byte $18,%10101011 + !byte $18,%11001011 + !byte $16,%00101100 + !byte $16,%01001100 + !byte $14,%10101100 + !byte $14,%11001100 + !byte $12,%01001101 + !byte $12,%01101101 + !byte $10,%00001110 + !byte $10,%00101110 + !byte $0E,%10101110 + !byte $0E,%11001110 + !byte $0E,%00001111 + !byte $0C,%10101111 + !byte $0C,%11001111 + !byte $0C,%00010000 + !byte $0A,%11010000 + !byte $0A,%00010001 + !byte $0A,%00110001 + !byte $0A,%01010001 + !byte $0A,%01110001 + !byte $08,%00110011 + !byte $08,%01010011 + !byte $08,%01110011 + !byte $08,%10010011 + !byte $08,%10110011 + !byte $08,%11010011 + !byte $5E,%10000101 + !byte $5C,%10000101 + !byte $5A,%10000101 + !byte $58,%10000101 + !byte $56,%10000101 + !byte $54,%10000101 + !byte $52,%10100101 + !byte $50,%10100101 + !byte $4E,%10100101 + !byte $4E,%11000101 + !byte $4C,%11000101 + !byte $4A,%00000110 + !byte $48,%00000110 + !byte $46,%00100110 + !byte $44,%01000110 + !byte $42,%01000110 + !byte $40,%01100110 + !byte $3E,%10000110 + !byte $3C,%10100110 + !byte $3A,%11000110 + !byte $38,%00000111 + !byte $36,%00100111 + !byte $36,%01000111 + !byte $34,%01100111 + !byte $32,%10000111 + !byte $30,%10100111 + !byte $30,%11000111 + !byte $2E,%00001000 + !byte $2C,%01001000 + !byte $2A,%01101000 + !byte $28,%10101000 + !byte $26,%00001001 + !byte $24,%01001001 + !byte $22,%10001001 + !byte $20,%11001001 + !byte $20,%00001010 + !byte $1E,%01001010 + !byte $1C,%10101010 + !byte $1A,%00001011 + !byte $1A,%00101011 + !byte $18,%01101011 + !byte $18,%10001011 + !byte $16,%00001100 + !byte $14,%01101100 + !byte $14,%10001100 + !byte $12,%00001101 + !byte $12,%00101101 + !byte $10,%10101101 + !byte $10,%11001101 + !byte $0E,%01101110 + !byte $0E,%10001110 + !byte $0C,%01001111 + !byte $0C,%01101111 + !byte $0C,%10001111 + !byte $0A,%01010000 + !byte $0A,%01110000 + !byte $0A,%10010000 + !byte $0A,%10110000 + !byte $08,%11010001 + !byte $08,%00010010 + !byte $08,%00110010 + !byte $08,%01010010 + !byte $08,%01110010 + !byte $08,%10010010 + !byte $08,%10110010 + !byte $08,%11010010 + !byte $08,%00010011 + !byte $5E,%01100101 + !byte $5C,%01100101 + !byte $5A,%01100101 + !byte $58,%01100101 + !byte $56,%01100101 + !byte $54,%01100101 + !byte $52,%10000101 + !byte $50,%10000101 + !byte $4E,%10000101 + !byte $4C,%10100101 + !byte $4A,%10100101 + !byte $4A,%11000101 + !byte $48,%11000101 + !byte $46,%00000110 + !byte $44,%00000110 + !byte $44,%00100110 + !byte $42,%00100110 + !byte $40,%01000110 + !byte $3E,%01100110 + !byte $3C,%10000110 + !byte $3A,%10100110 + !byte $38,%11000110 + !byte $36,%00000111 + !byte $34,%00100111 + !byte $34,%01000111 + !byte $32,%01100111 + !byte $30,%10000111 + !byte $2E,%11000111 + !byte $2C,%00001000 + !byte $2C,%00101000 + !byte $2A,%01001000 + !byte $28,%10001000 + !byte $26,%11001000 + !byte $24,%00101001 + !byte $22,%01101001 + !byte $20,%10101001 + !byte $1E,%00001010 + !byte $1E,%00101010 + !byte $1C,%01101010 + !byte $1C,%10001010 + !byte $1A,%11001010 + !byte $18,%01001011 + !byte $16,%10101011 + !byte $16,%11001011 + !byte $14,%00101100 + !byte $14,%01001100 + !byte $12,%10101100 + !byte $12,%11001100 + !byte $10,%01001101 + !byte $10,%01101101 + !byte $10,%10001101 + !byte $0E,%00001110 + !byte $0E,%00101110 + !byte $0E,%01001110 + !byte $0C,%11001110 + !byte $0C,%00001111 + !byte $0C,%00101111 + !byte $0A,%10101111 + !byte $0A,%11001111 + !byte $0A,%00010000 + !byte $0A,%00110000 + !byte $08,%00010001 + !byte $08,%00110001 + !byte $08,%01010001 + !byte $08,%01110001 + !byte $08,%10010001 + !byte $08,%10110001 + !byte $5E,%01000101 + !byte $5C,%01000101 + !byte $5A,%01000101 + !byte $58,%01000101 + !byte $56,%01000101 + !byte $54,%01000101 + !byte $52,%01100101 + !byte $50,%01100101 + !byte $4E,%01100101 + !byte $4C,%10000101 + !byte $4A,%10000101 + !byte $48,%10100101 + !byte $46,%11000101 + !byte $44,%11000101 + !byte $42,%00000110 + !byte $40,%00100110 + !byte $3E,%01000110 + !byte $3C,%01100110 + !byte $3A,%10000110 + !byte $38,%10100110 + !byte $36,%11000110 + !byte $34,%00000111 + !byte $32,%01000111 + !byte $30,%01100111 + !byte $2E,%10100111 + !byte $2C,%11000111 + !byte $2A,%00101000 + !byte $28,%01101000 + !byte $26,%10001000 + !byte $26,%10101000 + !byte $24,%11001000 + !byte $24,%00001001 + !byte $22,%00101001 + !byte $22,%01001001 + !byte $20,%10001001 + !byte $1E,%11001001 + !byte $1C,%00101010 + !byte $1C,%01001010 + !byte $1A,%10001010 + !byte $1A,%10101010 + !byte $18,%00001011 + !byte $18,%00101011 + !byte $16,%01101011 + !byte $16,%10001011 + !byte $14,%11001011 + !byte $14,%00001100 + !byte $12,%01101100 + !byte $12,%10001100 + !byte $10,%00001101 + !byte $10,%00101101 + !byte $0E,%10101101 + !byte $0E,%11001101 + !byte $0C,%01101110 + !byte $0C,%10001110 + !byte $0C,%10101110 + !byte $0A,%01001111 + !byte $0A,%01101111 + !byte $0A,%10001111 + !byte $08,%01110000 + !byte $08,%10010000 + !byte $08,%10110000 + !byte $08,%11010000 + !byte $06,%00110010 + !byte $06,%01010010 + !byte $06,%01110010 + !byte $06,%10010010 + !byte $06,%10110010 + !byte $06,%11010010 + !byte $06,%00010011 + !byte $06,%00110011 + !byte $06,%01010011 + !byte $06,%01110011 + !byte $06,%10010011 + !byte $06,%10110011 + !byte $06,%11010011 + !byte $5E,%00100101 + !byte $5C,%00100101 + !byte $5A,%00100101 + !byte $58,%00100101 + !byte $56,%00100101 + !byte $54,%00100101 + !byte $52,%01000101 + !byte $50,%01000101 + !byte $4E,%01000101 + !byte $4C,%01100101 + !byte $4A,%01100101 + !byte $48,%10000101 + !byte $46,%10100101 + !byte $44,%10100101 + !byte $42,%11000101 + !byte $40,%00000110 + !byte $3E,%00100110 + !byte $3C,%01000110 + !byte $3A,%01100110 + !byte $38,%10000110 + !byte $36,%10100110 + !byte $34,%11000110 + !byte $32,%00000111 + !byte $32,%00100111 + !byte $30,%01000111 + !byte $2E,%01100111 + !byte $2E,%10000111 + !byte $2C,%10100111 + !byte $2A,%11000111 + !byte $2A,%00001000 + !byte $28,%00101000 + !byte $28,%01001000 + !byte $26,%01101000 + !byte $24,%10101000 + !byte $22,%00001001 + !byte $20,%01001001 + !byte $20,%01101001 + !byte $1E,%10001001 + !byte $1E,%10101001 + !byte $1C,%00001010 + !byte $1A,%01101010 + !byte $18,%10101010 + !byte $18,%11001010 + !byte $16,%00101011 + !byte $16,%01001011 + !byte $14,%10101011 + !byte $12,%00101100 + !byte $12,%01001100 + !byte $10,%10101100 + !byte $10,%11001100 + !byte $0E,%01001101 + !byte $0E,%01101101 + !byte $0E,%10001101 + !byte $0C,%00001110 + !byte $0C,%00101110 + !byte $0C,%01001110 + !byte $0A,%11001110 + !byte $0A,%00001111 + !byte $0A,%00101111 + !byte $08,%11001111 + !byte $08,%00010000 + !byte $08,%00110000 + !byte $08,%01010000 + !byte $06,%00110001 + !byte $06,%01010001 + !byte $06,%01110001 + !byte $06,%10010001 + !byte $06,%10110001 + !byte $06,%11010001 + !byte $06,%00010010 + !byte $5E,%00000101 + !byte $5C,%00000101 + !byte $5A,%00000101 + !byte $58,%00000101 + !byte $56,%00000101 + !byte $54,%00000101 + !byte $52,%00100101 + !byte $50,%00100101 + !byte $4E,%00100101 + !byte $4C,%01000101 + !byte $4A,%01000101 + !byte $48,%01100101 + !byte $46,%10000101 + !byte $44,%10000101 + !byte $42,%10100101 + !byte $40,%11000101 + !byte $3E,%00000110 + !byte $3C,%00100110 + !byte $3A,%01000110 + !byte $38,%01100110 + !byte $36,%10000110 + !byte $34,%10100110 + !byte $32,%11000110 + !byte $30,%00100111 + !byte $2E,%01000111 + !byte $2C,%10000111 + !byte $2A,%10100111 + !byte $28,%00001000 + !byte $26,%01001000 + !byte $24,%10001000 + !byte $22,%11001000 + !byte $20,%00101001 + !byte $1E,%01101001 + !byte $1C,%10101001 + !byte $1C,%11001001 + !byte $1A,%00101010 + !byte $1A,%01001010 + !byte $18,%10001010 + !byte $16,%00001011 + !byte $14,%01101011 + !byte $14,%10001011 + !byte $12,%11001011 + !byte $12,%00001100 + !byte $10,%01101100 + !byte $10,%10001100 + !byte $0E,%00001101 + !byte $0E,%00101101 + !byte $0C,%10101101 + !byte $0C,%11001101 + !byte $0A,%01101110 + !byte $0A,%10001110 + !byte $0A,%10101110 + !byte $08,%01101111 + !byte $08,%10001111 + !byte $08,%10101111 + !byte $06,%10010000 + !byte $06,%10110000 + !byte $06,%11010000 + !byte $06,%00010001 + !byte $04,%01110010 + !byte $04,%10010010 + !byte $04,%10110010 + !byte $04,%11010010 + !byte $04,%00010011 + !byte $04,%00110011 + !byte $04,%01010011 + !byte $04,%01110011 + !byte $04,%10010011 + !byte $04,%10110011 + !byte $04,%11010011 + !byte $5E,%11000100 + !byte $5C,%11000100 + !byte $5A,%11000100 + !byte $58,%11000100 + !byte $56,%11000100 + !byte $54,%11000100 + !byte $52,%00000101 + !byte $50,%00000101 + !byte $4E,%00000101 + !byte $4C,%00100101 + !byte $4A,%00100101 + !byte $48,%01000101 + !byte $46,%01100101 + !byte $44,%01100101 + !byte $42,%10000101 + !byte $40,%10100101 + !byte $3E,%11000101 + !byte $3C,%00000110 + !byte $3A,%00100110 + !byte $38,%01000110 + !byte $36,%01100110 + !byte $34,%10000110 + !byte $32,%10100110 + !byte $30,%11000110 + !byte $30,%00000111 + !byte $2E,%00100111 + !byte $2C,%01000111 + !byte $2C,%01100111 + !byte $2A,%10000111 + !byte $28,%11000111 + !byte $26,%00001000 + !byte $26,%00101000 + !byte $24,%01001000 + !byte $24,%01101000 + !byte $22,%10001000 + !byte $22,%10101000 + !byte $20,%11001000 + !byte $20,%00001001 + !byte $1E,%01001001 + !byte $1C,%10001001 + !byte $1A,%11001001 + !byte $1A,%00001010 + !byte $18,%01001010 + !byte $18,%01101010 + !byte $16,%10101010 + !byte $16,%11001010 + !byte $14,%00101011 + !byte $14,%01001011 + !byte $12,%10001011 + !byte $12,%10101011 + !byte $10,%00101100 + !byte $10,%01001100 + !byte $0E,%10101100 + !byte $0E,%11001100 + !byte $0C,%01101101 + !byte $0C,%10001101 + !byte $0A,%00101110 + !byte $0A,%01001110 + !byte $08,%11001110 + !byte $08,%00001111 + !byte $08,%00101111 + !byte $08,%01001111 + !byte $06,%00010000 + !byte $06,%00110000 + !byte $06,%01010000 + !byte $06,%01110000 + !byte $04,%01110001 + !byte $04,%10010001 + !byte $04,%10110001 + !byte $04,%11010001 + !byte $04,%00010010 + !byte $04,%00110010 + !byte $04,%01010010 + !byte $5E,%10100100 + !byte $5C,%10100100 + !byte $5A,%10100100 + !byte $58,%10100100 + !byte $56,%10100100 + !byte $54,%10100100 + !byte $52,%11000100 + !byte $50,%11000100 + !byte $4E,%11000100 + !byte $4C,%00000101 + !byte $4A,%00000101 + !byte $48,%00100101 + !byte $46,%01000101 + !byte $44,%01000101 + !byte $42,%01100101 + !byte $40,%10000101 + !byte $3E,%10100101 + !byte $3C,%11000101 + !byte $3A,%11000101 + !byte $3A,%00000110 + !byte $38,%00100110 + !byte $36,%01000110 + !byte $34,%01100110 + !byte $32,%10000110 + !byte $30,%10100110 + !byte $2E,%00000111 + !byte $2C,%00100111 + !byte $2A,%01100111 + !byte $28,%10000111 + !byte $28,%10100111 + !byte $26,%11000111 + !byte $24,%00101000 + !byte $22,%01101000 + !byte $20,%10101000 + !byte $1E,%00001001 + !byte $1E,%00101001 + !byte $1C,%01101001 + !byte $1A,%10101001 + !byte $18,%00001010 + !byte $18,%00101010 + !byte $16,%01101010 + !byte $16,%10001010 + !byte $14,%11001010 + !byte $14,%00001011 + !byte $12,%01101011 + !byte $10,%11001011 + !byte $10,%00001100 + !byte $0E,%01101100 + !byte $0E,%10001100 + !byte $0C,%00001101 + !byte $0C,%00101101 + !byte $0C,%01001101 + !byte $0A,%10101101 + !byte $0A,%11001101 + !byte $0A,%00001110 + !byte $08,%10001110 + !byte $08,%10101110 + !byte $06,%01101111 + !byte $06,%10001111 + !byte $06,%10101111 + !byte $06,%11001111 + !byte $04,%10110000 + !byte $04,%11010000 + !byte $04,%00010001 + !byte $04,%00110001 + !byte $04,%01010001 + !byte $02,%00010011 + !byte $02,%00110011 + !byte $02,%01010011 + !byte $02,%01110011 + !byte $02,%10010011 + !byte $02,%10110011 + !byte $02,%11010011 + !byte $5E,%10000100 + !byte $5C,%10000100 + !byte $5A,%10000100 + !byte $58,%10000100 + !byte $56,%10000100 + !byte $54,%10000100 + !byte $52,%10100100 + !byte $50,%10100100 + !byte $4E,%10100100 + !byte $4C,%11000100 + !byte $4A,%11000100 + !byte $48,%00000101 + !byte $46,%00000101 + !byte $46,%00100101 + !byte $44,%00100101 + !byte $42,%01000101 + !byte $40,%01100101 + !byte $3E,%10000101 + !byte $3C,%10000101 + !byte $3C,%10100101 + !byte $3A,%10100101 + !byte $38,%11000101 + !byte $38,%00000110 + !byte $36,%00100110 + !byte $34,%01000110 + !byte $32,%01100110 + !byte $30,%10000110 + !byte $2E,%11000110 + !byte $2C,%00000111 + !byte $2A,%01000111 + !byte $28,%01100111 + !byte $26,%10100111 + !byte $24,%00001000 + !byte $22,%01001000 + !byte $20,%10001000 + !byte $1E,%11001000 + !byte $1C,%00101001 + !byte $1C,%01001001 + !byte $1A,%10001001 + !byte $18,%11001001 + !byte $16,%01001010 + !byte $14,%10101010 + !byte $12,%00101011 + !byte $12,%01001011 + !byte $10,%10001011 + !byte $10,%10101011 + !byte $0E,%00101100 + !byte $0E,%01001100 + !byte $0C,%10101100 + !byte $0C,%11001100 + !byte $0A,%01101101 + !byte $0A,%10001101 + !byte $08,%00101110 + !byte $08,%01001110 + !byte $08,%01101110 + !byte $06,%00001111 + !byte $06,%00101111 + !byte $06,%01001111 + !byte $04,%00110000 + !byte $04,%01010000 + !byte $04,%01110000 + !byte $04,%10010000 + !byte $02,%10110001 + !byte $02,%11010001 + !byte $02,%00010010 + !byte $02,%00110010 + !byte $02,%01010010 + !byte $02,%01110010 + !byte $02,%10010010 + !byte $02,%10110010 + !byte $02,%11010010 + !byte $5E,%01100100 + !byte $5C,%01100100 + !byte $5A,%01100100 + !byte $58,%01100100 + !byte $56,%01100100 + !byte $54,%01100100 + !byte $52,%10000100 + !byte $50,%10000100 + !byte $4E,%10000100 + !byte $4C,%10100100 + !byte $4A,%10100100 + !byte $48,%11000100 + !byte $46,%11000100 + !byte $44,%00000101 + !byte $42,%00100101 + !byte $40,%01000101 + !byte $3E,%01000101 + !byte $3E,%01100101 + !byte $3C,%01100101 + !byte $3A,%10000101 + !byte $38,%10100101 + !byte $36,%11000101 + !byte $36,%00000110 + !byte $34,%00100110 + !byte $32,%01000110 + !byte $30,%01100110 + !byte $2E,%10000110 + !byte $2E,%10100110 + !byte $2C,%11000110 + !byte $2A,%00000111 + !byte $2A,%00100111 + !byte $28,%01000111 + !byte $26,%10000111 + !byte $24,%10100111 + !byte $24,%11000111 + !byte $22,%00001000 + !byte $22,%00101000 + !byte $20,%01001000 + !byte $20,%01101000 + !byte $1E,%10001000 + !byte $1E,%10101000 + !byte $1C,%00001001 + !byte $1A,%01001001 + !byte $1A,%01101001 + !byte $18,%10101001 + !byte $16,%00001010 + !byte $16,%00101010 + !byte $14,%01101010 + !byte $14,%10001010 + !byte $12,%11001010 + !byte $12,%00001011 + !byte $10,%01101011 + !byte $0E,%11001011 + !byte $0E,%00001100 + !byte $0C,%01101100 + !byte $0C,%10001100 + !byte $0A,%00001101 + !byte $0A,%00101101 + !byte $0A,%01001101 + !byte $08,%10101101 + !byte $08,%11001101 + !byte $08,%00001110 + !byte $06,%10001110 + !byte $06,%10101110 + !byte $06,%11001110 + !byte $04,%10001111 + !byte $04,%10101111 + !byte $04,%11001111 + !byte $04,%00010000 + !byte $02,%11010000 + !byte $02,%00010001 + !byte $02,%00110001 + !byte $02,%01010001 + !byte $02,%01110001 + !byte $02,%10010001 + !byte $5E,%01000100 + !byte $5C,%01000100 + !byte $5A,%01000100 + !byte $58,%01000100 + !byte $56,%01000100 + !byte $54,%01000100 + !byte $52,%01100100 + !byte $50,%01100100 + !byte $4E,%01100100 + !byte $4C,%10000100 + !byte $4A,%10000100 + !byte $48,%10100100 + !byte $46,%10100100 + !byte $44,%11000100 + !byte $42,%00000101 + !byte $40,%00100101 + !byte $3E,%00100101 + !byte $3C,%01000101 + !byte $3A,%01100101 + !byte $38,%10000101 + !byte $36,%10100101 + !byte $34,%11000101 + !byte $34,%00000110 + !byte $32,%00100110 + !byte $30,%01000110 + !byte $2E,%01100110 + !byte $2C,%10100110 + !byte $2A,%11000110 + !byte $28,%00100111 + !byte $26,%01000111 + !byte $26,%01100111 + !byte $24,%10000111 + !byte $22,%11000111 + !byte $20,%00101000 + !byte $1E,%01101000 + !byte $1C,%10101000 + !byte $1C,%11001000 + !byte $1A,%00101001 + !byte $18,%01101001 + !byte $18,%10001001 + !byte $16,%11001001 + !byte $14,%00101010 + !byte $14,%01001010 + !byte $12,%10001010 + !byte $12,%10101010 + !byte $10,%00101011 + !byte $10,%01001011 + !byte $0E,%10001011 + !byte $0E,%10101011 + !byte $0C,%00101100 + !byte $0C,%01001100 + !byte $0A,%10101100 + !byte $0A,%11001100 + !byte $08,%01101101 + !byte $08,%10001101 + !byte $06,%00101110 + !byte $06,%01001110 + !byte $06,%01101110 + !byte $04,%00101111 + !byte $04,%01001111 + !byte $04,%01101111 + !byte $02,%01010000 + !byte $02,%01110000 + !byte $02,%10010000 + !byte $02,%10110000 + !byte $00,%00010010 + !byte $00,%00110010 + !byte $00,%01010010 + !byte $00,%01110010 + !byte $00,%10010010 + !byte $00,%10110010 + !byte $00,%11010010 + !byte $00,%00010011 + !byte $00,%00110011 + !byte $00,%01010011 + !byte $00,%01110011 + !byte $00,%10010011 + !byte $00,%10110011 + !byte $00,%11010011 + !byte $5E,%00100100 + !byte $5C,%00100100 + !byte $5A,%00100100 + !byte $58,%00100100 + !byte $56,%00100100 + !byte $54,%00100100 + !byte $52,%01000100 + !byte $50,%01000100 + !byte $4E,%01000100 + !byte $4C,%01100100 + !byte $4A,%01100100 + !byte $48,%10000100 + !byte $46,%10000100 + !byte $44,%10100100 + !byte $42,%11000100 + !byte $40,%00000101 + !byte $3E,%00000101 + !byte $3C,%00100101 + !byte $3A,%01000101 + !byte $38,%01100101 + !byte $36,%10000101 + !byte $34,%10100101 + !byte $32,%11000101 + !byte $32,%00000110 + !byte $30,%00100110 + !byte $2E,%01000110 + !byte $2C,%10000110 + !byte $2A,%10100110 + !byte $28,%00000111 + !byte $26,%00100111 + !byte $24,%01100111 + !byte $22,%10100111 + !byte $20,%00001000 + !byte $1E,%01001000 + !byte $1C,%10001000 + !byte $1A,%11001000 + !byte $1A,%00001001 + !byte $18,%01001001 + !byte $16,%10001001 + !byte $16,%10101001 + !byte $14,%00001010 + !byte $12,%01101010 + !byte $10,%11001010 + !byte $10,%00001011 + !byte $0E,%01001011 + !byte $0E,%01101011 + !byte $0C,%11001011 + !byte $0C,%00001100 + !byte $0A,%01101100 + !byte $0A,%10001100 + !byte $08,%00101101 + !byte $08,%01001101 + !byte $06,%11001101 + !byte $06,%00001110 + !byte $04,%10101110 + !byte $04,%11001110 + !byte $04,%00001111 + !byte $02,%10101111 + !byte $02,%11001111 + !byte $02,%00010000 + !byte $02,%00110000 + !byte $00,%00110001 + !byte $00,%01010001 + !byte $00,%01110001 + !byte $00,%10010001 + !byte $00,%10110001 + !byte $00,%11010001 + !byte $5E,%00000100 + !byte $5C,%00000100 + !byte $5A,%00000100 + !byte $58,%00000100 + !byte $56,%00000100 + !byte $54,%00000100 + !byte $52,%00100100 + !byte $50,%00100100 + !byte $4E,%00100100 + !byte $4C,%01000100 + !byte $4A,%01000100 + !byte $48,%01100100 + !byte $46,%01100100 + !byte $44,%10000100 + !byte $42,%10100100 + !byte $40,%10100100 + !byte $40,%11000100 + !byte $3E,%11000100 + !byte $3C,%00000101 + !byte $3A,%00100101 + !byte $38,%01000101 + !byte $36,%01100101 + !byte $34,%10000101 + !byte $32,%10100101 + !byte $30,%00000110 + !byte $2E,%00100110 + !byte $2C,%01000110 + !byte $2C,%01100110 + !byte $2A,%10000110 + !byte $28,%10100110 + !byte $28,%11000110 + !byte $26,%00000111 + !byte $24,%01000111 + !byte $22,%01100111 + !byte $22,%10000111 + !byte $20,%10100111 + !byte $20,%11000111 + !byte $1E,%00001000 + !byte $1E,%00101000 + !byte $1C,%01001000 + !byte $1C,%01101000 + !byte $1A,%10101000 + !byte $18,%00001001 + !byte $18,%00101001 + !byte $16,%01101001 + !byte $14,%10101001 + !byte $14,%11001001 + !byte $12,%00101010 + !byte $12,%01001010 + !byte $10,%10001010 + !byte $10,%10101010 + !byte $0E,%00101011 + !byte $0C,%10001011 + !byte $0C,%10101011 + !byte $0A,%00101100 + !byte $0A,%01001100 + !byte $08,%10101100 + !byte $08,%11001100 + !byte $08,%00001101 + !byte $06,%01101101 + !byte $06,%10001101 + !byte $06,%10101101 + !byte $04,%01001110 + !byte $04,%01101110 + !byte $04,%10001110 + !byte $02,%00101111 + !byte $02,%01001111 + !byte $02,%01101111 + !byte $02,%10001111 + !byte $00,%01110000 + !byte $00,%10010000 + !byte $00,%10110000 + !byte $00,%11010000 + !byte $00,%00010001 + !byte $5E,%11000011 + !byte $5C,%11000011 + !byte $5A,%11000011 + !byte $58,%11000011 + !byte $56,%11000011 + !byte $54,%11000011 + !byte $52,%00000100 + !byte $50,%00000100 + !byte $4E,%00000100 + !byte $4C,%00100100 + !byte $4A,%00100100 + !byte $48,%01000100 + !byte $46,%01000100 + !byte $44,%01100100 + !byte $42,%10000100 + !byte $40,%10000100 + !byte $3E,%10100100 + !byte $3C,%11000100 + !byte $3A,%00000101 + !byte $38,%00100101 + !byte $36,%01000101 + !byte $34,%01100101 + !byte $32,%10000101 + !byte $30,%10100101 + !byte $30,%11000101 + !byte $2E,%00000110 + !byte $2C,%00100110 + !byte $2A,%01100110 + !byte $28,%10000110 + !byte $26,%11000110 + !byte $24,%00000111 + !byte $24,%00100111 + !byte $22,%01000111 + !byte $20,%10000111 + !byte $1E,%11000111 + !byte $1C,%00101000 + !byte $1A,%01101000 + !byte $1A,%10001000 + !byte $18,%11001000 + !byte $16,%00101001 + !byte $16,%01001001 + !byte $14,%10001001 + !byte $12,%00001010 + !byte $10,%01101010 + !byte $0E,%11001010 + !byte $0E,%00001011 + !byte $0C,%01001011 + !byte $0C,%01101011 + !byte $0A,%11001011 + !byte $0A,%00001100 + !byte $08,%01101100 + !byte $08,%10001100 + !byte $06,%00101101 + !byte $06,%01001101 + !byte $04,%11001101 + !byte $04,%00001110 + !byte $04,%00101110 + !byte $02,%10101110 + !byte $02,%11001110 + !byte $02,%00001111 + !byte $00,%11001111 + !byte $00,%00010000 + !byte $00,%00110000 + !byte $00,%01010000 + !byte $5E,%10100011 + !byte $5C,%10100011 + !byte $5A,%10100011 + !byte $58,%10100011 + !byte $56,%10100011 + !byte $54,%10100011 + !byte $52,%11000011 + !byte $50,%11000011 + !byte $4E,%11000011 + !byte $4C,%00000100 + !byte $4A,%00000100 + !byte $48,%00100100 + !byte $46,%00100100 + !byte $44,%01000100 + !byte $42,%01100100 + !byte $40,%01100100 + !byte $3E,%10000100 + !byte $3C,%10100100 + !byte $3A,%11000100 + !byte $38,%00000101 + !byte $36,%00100101 + !byte $34,%01000101 + !byte $32,%01100101 + !byte $30,%10000101 + !byte $2E,%11000101 + !byte $2C,%00000110 + !byte $2A,%00100110 + !byte $2A,%01000110 + !byte $28,%01100110 + !byte $26,%10000110 + !byte $26,%10100110 + !byte $24,%11000110 + !byte $22,%00100111 + !byte $20,%01100111 + !byte $1E,%10100111 + !byte $1C,%00001000 + !byte $1A,%01001000 + !byte $18,%10001000 + !byte $18,%10101000 + !byte $16,%00001001 + !byte $14,%01001001 + !byte $14,%01101001 + !byte $12,%10101001 + !byte $12,%11001001 + !byte $10,%00101010 + !byte $10,%01001010 + !byte $0E,%10001010 + !byte $0E,%10101010 + !byte $0C,%00001011 + !byte $0C,%00101011 + !byte $0A,%10001011 + !byte $0A,%10101011 + !byte $08,%00101100 + !byte $08,%01001100 + !byte $06,%10101100 + !byte $06,%11001100 + !byte $06,%00001101 + !byte $04,%01101101 + !byte $04,%10001101 + !byte $04,%10101101 + !byte $02,%01001110 + !byte $02,%01101110 + !byte $02,%10001110 + !byte $00,%01001111 + !byte $00,%01101111 + !byte $00,%10001111 + !byte $00,%10101111 + !byte $5E,%10000011 + !byte $5C,%10000011 + !byte $5A,%10000011 + !byte $58,%10000011 + !byte $56,%10000011 + !byte $54,%10000011 + !byte $52,%10100011 + !byte $50,%10100011 + !byte $4E,%10100011 + !byte $4C,%11000011 + !byte $4A,%11000011 + !byte $48,%00000100 + !byte $46,%00000100 + !byte $44,%00100100 + !byte $42,%01000100 + !byte $40,%01000100 + !byte $3E,%01100100 + !byte $3C,%10000100 + !byte $3A,%10100100 + !byte $38,%11000100 + !byte $36,%00000101 + !byte $34,%00100101 + !byte $32,%01000101 + !byte $30,%01100101 + !byte $2E,%10000101 + !byte $2E,%10100101 + !byte $2C,%11000101 + !byte $2A,%00000110 + !byte $28,%01000110 + !byte $26,%01100110 + !byte $24,%10100110 + !byte $22,%00000111 + !byte $20,%00100111 + !byte $20,%01000111 + !byte $1E,%01100111 + !byte $1E,%10000111 + !byte $1C,%10100111 + !byte $1C,%11000111 + !byte $1A,%00101000 + !byte $18,%01101000 + !byte $16,%10101000 + !byte $16,%11001000 + !byte $14,%00101001 + !byte $12,%01101001 + !byte $12,%10001001 + !byte $10,%11001001 + !byte $10,%00001010 + !byte $0E,%01001010 + !byte $0E,%01101010 + !byte $0C,%11001010 + !byte $0A,%01001011 + !byte $0A,%01101011 + !byte $08,%11001011 + !byte $08,%00001100 + !byte $06,%01101100 + !byte $06,%10001100 + !byte $04,%00101101 + !byte $04,%01001101 + !byte $02,%11001101 + !byte $02,%00001110 + !byte $02,%00101110 + !byte $00,%11001110 + !byte $00,%00001111 + !byte $00,%00101111 + !byte $5E,%01100011 + !byte $5C,%01100011 + !byte $5A,%01100011 + !byte $58,%01100011 + !byte $56,%01100011 + !byte $54,%01100011 + !byte $52,%10000011 + !byte $50,%10000011 + !byte $4E,%10000011 + !byte $4C,%10100011 + !byte $4A,%10100011 + !byte $48,%11000011 + !byte $46,%11000011 + !byte $44,%00000100 + !byte $42,%00000100 + !byte $42,%00100100 + !byte $40,%00100100 + !byte $3E,%01000100 + !byte $3C,%01100100 + !byte $3A,%10000100 + !byte $38,%10100100 + !byte $36,%11000100 + !byte $34,%00000101 + !byte $32,%00100101 + !byte $30,%01000101 + !byte $2E,%01100101 + !byte $2C,%10100101 + !byte $2A,%11000101 + !byte $28,%00100110 + !byte $26,%01000110 + !byte $24,%10000110 + !byte $22,%10100110 + !byte $22,%11000110 + !byte $20,%00000111 + !byte $1E,%01000111 + !byte $1C,%10000111 + !byte $1A,%11000111 + !byte $1A,%00001000 + !byte $18,%00101000 + !byte $18,%01001000 + !byte $16,%10001000 + !byte $14,%11001000 + !byte $14,%00001001 + !byte $12,%01001001 + !byte $10,%10101001 + !byte $0E,%00101010 + !byte $0C,%10001010 + !byte $0C,%10101010 + !byte $0A,%00001011 + !byte $0A,%00101011 + !byte $08,%10001011 + !byte $08,%10101011 + !byte $06,%00101100 + !byte $06,%01001100 + !byte $04,%11001100 + !byte $04,%00001101 + !byte $02,%10001101 + !byte $02,%10101101 + !byte $00,%01001110 + !byte $00,%01101110 + !byte $00,%10001110 + !byte $00,%10101110 + !byte $5E,%01000011 + !byte $5C,%01000011 + !byte $5A,%01000011 + !byte $58,%01000011 + !byte $56,%01000011 + !byte $54,%01000011 + !byte $52,%01100011 + !byte $50,%01100011 + !byte $4E,%01100011 + !byte $4C,%10000011 + !byte $4A,%10000011 + !byte $48,%10100011 + !byte $46,%10100011 + !byte $44,%11000011 + !byte $42,%11000011 + !byte $40,%00000100 + !byte $3E,%00100100 + !byte $3C,%01000100 + !byte $3A,%01100100 + !byte $38,%10000100 + !byte $36,%10100100 + !byte $34,%11000100 + !byte $32,%00000101 + !byte $30,%00100101 + !byte $2E,%01000101 + !byte $2C,%01100101 + !byte $2C,%10000101 + !byte $2A,%10100101 + !byte $28,%11000101 + !byte $28,%00000110 + !byte $26,%00100110 + !byte $24,%01000110 + !byte $24,%01100110 + !byte $22,%10000110 + !byte $20,%11000110 + !byte $1E,%00100111 + !byte $1C,%01100111 + !byte $1A,%10100111 + !byte $18,%00001000 + !byte $16,%01001000 + !byte $16,%01101000 + !byte $14,%10101000 + !byte $12,%00001001 + !byte $12,%00101001 + !byte $10,%01101001 + !byte $10,%10001001 + !byte $0E,%11001001 + !byte $0E,%00001010 + !byte $0C,%01001010 + !byte $0C,%01101010 + !byte $0A,%10101010 + !byte $0A,%11001010 + !byte $08,%01001011 + !byte $08,%01101011 + !byte $06,%11001011 + !byte $06,%00001100 + !byte $04,%01101100 + !byte $04,%10001100 + !byte $04,%10101100 + !byte $02,%00101101 + !byte $02,%01001101 + !byte $02,%01101101 + !byte $00,%00001110 + !byte $00,%00101110 + !byte $5E,%00100011 + !byte $5C,%00100011 + !byte $5A,%00100011 + !byte $58,%00100011 + !byte $56,%00100011 + !byte $54,%00100011 + !byte $52,%01000011 + !byte $50,%01000011 + !byte $4E,%01000011 + !byte $4C,%01100011 + !byte $4A,%01100011 + !byte $48,%10000011 + !byte $46,%10000011 + !byte $44,%10100011 + !byte $42,%10100011 + !byte $40,%11000011 + !byte $3E,%00000100 + !byte $3C,%00100100 + !byte $3A,%01000100 + !byte $38,%01100100 + !byte $36,%01100100 + !byte $36,%10000100 + !byte $34,%10100100 + !byte $32,%11000100 + !byte $30,%00000101 + !byte $2E,%00100101 + !byte $2C,%01000101 + !byte $2A,%10000101 + !byte $28,%10100101 + !byte $26,%00000110 + !byte $24,%00100110 + !byte $22,%01100110 + !byte $20,%10100110 + !byte $1E,%00000111 + !byte $1C,%00100111 + !byte $1C,%01000111 + !byte $1A,%01100111 + !byte $1A,%10000111 + !byte $18,%11000111 + !byte $16,%00101000 + !byte $14,%01101000 + !byte $14,%10001000 + !byte $12,%11001000 + !byte $10,%00101001 + !byte $10,%01001001 + !byte $0E,%10001001 + !byte $0E,%10101001 + !byte $0C,%00001010 + !byte $0C,%00101010 + !byte $0A,%10001010 + !byte $08,%00001011 + !byte $08,%00101011 + !byte $06,%10001011 + !byte $06,%10101011 + !byte $04,%00101100 + !byte $04,%01001100 + !byte $02,%11001100 + !byte $02,%00001101 + !byte $00,%10001101 + !byte $00,%10101101 + !byte $00,%11001101 + !byte $5E,%00000011 + !byte $5C,%00000011 + !byte $5A,%00000011 + !byte $58,%00000011 + !byte $56,%00000011 + !byte $54,%00000011 + !byte $52,%00100011 + !byte $50,%00100011 + !byte $4E,%00100011 + !byte $4C,%01000011 + !byte $4A,%01000011 + !byte $48,%01100011 + !byte $46,%01100011 + !byte $44,%10000011 + !byte $42,%10000011 + !byte $40,%10100011 + !byte $3E,%11000011 + !byte $3C,%00000100 + !byte $3A,%00100100 + !byte $38,%00100100 + !byte $38,%01000100 + !byte $36,%01000100 + !byte $34,%01100100 + !byte $34,%10000100 + !byte $32,%10100100 + !byte $30,%11000100 + !byte $2E,%00000101 + !byte $2C,%00100101 + !byte $2A,%01100101 + !byte $28,%10000101 + !byte $26,%10100101 + !byte $26,%11000101 + !byte $24,%00000110 + !byte $22,%01000110 + !byte $20,%01100110 + !byte $20,%10000110 + !byte $1E,%10100110 + !byte $1E,%11000110 + !byte $1C,%00000111 + !byte $1A,%01000111 + !byte $18,%10000111 + !byte $18,%10100111 + !byte $16,%11000111 + !byte $16,%00001000 + !byte $14,%01001000 + !byte $12,%10001000 + !byte $12,%10101000 + !byte $10,%00001001 + !byte $0E,%01101001 + !byte $0C,%11001001 + !byte $0A,%01001010 + !byte $0A,%01101010 + !byte $08,%10101010 + !byte $08,%11001010 + !byte $06,%01001011 + !byte $06,%01101011 + !byte $04,%11001011 + !byte $04,%00001100 + !byte $02,%10001100 + !byte $02,%10101100 + !byte $00,%00101101 + !byte $00,%01001101 + !byte $00,%01101101 + !byte $5E,%11000010 + !byte $5C,%11000010 + !byte $5A,%11000010 + !byte $58,%11000010 + !byte $56,%11000010 + !byte $54,%11000010 + !byte $52,%00000011 + !byte $50,%00000011 + !byte $4E,%00000011 + !byte $4C,%00100011 + !byte $4A,%00100011 + !byte $48,%01000011 + !byte $46,%01000011 + !byte $44,%01100011 + !byte $42,%01100011 + !byte $40,%10000011 + !byte $3E,%10100011 + !byte $3C,%11000011 + !byte $3A,%11000011 + !byte $3A,%00000100 + !byte $38,%00000100 + !byte $36,%00100100 + !byte $34,%01000100 + !byte $32,%01100100 + !byte $32,%10000100 + !byte $30,%10100100 + !byte $2E,%11000100 + !byte $2C,%00000101 + !byte $2A,%00100101 + !byte $2A,%01000101 + !byte $28,%01100101 + !byte $26,%10000101 + !byte $24,%11000101 + !byte $22,%00000110 + !byte $22,%00100110 + !byte $20,%01000110 + !byte $1E,%10000110 + !byte $1C,%11000110 + !byte $1A,%00100111 + !byte $18,%01100111 + !byte $16,%10100111 + !byte $14,%00001000 + !byte $14,%00101000 + !byte $12,%01101000 + !byte $10,%10101000 + !byte $10,%11001000 + !byte $0E,%00101001 + !byte $0E,%01001001 + !byte $0C,%10001001 + !byte $0C,%10101001 + !byte $0A,%00001010 + !byte $0A,%00101010 + !byte $08,%01101010 + !byte $08,%10001010 + !byte $06,%00001011 + !byte $06,%00101011 + !byte $04,%10001011 + !byte $04,%10101011 + !byte $02,%00101100 + !byte $02,%01001100 + !byte $02,%01101100 + !byte $00,%11001100 + !byte $00,%00001101 + !byte $5E,%10100010 + !byte $5C,%10100010 + !byte $5A,%10100010 + !byte $58,%10100010 + !byte $56,%10100010 + !byte $54,%10100010 + !byte $52,%11000010 + !byte $50,%11000010 + !byte $4E,%11000010 + !byte $4C,%00000011 + !byte $4A,%00000011 + !byte $48,%00100011 + !byte $46,%00100011 + !byte $44,%01000011 + !byte $42,%01000011 + !byte $40,%01100011 + !byte $3E,%10000011 + !byte $3C,%10100011 + !byte $3A,%10100011 + !byte $38,%11000011 + !byte $36,%00000100 + !byte $34,%00100100 + !byte $32,%01000100 + !byte $30,%01100100 + !byte $30,%10000100 + !byte $2E,%10100100 + !byte $2C,%11000100 + !byte $2A,%00000101 + !byte $28,%01000101 + !byte $26,%01100101 + !byte $24,%10100101 + !byte $22,%11000101 + !byte $20,%00100110 + !byte $1E,%01100110 + !byte $1C,%10100110 + !byte $1A,%11000110 + !byte $1A,%00000111 + !byte $18,%00100111 + !byte $18,%01000111 + !byte $16,%10000111 + !byte $14,%11000111 + !byte $12,%00101000 + !byte $12,%01001000 + !byte $10,%10001000 + !byte $0E,%11001000 + !byte $0E,%00001001 + !byte $0C,%01001001 + !byte $0C,%01101001 + !byte $0A,%10101001 + !byte $0A,%11001001 + !byte $08,%01001010 + !byte $06,%10101010 + !byte $06,%11001010 + !byte $04,%01001011 + !byte $04,%01101011 + !byte $02,%11001011 + !byte $02,%00001100 + !byte $00,%10001100 + !byte $00,%10101100 + !byte $5E,%10000010 + !byte $5C,%10000010 + !byte $5A,%10000010 + !byte $58,%10000010 + !byte $56,%10000010 + !byte $54,%10000010 + !byte $52,%10100010 + !byte $50,%10100010 + !byte $4E,%10100010 + !byte $4C,%11000010 + !byte $4A,%11000010 + !byte $48,%00000011 + !byte $46,%00000011 + !byte $44,%00100011 + !byte $42,%00100011 + !byte $40,%01000011 + !byte $3E,%01100011 + !byte $3C,%01100011 + !byte $3C,%10000011 + !byte $3A,%10000011 + !byte $38,%10100011 + !byte $36,%11000011 + !byte $34,%00000100 + !byte $32,%00100100 + !byte $30,%01000100 + !byte $2E,%01100100 + !byte $2E,%10000100 + !byte $2C,%10100100 + !byte $2A,%11000100 + !byte $28,%00000101 + !byte $28,%00100101 + !byte $26,%01000101 + !byte $24,%01100101 + !byte $24,%10000101 + !byte $22,%10100101 + !byte $20,%00000110 + !byte $1E,%00100110 + !byte $1E,%01000110 + !byte $1C,%01100110 + !byte $1C,%10000110 + !byte $1A,%10100110 + !byte $18,%00000111 + !byte $16,%01000111 + !byte $16,%01100111 + !byte $14,%10100111 + !byte $12,%00001000 + !byte $10,%01001000 + !byte $10,%01101000 + !byte $0E,%10101000 + !byte $0C,%00101001 + !byte $0A,%10001001 + !byte $08,%00001010 + !byte $08,%00101010 + !byte $06,%01101010 + !byte $06,%10001010 + !byte $04,%00001011 + !byte $04,%00101011 + !byte $02,%10001011 + !byte $02,%10101011 + !byte $00,%00101100 + !byte $00,%01001100 + !byte $00,%01101100 + !byte $5E,%01100010 + !byte $5C,%01100010 + !byte $5A,%01100010 + !byte $58,%01100010 + !byte $56,%01100010 + !byte $54,%01100010 + !byte $52,%01100010 + !byte $52,%10000010 + !byte $50,%10000010 + !byte $4E,%10000010 + !byte $4C,%10100010 + !byte $4A,%10100010 + !byte $48,%11000010 + !byte $46,%11000010 + !byte $44,%00000011 + !byte $42,%00000011 + !byte $40,%00100011 + !byte $3E,%01000011 + !byte $3C,%01000011 + !byte $3A,%01100011 + !byte $38,%10000011 + !byte $36,%10100011 + !byte $34,%11000011 + !byte $32,%00000100 + !byte $30,%00100100 + !byte $2E,%01000100 + !byte $2C,%10000100 + !byte $2A,%10100100 + !byte $28,%11000100 + !byte $26,%00100101 + !byte $24,%01000101 + !byte $22,%10000101 + !byte $20,%10100101 + !byte $20,%11000101 + !byte $1E,%00000110 + !byte $1C,%01000110 + !byte $1A,%10000110 + !byte $18,%11000110 + !byte $16,%00100111 + !byte $14,%01100111 + !byte $14,%10000111 + !byte $12,%10100111 + !byte $12,%11000111 + !byte $10,%00101000 + !byte $0E,%01101000 + !byte $0E,%10001000 + !byte $0C,%11001000 + !byte $0C,%00001001 + !byte $0A,%01001001 + !byte $0A,%01101001 + !byte $08,%10101001 + !byte $08,%11001001 + !byte $06,%01001010 + !byte $04,%10101010 + !byte $04,%11001010 + !byte $02,%01001011 + !byte $02,%01101011 + !byte $00,%11001011 + !byte $00,%00001100 + !byte $5E,%01000010 + !byte $5C,%01000010 + !byte $5A,%01000010 + !byte $58,%01000010 + !byte $56,%01000010 + !byte $54,%01000010 + !byte $52,%01000010 + !byte $50,%01100010 + !byte $4E,%01100010 + !byte $4C,%10000010 + !byte $4A,%10000010 + !byte $48,%10000010 + !byte $48,%10100010 + !byte $46,%10100010 + !byte $44,%11000010 + !byte $42,%11000010 + !byte $40,%00000011 + !byte $3E,%00100011 + !byte $3C,%00100011 + !byte $3A,%01000011 + !byte $38,%01100011 + !byte $36,%10000011 + !byte $34,%10100011 + !byte $32,%11000011 + !byte $30,%00000100 + !byte $2E,%00100100 + !byte $2C,%01000100 + !byte $2C,%01100100 + !byte $2A,%10000100 + !byte $28,%10100100 + !byte $26,%00000101 + !byte $24,%00100101 + !byte $22,%01000101 + !byte $22,%01100101 + !byte $20,%10000101 + !byte $1E,%11000101 + !byte $1C,%00000110 + !byte $1C,%00100110 + !byte $1A,%01000110 + !byte $1A,%01100110 + !byte $18,%10100110 + !byte $16,%11000110 + !byte $16,%00000111 + !byte $14,%01000111 + !byte $12,%10000111 + !byte $10,%11000111 + !byte $10,%00001000 + !byte $0E,%01001000 + !byte $0C,%10001000 + !byte $0C,%10101000 + !byte $0A,%00001001 + !byte $0A,%00101001 + !byte $08,%01101001 + !byte $08,%10001001 + !byte $06,%00001010 + !byte $06,%00101010 + !byte $04,%01101010 + !byte $04,%10001010 + !byte $02,%00001011 + !byte $02,%00101011 + !byte $00,%10001011 + !byte $00,%10101011 + !byte $5E,%00100010 + !byte $5C,%00100010 + !byte $5A,%00100010 + !byte $58,%00100010 + !byte $56,%00100010 + !byte $54,%00100010 + !byte $52,%00100010 + !byte $50,%01000010 + !byte $4E,%01000010 + !byte $4C,%01100010 + !byte $4A,%01100010 + !byte $48,%01100010 + !byte $46,%10000010 + !byte $44,%10100010 + !byte $42,%10100010 + !byte $40,%11000010 + !byte $3E,%00000011 + !byte $3C,%00000011 + !byte $3A,%00100011 + !byte $38,%01000011 + !byte $36,%01100011 + !byte $34,%10000011 + !byte $32,%10100011 + !byte $30,%11000011 + !byte $2E,%00000100 + !byte $2C,%00100100 + !byte $2A,%01100100 + !byte $28,%10000100 + !byte $26,%10100100 + !byte $26,%11000100 + !byte $24,%00000101 + !byte $22,%00100101 + !byte $20,%01100101 + !byte $1E,%10100101 + !byte $1C,%11000101 + !byte $1A,%00100110 + !byte $18,%01100110 + !byte $18,%10000110 + !byte $16,%10100110 + !byte $14,%00000111 + !byte $14,%00100111 + !byte $12,%01100111 + !byte $10,%10100111 + !byte $0E,%00001000 + !byte $0E,%00101000 + !byte $0C,%01101000 + !byte $0A,%11001000 + !byte $08,%01001001 + !byte $06,%10101001 + !byte $06,%11001001 + !byte $04,%00101010 + !byte $04,%01001010 + !byte $02,%10101010 + !byte $02,%11001010 + !byte $00,%01001011 + !byte $00,%01101011 + !byte $5E,%00000010 + !byte $5C,%00000010 + !byte $5A,%00000010 + !byte $58,%00000010 + !byte $56,%00000010 + !byte $54,%00000010 + !byte $52,%00000010 + !byte $50,%00100010 + !byte $4E,%00100010 + !byte $4C,%01000010 + !byte $4A,%01000010 + !byte $48,%01000010 + !byte $46,%01100010 + !byte $44,%10000010 + !byte $42,%10000010 + !byte $40,%10100010 + !byte $3E,%11000010 + !byte $3C,%11000010 + !byte $3A,%00000011 + !byte $38,%00100011 + !byte $36,%01000011 + !byte $34,%01100011 + !byte $32,%10000011 + !byte $30,%10100011 + !byte $2E,%11000011 + !byte $2C,%00000100 + !byte $2A,%00100100 + !byte $2A,%01000100 + !byte $28,%01100100 + !byte $26,%10000100 + !byte $24,%11000100 + !byte $22,%00000101 + !byte $20,%01000101 + !byte $1E,%01100101 + !byte $1E,%10000101 + !byte $1C,%10100101 + !byte $1A,%00000110 + !byte $18,%01000110 + !byte $16,%10000110 + !byte $14,%11000110 + !byte $12,%00100111 + !byte $12,%01000111 + !byte $10,%10000111 + !byte $0E,%11000111 + !byte $0C,%01001000 + !byte $0A,%10001000 + !byte $0A,%10101000 + !byte $08,%00001001 + !byte $08,%00101001 + !byte $06,%01101001 + !byte $06,%10001001 + !byte $04,%00001010 + !byte $02,%01101010 + !byte $02,%10001010 + !byte $00,%00001011 + !byte $00,%00101011 + !byte $5E,%11000001 + !byte $5C,%11000001 + !byte $5A,%11000001 + !byte $58,%11000001 + !byte $56,%11000001 + !byte $54,%11000001 + !byte $52,%11000001 + !byte $50,%00000010 + !byte $4E,%00000010 + !byte $4C,%00100010 + !byte $4A,%00100010 + !byte $48,%00100010 + !byte $46,%01000010 + !byte $44,%01100010 + !byte $42,%01100010 + !byte $40,%10000010 + !byte $3E,%10000010 + !byte $3E,%10100010 + !byte $3C,%10100010 + !byte $3A,%11000010 + !byte $38,%00000011 + !byte $36,%00100011 + !byte $34,%01000011 + !byte $32,%01100011 + !byte $30,%10000011 + !byte $2E,%10100011 + !byte $2C,%11000011 + !byte $2A,%00000100 + !byte $28,%01000100 + !byte $26,%01100100 + !byte $24,%10000100 + !byte $24,%10100100 + !byte $22,%11000100 + !byte $20,%00000101 + !byte $20,%00100101 + !byte $1E,%01000101 + !byte $1C,%10000101 + !byte $1A,%11000101 + !byte $18,%00000110 + !byte $18,%00100110 + !byte $16,%01100110 + !byte $14,%10100110 + !byte $12,%00000111 + !byte $10,%01000111 + !byte $10,%01100111 + !byte $0E,%10100111 + !byte $0C,%00001000 + !byte $0C,%00101000 + !byte $0A,%01101000 + !byte $08,%10101000 + !byte $08,%11001000 + !byte $06,%01001001 + !byte $04,%10101001 + !byte $04,%11001001 + !byte $02,%00101010 + !byte $02,%01001010 + !byte $00,%10101010 + !byte $00,%11001010 + !byte $5E,%10100001 + !byte $5C,%10100001 + !byte $5A,%10100001 + !byte $58,%10100001 + !byte $56,%10100001 + !byte $54,%10100001 + !byte $52,%10100001 + !byte $50,%11000001 + !byte $4E,%11000001 + !byte $4C,%11000001 + !byte $4C,%00000010 + !byte $4A,%00000010 + !byte $48,%00000010 + !byte $46,%00100010 + !byte $44,%00100010 + !byte $44,%01000010 + !byte $42,%01000010 + !byte $40,%01100010 + !byte $3E,%01100010 + !byte $3C,%10000010 + !byte $3A,%10100010 + !byte $38,%11000010 + !byte $36,%00000011 + !byte $34,%00100011 + !byte $32,%01000011 + !byte $30,%01100011 + !byte $2E,%10000011 + !byte $2C,%10100011 + !byte $2A,%11000011 + !byte $28,%00000100 + !byte $28,%00100100 + !byte $26,%01000100 + !byte $24,%01100100 + !byte $22,%10100100 + !byte $20,%11000100 + !byte $1E,%00100101 + !byte $1C,%01100101 + !byte $1A,%10000101 + !byte $1A,%10100101 + !byte $18,%11000101 + !byte $16,%00100110 + !byte $16,%01000110 + !byte $14,%01100110 + !byte $14,%10000110 + !byte $12,%10100110 + !byte $12,%11000110 + !byte $10,%00100111 + !byte $0E,%01100111 + !byte $0E,%10000111 + !byte $0C,%11000111 + !byte $0A,%00101000 + !byte $0A,%01001000 + !byte $08,%10001000 + !byte $06,%00001001 + !byte $06,%00101001 + !byte $04,%01101001 + !byte $04,%10001001 + !byte $02,%11001001 + !byte $02,%00001010 + !byte $00,%01101010 + !byte $00,%10001010 + !byte $5E,%10000001 + !byte $5C,%10000001 + !byte $5A,%10000001 + !byte $58,%10000001 + !byte $56,%10000001 + !byte $54,%10000001 + !byte $52,%10000001 + !byte $50,%10100001 + !byte $4E,%10100001 + !byte $4C,%10100001 + !byte $4A,%11000001 + !byte $48,%11000001 + !byte $46,%00000010 + !byte $44,%00000010 + !byte $42,%00100010 + !byte $40,%01000010 + !byte $3E,%01000010 + !byte $3C,%01100010 + !byte $3A,%10000010 + !byte $38,%10100010 + !byte $36,%11000010 + !byte $34,%11000010 + !byte $34,%00000011 + !byte $32,%00000011 + !byte $32,%00100011 + !byte $30,%01000011 + !byte $2E,%01100011 + !byte $2C,%10000011 + !byte $2A,%10100011 + !byte $28,%11000011 + !byte $26,%00100100 + !byte $24,%01000100 + !byte $22,%01100100 + !byte $22,%10000100 + !byte $20,%10100100 + !byte $1E,%00000101 + !byte $1C,%00100101 + !byte $1C,%01000101 + !byte $1A,%01100101 + !byte $18,%10100101 + !byte $16,%00000110 + !byte $14,%01000110 + !byte $12,%10000110 + !byte $10,%11000110 + !byte $10,%00000111 + !byte $0E,%00100111 + !byte $0E,%01000111 + !byte $0C,%10000111 + !byte $0C,%10100111 + !byte $0A,%00001000 + !byte $08,%01001000 + !byte $08,%01101000 + !byte $06,%10101000 + !byte $06,%11001000 + !byte $04,%00101001 + !byte $04,%01001001 + !byte $02,%10101001 + !byte $00,%00101010 + !byte $00,%01001010 + !byte $5E,%01100001 + !byte $5C,%01100001 + !byte $5A,%01100001 + !byte $58,%01100001 + !byte $56,%01100001 + !byte $54,%01100001 + !byte $52,%01100001 + !byte $50,%10000001 + !byte $4E,%10000001 + !byte $4C,%10000001 + !byte $4A,%10100001 + !byte $48,%10100001 + !byte $46,%11000001 + !byte $44,%11000001 + !byte $42,%00000010 + !byte $40,%00100010 + !byte $3E,%00100010 + !byte $3C,%01000010 + !byte $3A,%01100010 + !byte $38,%10000010 + !byte $36,%10000010 + !byte $36,%10100010 + !byte $34,%10100010 + !byte $32,%11000010 + !byte $30,%00000011 + !byte $30,%00100011 + !byte $2E,%00100011 + !byte $2E,%01000011 + !byte $2C,%01100011 + !byte $2A,%10000011 + !byte $28,%10100011 + !byte $26,%00000100 + !byte $24,%00100100 + !byte $22,%01000100 + !byte $20,%10000100 + !byte $1E,%10100100 + !byte $1E,%11000100 + !byte $1C,%00000101 + !byte $1A,%01000101 + !byte $18,%10000101 + !byte $16,%10100101 + !byte $16,%11000101 + !byte $14,%00000110 + !byte $14,%00100110 + !byte $12,%01100110 + !byte $10,%10100110 + !byte $0E,%00000111 + !byte $0C,%01100111 + !byte $0A,%10100111 + !byte $0A,%11000111 + !byte $08,%00101000 + !byte $06,%10001000 + !byte $04,%00001001 + !byte $02,%01101001 + !byte $02,%10001001 + !byte $00,%11001001 + !byte $00,%00001010 + !byte $5E,%01000001 + !byte $5C,%01000001 + !byte $5A,%01000001 + !byte $58,%01000001 + !byte $56,%01000001 + !byte $54,%01000001 + !byte $52,%01000001 + !byte $50,%01100001 + !byte $4E,%01100001 + !byte $4C,%01100001 + !byte $4A,%10000001 + !byte $48,%10000001 + !byte $46,%10100001 + !byte $44,%10100001 + !byte $42,%11000001 + !byte $40,%00000010 + !byte $3E,%00000010 + !byte $3C,%00100010 + !byte $3A,%01000010 + !byte $38,%01100010 + !byte $36,%01100010 + !byte $34,%10000010 + !byte $32,%10100010 + !byte $30,%11000010 + !byte $2E,%00000011 + !byte $2C,%01000011 + !byte $2A,%01100011 + !byte $28,%10000011 + !byte $26,%10100011 + !byte $26,%11000011 + !byte $24,%00000100 + !byte $22,%00100100 + !byte $20,%01100100 + !byte $1E,%10000100 + !byte $1C,%11000100 + !byte $1A,%00000101 + !byte $1A,%00100101 + !byte $18,%01000101 + !byte $18,%01100101 + !byte $16,%10000101 + !byte $14,%11000101 + !byte $12,%00100110 + !byte $12,%01000110 + !byte $10,%01100110 + !byte $10,%10000110 + !byte $0E,%11000110 + !byte $0C,%00100111 + !byte $0C,%01000111 + !byte $0A,%10000111 + !byte $08,%11000111 + !byte $08,%00001000 + !byte $06,%01001000 + !byte $06,%01101000 + !byte $04,%10101000 + !byte $04,%11001000 + !byte $02,%00101001 + !byte $02,%01001001 + !byte $00,%10001001 + !byte $00,%10101001 + !byte $5E,%00100001 + !byte $5C,%00100001 + !byte $5A,%00100001 + !byte $58,%00100001 + !byte $56,%00100001 + !byte $54,%00100001 + !byte $52,%00100001 + !byte $50,%01000001 + !byte $4E,%01000001 + !byte $4C,%01000001 + !byte $4A,%01100001 + !byte $48,%01100001 + !byte $46,%10000001 + !byte $44,%10000001 + !byte $42,%10100001 + !byte $40,%11000001 + !byte $3E,%11000001 + !byte $3C,%00000010 + !byte $3A,%00100010 + !byte $38,%00100010 + !byte $38,%01000010 + !byte $36,%01000010 + !byte $34,%01100010 + !byte $32,%10000010 + !byte $30,%10100010 + !byte $2E,%11000010 + !byte $2C,%00000011 + !byte $2C,%00100011 + !byte $2A,%01000011 + !byte $28,%01100011 + !byte $26,%10000011 + !byte $24,%11000011 + !byte $22,%00000100 + !byte $20,%00100100 + !byte $20,%01000100 + !byte $1E,%01100100 + !byte $1C,%10100100 + !byte $1A,%11000100 + !byte $18,%00100101 + !byte $16,%01100101 + !byte $14,%10100101 + !byte $12,%00000110 + !byte $10,%01000110 + !byte $0E,%10000110 + !byte $0E,%10100110 + !byte $0C,%11000110 + !byte $0C,%00000111 + !byte $0A,%01000111 + !byte $0A,%01100111 + !byte $08,%10100111 + !byte $06,%00001000 + !byte $06,%00101000 + !byte $04,%01101000 + !byte $04,%10001000 + !byte $02,%11001000 + !byte $02,%00001001 + !byte $00,%01101001 + !byte $5E,%00000001 + !byte $5C,%00000001 + !byte $5A,%00000001 + !byte $58,%00000001 + !byte $56,%00000001 + !byte $54,%00000001 + !byte $52,%00000001 + !byte $50,%00100001 + !byte $4E,%00100001 + !byte $4C,%00100001 + !byte $4A,%01000001 + !byte $48,%01000001 + !byte $46,%01100001 + !byte $44,%01100001 + !byte $42,%10000001 + !byte $40,%10100001 + !byte $3E,%10100001 + !byte $3C,%11000001 + !byte $3A,%00000010 + !byte $38,%00000010 + !byte $36,%00100010 + !byte $34,%01000010 + !byte $32,%01100010 + !byte $30,%10000010 + !byte $2E,%10100010 + !byte $2C,%11000010 + !byte $2A,%00000011 + !byte $2A,%00100011 + !byte $28,%01000011 + !byte $26,%01100011 + !byte $24,%10000011 + !byte $24,%10100011 + !byte $22,%11000011 + !byte $20,%00000100 + !byte $1E,%01000100 + !byte $1C,%01100100 + !byte $1C,%10000100 + !byte $1A,%10100100 + !byte $18,%00000101 + !byte $16,%01000101 + !byte $14,%10000101 + !byte $12,%10100101 + !byte $12,%11000101 + !byte $10,%00100110 + !byte $0E,%01100110 + !byte $0C,%10100110 + !byte $0A,%00000111 + !byte $0A,%00100111 + !byte $08,%01100111 + !byte $08,%10000111 + !byte $06,%11000111 + !byte $04,%01001000 + !byte $02,%10101000 + !byte $00,%00101001 + !byte $00,%01001001 + !byte $5E,%11000000 + !byte $5C,%11000000 + !byte $5A,%11000000 + !byte $58,%11000000 + !byte $56,%11000000 + !byte $54,%11000000 + !byte $52,%11000000 + !byte $50,%00000001 + !byte $4E,%00000001 + !byte $4C,%00000001 + !byte $4A,%00100001 + !byte $48,%00100001 + !byte $46,%01000001 + !byte $44,%01000001 + !byte $42,%01100001 + !byte $40,%01100001 + !byte $40,%10000001 + !byte $3E,%10000001 + !byte $3C,%10100001 + !byte $3A,%11000001 + !byte $38,%11000001 + !byte $36,%00000010 + !byte $34,%00100010 + !byte $32,%01000010 + !byte $30,%01100010 + !byte $2E,%10000010 + !byte $2C,%10100010 + !byte $2A,%11000010 + !byte $28,%00100011 + !byte $26,%01000011 + !byte $24,%01100011 + !byte $22,%10100011 + !byte $20,%11000011 + !byte $1E,%00000100 + !byte $1E,%00100100 + !byte $1C,%01000100 + !byte $1A,%10000100 + !byte $18,%10100100 + !byte $18,%11000100 + !byte $16,%00000101 + !byte $16,%00100101 + !byte $14,%01000101 + !byte $14,%01100101 + !byte $12,%10000101 + !byte $10,%11000101 + !byte $10,%00000110 + !byte $0E,%01000110 + !byte $0C,%10000110 + !byte $0A,%11000110 + !byte $08,%01000111 + !byte $06,%10000111 + !byte $06,%10100111 + !byte $04,%00001000 + !byte $04,%00101000 + !byte $02,%01101000 + !byte $02,%10001000 + !byte $00,%11001000 + !byte $00,%00001001 + !byte $5E,%10100000 + !byte $5C,%10100000 + !byte $5A,%10100000 + !byte $58,%10100000 + !byte $56,%10100000 + !byte $54,%10100000 + !byte $52,%10100000 + !byte $50,%11000000 + !byte $4E,%11000000 + !byte $4C,%11000000 + !byte $4A,%00000001 + !byte $48,%00000001 + !byte $46,%00100001 + !byte $44,%00100001 + !byte $42,%01000001 + !byte $40,%01000001 + !byte $3E,%01100001 + !byte $3C,%10000001 + !byte $3A,%10100001 + !byte $38,%10100001 + !byte $36,%11000001 + !byte $34,%00000010 + !byte $32,%00100010 + !byte $30,%01000010 + !byte $2E,%01100010 + !byte $2C,%10000010 + !byte $2A,%10100010 + !byte $28,%11000010 + !byte $28,%00000011 + !byte $26,%00100011 + !byte $24,%01000011 + !byte $22,%01100011 + !byte $22,%10000011 + !byte $20,%10100011 + !byte $1E,%11000011 + !byte $1C,%00100100 + !byte $1A,%01100100 + !byte $18,%10000100 + !byte $16,%11000100 + !byte $14,%00100101 + !byte $12,%01100101 + !byte $10,%10100101 + !byte $0E,%00000110 + !byte $0E,%00100110 + !byte $0C,%01000110 + !byte $0C,%01100110 + !byte $0A,%10100110 + !byte $08,%00000111 + !byte $08,%00100111 + !byte $06,%01100111 + !byte $04,%10100111 + !byte $04,%11000111 + !byte $02,%00101000 + !byte $02,%01001000 + !byte $00,%10001000 + !byte $00,%10101000 + !byte $5E,%10000000 + !byte $5C,%10000000 + !byte $5A,%10000000 + !byte $58,%10000000 + !byte $56,%10000000 + !byte $54,%10000000 + !byte $52,%10000000 + !byte $50,%10100000 + !byte $4E,%10100000 + !byte $4C,%10100000 + !byte $4A,%11000000 + !byte $48,%11000000 + !byte $46,%00000001 + !byte $44,%00000001 + !byte $42,%00100001 + !byte $40,%00100001 + !byte $3E,%01000001 + !byte $3C,%01100001 + !byte $3A,%10000001 + !byte $38,%10000001 + !byte $36,%10100001 + !byte $34,%11000001 + !byte $32,%00000010 + !byte $30,%00100010 + !byte $2E,%01000010 + !byte $2C,%01100010 + !byte $2A,%10000010 + !byte $28,%10100010 + !byte $26,%00000011 + !byte $24,%00100011 + !byte $22,%01000011 + !byte $20,%10000011 + !byte $1E,%10100011 + !byte $1C,%00000100 + !byte $1A,%00100100 + !byte $1A,%01000100 + !byte $18,%01100100 + !byte $16,%10100100 + !byte $14,%00000101 + !byte $12,%01000101 + !byte $10,%01100101 + !byte $10,%10000101 + !byte $0E,%11000101 + !byte $0C,%00100110 + !byte $0A,%01100110 + !byte $0A,%10000110 + !byte $08,%11000110 + !byte $06,%00100111 + !byte $06,%01000111 + !byte $04,%10000111 + !byte $02,%00001000 + !byte $00,%01101000 + !byte $5E,%01100000 + !byte $5C,%01100000 + !byte $5A,%01100000 + !byte $58,%01100000 + !byte $56,%01100000 + !byte $54,%01100000 + !byte $52,%01100000 + !byte $50,%10000000 + !byte $4E,%10000000 + !byte $4C,%10000000 + !byte $4A,%10100000 + !byte $48,%10100000 + !byte $46,%11000000 + !byte $44,%11000000 + !byte $42,%00000001 + !byte $40,%00000001 + !byte $3E,%00100001 + !byte $3C,%01000001 + !byte $3A,%01000001 + !byte $3A,%01100001 + !byte $38,%01100001 + !byte $36,%10000001 + !byte $34,%10100001 + !byte $32,%11000001 + !byte $30,%00000010 + !byte $2E,%00100010 + !byte $2C,%01000010 + !byte $2A,%01100010 + !byte $28,%10000010 + !byte $26,%10100010 + !byte $26,%11000010 + !byte $24,%00000011 + !byte $22,%00100011 + !byte $20,%01000011 + !byte $20,%01100011 + !byte $1E,%10000011 + !byte $1C,%10100011 + !byte $1C,%11000011 + !byte $1A,%00000100 + !byte $18,%01000100 + !byte $16,%01100100 + !byte $16,%10000100 + !byte $14,%10100100 + !byte $14,%11000100 + !byte $12,%00000101 + !byte $12,%00100101 + !byte $10,%01000101 + !byte $0E,%10000101 + !byte $0E,%10100101 + !byte $0C,%11000101 + !byte $0C,%00000110 + !byte $0A,%01000110 + !byte $08,%10000110 + !byte $08,%10100110 + !byte $06,%00000111 + !byte $04,%01000111 + !byte $04,%01100111 + !byte $02,%10100111 + !byte $02,%11000111 + !byte $00,%00101000 + !byte $00,%01001000 + !byte $5E,%01000000 + !byte $5C,%01000000 + !byte $5A,%01000000 + !byte $58,%01000000 + !byte $56,%01000000 + !byte $54,%01000000 + !byte $52,%01000000 + !byte $50,%01100000 + !byte $4E,%01100000 + !byte $4C,%01100000 + !byte $4A,%10000000 + !byte $48,%10000000 + !byte $46,%10100000 + !byte $44,%10100000 + !byte $42,%11000000 + !byte $40,%11000000 + !byte $3E,%00000001 + !byte $3C,%00100001 + !byte $3A,%00100001 + !byte $38,%01000001 + !byte $36,%01100001 + !byte $34,%10000001 + !byte $32,%10100001 + !byte $30,%11000001 + !byte $2E,%00000010 + !byte $2C,%00100010 + !byte $2A,%01000010 + !byte $28,%01100010 + !byte $26,%10000010 + !byte $24,%11000010 + !byte $22,%00000011 + !byte $20,%00100011 + !byte $1E,%01100011 + !byte $1C,%10000011 + !byte $1A,%11000011 + !byte $18,%00100100 + !byte $16,%01000100 + !byte $14,%10000100 + !byte $12,%11000100 + !byte $10,%00100101 + !byte $0E,%01100101 + !byte $0C,%10100101 + !byte $0A,%00000110 + !byte $0A,%00100110 + !byte $08,%01100110 + !byte $06,%10100110 + !byte $06,%11000110 + !byte $04,%00100111 + !byte $02,%01100111 + !byte $02,%10000111 + !byte $00,%11000111 + !byte $00,%00001000 + !byte $5E,%00100000 + !byte $5C,%00100000 + !byte $5A,%00100000 + !byte $58,%00100000 + !byte $56,%00100000 + !byte $54,%00100000 + !byte $52,%00100000 + !byte $50,%01000000 + !byte $4E,%01000000 + !byte $4C,%01000000 + !byte $4A,%01100000 + !byte $48,%01100000 + !byte $46,%10000000 + !byte $44,%10000000 + !byte $42,%10100000 + !byte $40,%10100000 + !byte $3E,%11000000 + !byte $3C,%00000001 + !byte $3A,%00000001 + !byte $38,%00100001 + !byte $36,%01000001 + !byte $34,%01100001 + !byte $32,%10000001 + !byte $30,%10100001 + !byte $2E,%11000001 + !byte $2C,%00000010 + !byte $2A,%00100010 + !byte $28,%01000010 + !byte $26,%01100010 + !byte $24,%10000010 + !byte $24,%10100010 + !byte $22,%11000010 + !byte $20,%00000011 + !byte $1E,%01000011 + !byte $1C,%01100011 + !byte $1A,%10100011 + !byte $18,%11000011 + !byte $18,%00000100 + !byte $16,%00100100 + !byte $14,%01100100 + !byte $12,%10100100 + !byte $10,%00000101 + !byte $0E,%01000101 + !byte $0C,%10000101 + !byte $0A,%11000101 + !byte $08,%00100110 + !byte $08,%01000110 + !byte $06,%10000110 + !byte $04,%11000110 + !byte $04,%00000111 + !byte $02,%01000111 + !byte $00,%10100111 + !byte $5E,%00000000 + !byte $5C,%00000000 + !byte $5A,%00000000 + !byte $58,%00000000 + !byte $56,%00000000 + !byte $54,%00000000 + !byte $52,%00000000 + !byte $50,%00100000 + !byte $4E,%00100000 + !byte $4C,%00100000 + !byte $4A,%01000000 + !byte $48,%01000000 + !byte $46,%01100000 + !byte $44,%01100000 + !byte $42,%10000000 + !byte $40,%10000000 + !byte $3E,%10100000 + !byte $3C,%11000000 + !byte $3A,%11000000 + !byte $38,%00000001 + !byte $36,%00100001 + !byte $34,%01000001 + !byte $32,%01100001 + !byte $30,%01100001 + !byte $30,%10000001 + !byte $2E,%10000001 + !byte $2E,%10100001 + !byte $2C,%11000001 + !byte $2A,%00000010 + !byte $28,%00100010 + !byte $26,%01000010 + !byte $24,%01100010 + !byte $22,%10100010 + !byte $20,%11000010 + !byte $1E,%00000011 + !byte $1E,%00100011 + !byte $1C,%01000011 + !byte $1A,%01100011 + !byte $1A,%10000011 + !byte $18,%10100011 + !byte $16,%00000100 + !byte $14,%01000100 + !byte $12,%01100100 + !byte $12,%10000100 + !byte $10,%10100100 + !byte $10,%11000100 + !byte $0E,%00000101 + !byte $0E,%00100101 + !byte $0C,%01000101 + !byte $0C,%01100101 + !byte $0A,%10000101 + !byte $0A,%10100101 + !byte $08,%00000110 + !byte $06,%01000110 + !byte $06,%01100110 + !byte $04,%10100110 + !byte $02,%00000111 + !byte $02,%00100111 + !byte $00,%01100111 + !byte $00,%10000111 + !byte $50,%00000000 + !byte $4E,%00000000 + !byte $4C,%00000000 + !byte $4A,%00100000 + !byte $48,%00100000 + !byte $46,%01000000 + !byte $44,%01000000 + !byte $42,%01100000 + !byte $40,%01100000 + !byte $3E,%10000000 + !byte $3C,%10100000 + !byte $3A,%10100000 + !byte $38,%11000000 + !byte $36,%00000001 + !byte $34,%00100001 + !byte $32,%00100001 + !byte $32,%01000001 + !byte $30,%01000001 + !byte $2E,%01100001 + !byte $2C,%10000001 + !byte $2C,%10100001 + !byte $2A,%10100001 + !byte $2A,%11000001 + !byte $28,%00000010 + !byte $26,%00100010 + !byte $24,%01000010 + !byte $22,%01100010 + !byte $22,%10000010 + !byte $20,%10100010 + !byte $1E,%11000010 + !byte $1C,%00100011 + !byte $1A,%01000011 + !byte $18,%10000011 + !byte $16,%10100011 + !byte $16,%11000011 + !byte $14,%00000100 + !byte $14,%00100100 + !byte $12,%01000100 + !byte $10,%10000100 + !byte $0E,%11000100 + !byte $0C,%00100101 + !byte $0A,%01100101 + !byte $08,%10100101 + !byte $08,%11000101 + !byte $06,%00100110 + !byte $04,%01100110 + !byte $04,%10000110 + !byte $02,%11000110 + !byte $00,%01000111 + !byte $4A,%00000000 + !byte $48,%00000000 + !byte $46,%00100000 + !byte $44,%00100000 + !byte $42,%01000000 + !byte $40,%01000000 + !byte $3E,%01100000 + !byte $3C,%01100000 + !byte $3C,%10000000 + !byte $3A,%10000000 + !byte $38,%10100000 + !byte $36,%11000000 + !byte $34,%00000001 + !byte $32,%00000001 + !byte $30,%00100001 + !byte $2E,%01000001 + !byte $2C,%01100001 + !byte $2A,%10000001 + !byte $28,%10100001 + !byte $28,%11000001 + !byte $26,%00000010 + !byte $24,%00100010 + !byte $22,%01000010 + !byte $20,%10000010 + !byte $1E,%10100010 + !byte $1C,%11000010 + !byte $1C,%00000011 + !byte $1A,%00100011 + !byte $18,%01100011 + !byte $16,%10000011 + !byte $14,%11000011 + !byte $12,%00100100 + !byte $10,%01100100 + !byte $0E,%10100100 + !byte $0C,%00000101 + !byte $0A,%01000101 + !byte $08,%10000101 + !byte $06,%11000101 + !byte $06,%00000110 + !byte $04,%01000110 + !byte $02,%10000110 + !byte $02,%10100110 + !byte $00,%00000111 + !byte $00,%00100111 + !byte $46,%00000000 + !byte $44,%00000000 + !byte $42,%00100000 + !byte $40,%00100000 + !byte $3E,%01000000 + !byte $3C,%01000000 + !byte $3A,%01100000 + !byte $38,%10000000 + !byte $36,%10100000 + !byte $34,%11000000 + !byte $32,%11000000 + !byte $30,%00000001 + !byte $2E,%00100001 + !byte $2C,%01000001 + !byte $2A,%01100001 + !byte $28,%10000001 + !byte $26,%11000001 + !byte $24,%00000010 + !byte $22,%00100010 + !byte $20,%01000010 + !byte $20,%01100010 + !byte $1E,%10000010 + !byte $1C,%10100010 + !byte $1A,%00000011 + !byte $18,%00100011 + !byte $18,%01000011 + !byte $16,%01100011 + !byte $14,%10100011 + !byte $12,%00000100 + !byte $10,%00100100 + !byte $10,%01000100 + !byte $0E,%01100100 + !byte $0E,%10000100 + !byte $0C,%10100100 + !byte $0C,%11000100 + !byte $0A,%00000101 + !byte $0A,%00100101 + !byte $08,%01100101 + !byte $06,%10100101 + !byte $04,%00000110 + !byte $04,%00100110 + !byte $02,%01100110 + !byte $00,%11000110 + !byte $42,%00000000 + !byte $40,%00000000 + !byte $3E,%00100000 + !byte $3C,%00100000 + !byte $3A,%01000000 + !byte $38,%01100000 + !byte $36,%10000000 + !byte $34,%10000000 + !byte $34,%10100000 + !byte $32,%10100000 + !byte $30,%11000000 + !byte $2E,%00000001 + !byte $2C,%00100001 + !byte $2A,%01000001 + !byte $28,%01100001 + !byte $26,%10000001 + !byte $26,%10100001 + !byte $24,%11000001 + !byte $22,%00000010 + !byte $20,%00100010 + !byte $1E,%01100010 + !byte $1C,%10000010 + !byte $1A,%11000010 + !byte $18,%00000011 + !byte $16,%01000011 + !byte $14,%01100011 + !byte $14,%10000011 + !byte $12,%10100011 + !byte $12,%11000011 + !byte $10,%00000100 + !byte $0E,%01000100 + !byte $0C,%10000100 + !byte $0A,%11000100 + !byte $08,%00100101 + !byte $08,%01000101 + !byte $06,%01100101 + !byte $06,%10000101 + !byte $04,%11000101 + !byte $02,%00100110 + !byte $02,%01000110 + !byte $00,%10000110 + !byte $00,%10100110 + !byte $3E,%00000000 + !byte $3C,%00000000 + !byte $3A,%00100000 + !byte $38,%01000000 + !byte $36,%01100000 + !byte $34,%01100000 + !byte $32,%10000000 + !byte $30,%10100000 + !byte $2E,%11000000 + !byte $2C,%00000001 + !byte $2A,%00100001 + !byte $28,%01000001 + !byte $26,%01100001 + !byte $24,%10100001 + !byte $22,%11000001 + !byte $20,%00000010 + !byte $1E,%01000010 + !byte $1C,%01100010 + !byte $1A,%10000010 + !byte $1A,%10100010 + !byte $18,%11000010 + !byte $16,%00100011 + !byte $14,%01000011 + !byte $12,%10000011 + !byte $10,%11000011 + !byte $0E,%00100100 + !byte $0C,%01100100 + !byte $0A,%10100100 + !byte $08,%00000101 + !byte $06,%01000101 + !byte $04,%10000101 + !byte $04,%10100101 + !byte $02,%00000110 + !byte $00,%01100110 + !byte $3A,%00000000 + !byte $38,%00100000 + !byte $36,%01000000 + !byte $34,%01000000 + !byte $32,%01100000 + !byte $30,%10000000 + !byte $2E,%10100000 + !byte $2C,%11000000 + !byte $2A,%00000001 + !byte $28,%00100001 + !byte $26,%01000001 + !byte $24,%01100001 + !byte $24,%10000001 + !byte $22,%10100001 + !byte $20,%11000001 + !byte $1E,%00000010 + !byte $1E,%00100010 + !byte $1C,%01000010 + !byte $1A,%01100010 + !byte $18,%10100010 + !byte $16,%11000010 + !byte $16,%00000011 + !byte $14,%00100011 + !byte $12,%01100011 + !byte $10,%10000011 + !byte $10,%10100011 + !byte $0E,%11000011 + !byte $0E,%00000100 + !byte $0C,%00100100 + !byte $0C,%01000100 + !byte $0A,%01100100 + !byte $0A,%10000100 + !byte $08,%10100100 + !byte $08,%11000100 + !byte $06,%00100101 + !byte $04,%01100101 + !byte $02,%10100101 + !byte $02,%11000101 + !byte $00,%00100110 + !byte $00,%01000110 + !byte $38,%00000000 + !byte $36,%00000000 + !byte $36,%00100000 + !byte $34,%00100000 + !byte $32,%01000000 + !byte $30,%01100000 + !byte $2E,%10000000 + !byte $2C,%10100000 + !byte $2A,%11000000 + !byte $28,%00000001 + !byte $26,%00100001 + !byte $24,%01000001 + !byte $22,%10000001 + !byte $20,%10100001 + !byte $1E,%11000001 + !byte $1C,%00100010 + !byte $1A,%01000010 + !byte $18,%01100010 + !byte $18,%10000010 + !byte $16,%10100010 + !byte $14,%00000011 + !byte $12,%00100011 + !byte $12,%01000011 + !byte $10,%01100011 + !byte $0E,%10100011 + !byte $0C,%00000100 + !byte $0A,%01000100 + !byte $08,%10000100 + !byte $06,%11000100 + !byte $06,%00000101 + !byte $04,%00100101 + !byte $04,%01000101 + !byte $02,%10000101 + !byte $00,%11000101 + !byte $00,%00000110 + !byte $34,%00000000 + !byte $32,%00100000 + !byte $30,%01000000 + !byte $2E,%01100000 + !byte $2C,%10000000 + !byte $2A,%10100000 + !byte $28,%11000000 + !byte $26,%00000001 + !byte $24,%00100001 + !byte $22,%01000001 + !byte $22,%01100001 + !byte $20,%10000001 + !byte $1E,%10100001 + !byte $1C,%11000001 + !byte $1C,%00000010 + !byte $1A,%00100010 + !byte $18,%01000010 + !byte $16,%10000010 + !byte $14,%10100010 + !byte $14,%11000010 + !byte $12,%00000011 + !byte $10,%01000011 + !byte $0E,%10000011 + !byte $0C,%11000011 + !byte $0A,%00100100 + !byte $08,%01100100 + !byte $06,%10100100 + !byte $04,%00000101 + !byte $02,%01000101 + !byte $02,%01100101 + !byte $00,%10100101 + !byte $32,%00000000 + !byte $30,%00100000 + !byte $2E,%01000000 + !byte $2C,%01100000 + !byte $2A,%10000000 + !byte $28,%10100000 + !byte $26,%11000000 + !byte $24,%00000001 + !byte $22,%00100001 + !byte $20,%01100001 + !byte $1E,%10000001 + !byte $1C,%10100001 + !byte $1A,%00000010 + !byte $18,%00100010 + !byte $16,%01100010 + !byte $14,%10000010 + !byte $12,%11000010 + !byte $10,%00100011 + !byte $0E,%01000011 + !byte $0E,%01100011 + !byte $0C,%10000011 + !byte $0C,%10100011 + !byte $0A,%11000011 + !byte $0A,%00000100 + !byte $08,%00100100 + !byte $08,%01000100 + !byte $06,%01100100 + !byte $06,%10000100 + !byte $04,%11000100 + !byte $02,%00100101 + !byte $00,%01100101 + !byte $00,%10000101 + !byte $30,%00000000 + !byte $2E,%00100000 + !byte $2C,%01000000 + !byte $2A,%01100000 + !byte $28,%10000000 + !byte $26,%10100000 + !byte $24,%11000000 + !byte $22,%00000001 + !byte $20,%00100001 + !byte $20,%01000001 + !byte $1E,%01100001 + !byte $1C,%10000001 + !byte $1A,%10100001 + !byte $1A,%11000001 + !byte $18,%00000010 + !byte $16,%00100010 + !byte $16,%01000010 + !byte $14,%01100010 + !byte $12,%10100010 + !byte $10,%11000010 + !byte $10,%00000011 + !byte $0E,%00100011 + !byte $0C,%01100011 + !byte $0A,%10100011 + !byte $08,%00000100 + !byte $06,%01000100 + !byte $04,%10000100 + !byte $04,%10100100 + !byte $02,%00000101 + !byte $00,%01000101 + !byte $2E,%00000000 + !byte $2C,%00100000 + !byte $2A,%01000000 + !byte $28,%01100000 + !byte $26,%10000000 + !byte $24,%10100000 + !byte $22,%11000000 + !byte $20,%00000001 + !byte $1E,%01000001 + !byte $1C,%01100001 + !byte $1A,%10000001 + !byte $18,%11000001 + !byte $16,%00000010 + !byte $14,%01000010 + !byte $12,%01100010 + !byte $12,%10000010 + !byte $10,%10100010 + !byte $0E,%00000011 + !byte $0C,%01000011 + !byte $0A,%10000011 + !byte $08,%11000011 + !byte $06,%00100100 + !byte $04,%01100100 + !byte $02,%10100100 + !byte $02,%11000100 + !byte $00,%00100101 + !byte $2C,%00000000 + !byte $2A,%00000000 + !byte $2A,%00100000 + !byte $28,%00100000 + !byte $28,%01000000 + !byte $26,%01100000 + !byte $24,%10000000 + !byte $22,%10100000 + !byte $20,%11000000 + !byte $1E,%00000001 + !byte $1E,%00100001 + !byte $1C,%01000001 + !byte $1A,%01100001 + !byte $18,%10000001 + !byte $18,%10100001 + !byte $16,%11000001 + !byte $14,%00100010 + !byte $12,%01000010 + !byte $10,%10000010 + !byte $0E,%11000010 + !byte $0C,%00000011 + !byte $0C,%00100011 + !byte $0A,%01000011 + !byte $0A,%01100011 + !byte $08,%10000011 + !byte $08,%10100011 + !byte $06,%11000011 + !byte $06,%00000100 + !byte $04,%00100100 + !byte $04,%01000100 + !byte $02,%10000100 + !byte $00,%11000100 + !byte $00,%00000101 + !byte $28,%00000000 + !byte $26,%00100000 + !byte $26,%01000000 + !byte $24,%01100000 + !byte $22,%10000000 + !byte $20,%10100000 + !byte $1E,%11000000 + !byte $1C,%00100001 + !byte $1A,%01000001 + !byte $18,%01100001 + !byte $16,%10100001 + !byte $14,%11000001 + !byte $14,%00000010 + !byte $12,%00100010 + !byte $10,%01100010 + !byte $0E,%10000010 + !byte $0E,%10100010 + !byte $0C,%11000010 + !byte $0A,%00100011 + !byte $08,%01100011 + !byte $06,%10100011 + !byte $04,%00000100 + !byte $02,%01000100 + !byte $02,%01100100 + !byte $00,%10100100 + !byte $26,%00000000 + !byte $24,%00100000 + !byte $24,%01000000 + !byte $22,%01100000 + !byte $20,%10000000 + !byte $1E,%10100000 + !byte $1C,%11000000 + !byte $1C,%00000001 + !byte $1A,%00100001 + !byte $18,%01000001 + !byte $16,%10000001 + !byte $14,%10100001 + !byte $12,%00000010 + !byte $10,%00100010 + !byte $10,%01000010 + !byte $0E,%01100010 + !byte $0C,%10100010 + !byte $0A,%00000011 + !byte $08,%01000011 + !byte $06,%10000011 + !byte $04,%11000011 + !byte $02,%00100100 + !byte $00,%01100100 + !byte $00,%10000100 + !byte $24,%00000000 + !byte $22,%01000000 + !byte $20,%01100000 + !byte $1E,%10000000 + !byte $1C,%10100000 + !byte $1A,%00000001 + !byte $18,%00100001 + !byte $16,%01000001 + !byte $16,%01100001 + !byte $14,%10000001 + !byte $12,%11000001 + !byte $10,%00000010 + !byte $0E,%01000010 + !byte $0C,%10000010 + !byte $0A,%10100010 + !byte $0A,%11000010 + !byte $08,%00000011 + !byte $08,%00100011 + !byte $06,%01000011 + !byte $06,%01100011 + !byte $04,%10000011 + !byte $04,%10100011 + !byte $02,%11000011 + !byte $02,%00000100 + !byte $00,%01000100 + !byte $22,%00000000 + !byte $22,%00100000 + !byte $20,%01000000 + !byte $1E,%01100000 + !byte $1C,%10000000 + !byte $1A,%10100000 + !byte $1A,%11000000 + !byte $18,%00000001 + !byte $16,%00100001 + !byte $14,%01100001 + !byte $12,%10000001 + !byte $12,%10100001 + !byte $10,%11000001 + !byte $0E,%00100010 + !byte $0C,%01000010 + !byte $0C,%01100010 + !byte $0A,%10000010 + !byte $08,%11000010 + !byte $06,%00100011 + !byte $04,%01100011 + !byte $02,%10100011 + !byte $00,%00000100 + !byte $00,%00100100 + !byte $20,%00000000 + !byte $20,%00100000 + !byte $1E,%01000000 + !byte $1C,%01100000 + !byte $1A,%10000000 + !byte $18,%11000000 + !byte $16,%00000001 + !byte $14,%00100001 + !byte $14,%01000001 + !byte $12,%01100001 + !byte $10,%10100001 + !byte $0E,%11000001 + !byte $0E,%00000010 + !byte $0C,%00100010 + !byte $0A,%01100010 + !byte $08,%10100010 + !byte $06,%00000011 + !byte $04,%01000011 + !byte $02,%10000011 + !byte $00,%11000011 + !byte $1E,%00100000 + !byte $1C,%01000000 + !byte $1A,%01100000 + !byte $18,%10000000 + !byte $18,%10100000 + !byte $16,%11000000 + !byte $14,%00000001 + !byte $12,%01000001 + !byte $10,%01100001 + !byte $10,%10000001 + !byte $0E,%10100001 + !byte $0C,%00000010 + !byte $0A,%01000010 + !byte $08,%10000010 + !byte $06,%10100010 + !byte $06,%11000010 + !byte $04,%00000011 + !byte $04,%00100011 + !byte $02,%01100011 + !byte $00,%10100011 + !byte $1E,%00000000 + !byte $1C,%00100000 + !byte $1A,%01000000 + !byte $18,%01100000 + !byte $16,%10100000 + !byte $14,%11000000 + !byte $12,%00100001 + !byte $10,%01000001 + !byte $0E,%10000001 + !byte $0C,%11000001 + !byte $0A,%00000010 + !byte $0A,%00100010 + !byte $08,%01000010 + !byte $08,%01100010 + !byte $06,%10000010 + !byte $04,%11000010 + !byte $02,%00100011 + !byte $02,%01000011 + !byte $00,%01100011 + !byte $00,%10000011 + !byte $1C,%00000000 + !byte $1A,%00100000 + !byte $18,%01000000 + !byte $16,%01100000 + !byte $16,%10000000 + !byte $14,%10100000 + !byte $12,%11000000 + !byte $12,%00000001 + !byte $10,%00100001 + !byte $0E,%01100001 + !byte $0C,%10000001 + !byte $0C,%10100001 + !byte $0A,%11000001 + !byte $08,%00100010 + !byte $06,%01100010 + !byte $04,%10100010 + !byte $02,%00000011 + !byte $00,%01000011 + !byte $1A,%00000000 + !byte $18,%00100000 + !byte $16,%01000000 + !byte $14,%10000000 + !byte $12,%10100000 + !byte $10,%00000001 + !byte $0E,%00100001 + !byte $0E,%01000001 + !byte $0C,%01100001 + !byte $0A,%10100001 + !byte $08,%00000010 + !byte $06,%00100010 + !byte $06,%01000010 + !byte $04,%01100010 + !byte $04,%10000010 + !byte $02,%10100010 + !byte $02,%11000010 + !byte $00,%00000011 + !byte $00,%00100011 + !byte $18,%00000000 + !byte $16,%00100000 + !byte $14,%01100000 + !byte $12,%10000000 + !byte $10,%11000000 + !byte $0E,%00000001 + !byte $0C,%01000001 + !byte $0A,%10000001 + !byte $08,%10100001 + !byte $08,%11000001 + !byte $06,%00000010 + !byte $04,%01000010 + !byte $02,%10000010 + !byte $00,%11000010 + !byte $16,%00000000 + !byte $14,%00100000 + !byte $14,%01000000 + !byte $12,%01100000 + !byte $10,%10000000 + !byte $10,%10100000 + !byte $0E,%11000000 + !byte $0C,%00100001 + !byte $0A,%01000001 + !byte $0A,%01100001 + !byte $08,%10000001 + !byte $06,%11000001 + !byte $04,%00100010 + !byte $02,%01100010 + !byte $00,%10100010 + !byte $14,%00000000 + !byte $12,%01000000 + !byte $10,%01100000 + !byte $0E,%10100000 + !byte $0C,%11000000 + !byte $0C,%00000001 + !byte $0A,%00100001 + !byte $08,%01100001 + !byte $06,%10100001 + !byte $04,%11000001 + !byte $04,%00000010 + !byte $02,%00100010 + !byte $02,%01000010 + !byte $00,%01100010 + !byte $00,%10000010 + !byte $12,%00000000 + !byte $12,%00100000 + !byte $10,%01000000 + !byte $0E,%10000000 + !byte $0C,%10100000 + !byte $0A,%00000001 + !byte $08,%01000001 + !byte $06,%01100001 + !byte $06,%10000001 + !byte $04,%10100001 + !byte $02,%00000010 + !byte $00,%01000010 + !byte $10,%00100000 + !byte $0E,%01000000 + !byte $0E,%01100000 + !byte $0C,%10000000 + !byte $0A,%10100000 + !byte $0A,%11000000 + !byte $08,%00000001 + !byte $08,%00100001 + !byte $06,%01000001 + !byte $04,%10000001 + !byte $02,%11000001 + !byte $00,%00100010 + !byte $10,%00000000 + !byte $0E,%00100000 + !byte $0C,%01100000 + !byte $0A,%10000000 + !byte $08,%11000000 + !byte $06,%00100001 + !byte $04,%01100001 + !byte $02,%10000001 + !byte $02,%10100001 + !byte $00,%11000001 + !byte $00,%00000010 + !byte $0E,%00000000 + !byte $0C,%00100000 + !byte $0C,%01000000 + !byte $0A,%01100000 + !byte $08,%10100000 + !byte $06,%11000000 + !byte $06,%00000001 + !byte $04,%00100001 + !byte $04,%01000001 + !byte $02,%01100001 + !byte $00,%10100001 + !byte $0C,%00000000 + !byte $0A,%01000000 + !byte $08,%10000000 + !byte $06,%10100000 + !byte $04,%00000001 + !byte $02,%01000001 + !byte $00,%10000001 + !byte $0A,%00100000 + !byte $08,%01000000 + !byte $08,%01100000 + !byte $06,%10000000 + !byte $04,%11000000 + !byte $02,%00100001 + !byte $00,%01000001 + !byte $00,%01100001 + !byte $0A,%00000000 + !byte $08,%00100000 + !byte $06,%01100000 + !byte $04,%10000000 + !byte $04,%10100000 + !byte $02,%11000000 + !byte $02,%00000001 + !byte $00,%00100001 + !byte $08,%00000000 + !byte $06,%01000000 + !byte $04,%01100000 + !byte $02,%10100000 + !byte $00,%00000001 + !byte $06,%00000000 + !byte $06,%00100000 + !byte $04,%01000000 + !byte $02,%10000000 + !byte $00,%11000000 + !byte $04,%00100000 + !byte $02,%01000000 + !byte $02,%01100000 + !byte $00,%10000000 + !byte $00,%10100000 + !byte $04,%00000000 + !byte $02,%00100000 + !byte $00,%01100000 + !byte $02,%00000000 + !byte $00,%01000000 + !byte $00,%00100000 + !byte $00,%00000000 + !byte $80 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + +FX_RIPPLE_1BIT aslmod2 + rts diff --git a/src/fx/fx.hgr.iris.in.a b/src/fx/fx.hgr.iris.in.a new file mode 100644 index 0000000..9fdc47b --- /dev/null +++ b/src/fx/fx.hgr.iris.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/IRIS.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + + +FX_INITONCE_1BIT CoordinatesFile, Start + +FX_REVERSE_1BIT +Start + +FX_PRECOMPUTED_1BIT Coordinates1Bit + +CoordinatesFile + !byte 12 + !text "FX/IRIS.DATA" diff --git a/src/fx/fx.hgr.lattice.a b/src/fx/fx.hgr.lattice.a new file mode 100644 index 0000000..632c7dd --- /dev/null +++ b/src/fx/fx.hgr.lattice.a @@ -0,0 +1,221 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/LATTICE",plain +*=$6000 + +maskindex = $fc +rowcount = $fd +row = $fe +col = $ff + + !source "src/fx/macros.a" + !source "src/constants.a" + + lda #5 + sta maskindex +MaskLoop + ldx maskindex + lda even_maskslo,x + sta EvenMask + lda even_maskshi,x + sta EvenMask+1 + lda odd_maskslo,x + sta OddMask + lda odd_maskshi,x + sta OddMask+1 + lda #0 + sta row + lda #23 + sta rowcount + jsr WaitForVBL +RowLoop + lda row + +HGR_ROW_CALC + lda #39 + sta col +ColLoop + ldy col + tya + eor row + and #1 + bne Odd + clc + ldx #7 +- lda ($3c),y + eor ($26),y +EvenMask=*+1 + and $FDFD,x + eor ($26),y + sta ($26),y + +HGR_INC_WITHIN_BLOCK + dex + bpl - + bmi NextCol +Odd + clc + ldx #7 +- lda ($3c),y + eor ($26),y +OddMask=*+1 + and $FDFD,x + eor ($26),y + sta ($26),y + +HGR_INC_WITHIN_BLOCK + dex + bpl - +NextCol + +RESET_HGR_CALC + dec col + +LBPL ColLoop + inc row + dec rowcount + +LBPL RowLoop + bit $c000 + bmi Exit + dec maskindex + +LBPL MaskLoop +Exit jmp UnwaitForVBL + +even_maskslo + !byte copymask_even6 + !byte >copymask_even5 + !byte >copymask_even4 + !byte >copymask_even3 + !byte >copymask_even2 + !byte >copymask_even1 + +odd_maskslo + !byte copymask_odd6 + !byte >copymask_odd5 + !byte >copymask_odd4 + !byte >copymask_odd3 + !byte >copymask_odd2 + !byte >copymask_odd1 + +copymask_even1 + !byte %11100000 + !byte %10110000 + !byte %10011000 + !byte %10011000 + !byte %10001100 + !byte %10000110 + !byte %10000011 + !byte %10000001 +copymask_odd1 + !byte %10000001 + !byte %10000011 + !byte %10000110 + !byte %10001100 + !byte %10011000 + !byte %10011000 + !byte %10110000 + !byte %11100000 +copymask_even2 + !byte %11110000 + !byte %10111000 + !byte %10011100 + !byte %10011100 + !byte %10001110 + !byte %10000111 + !byte %11000011 + !byte %11100001 +copymask_odd2 + !byte %11100001 + !byte %11000011 + !byte %10000111 + !byte %10001110 + !byte %10011100 + !byte %10011100 + !byte %10111000 + !byte %11110000 +copymask_even3 + !byte %11110001 + !byte %11111000 + !byte %10111100 + !byte %10111100 + !byte %10011110 + !byte %10001111 + !byte %11000111 + !byte %11100011 +copymask_odd3 + !byte %11100011 + !byte %11000111 + !byte %10001111 + !byte %10011110 + !byte %10111100 + !byte %10111100 + !byte %11111000 + !byte %11110001 +copymask_even4 + !byte %11111001 + !byte %11111100 + !byte %10111110 + !byte %10111110 + !byte %10011111 + !byte %11001111 + !byte %11100111 + !byte %11110011 +copymask_odd4 + !byte %11110011 + !byte %11100111 + !byte %11001111 + !byte %10011111 + !byte %10111110 + !byte %10111110 + !byte %11111100 + !byte %11111001 +copymask_even5 + !byte %11111011 + !byte %11111101 + !byte %11111110 + !byte %11111110 + !byte %10111111 + !byte %11011111 + !byte %11101111 + !byte %11110111 +copymask_odd5 + !byte %11110111 + !byte %11101111 + !byte %11011111 + !byte %10111111 + !byte %11111110 + !byte %11111110 + !byte %11111101 + !byte %11111011 +copymask_even6 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 +copymask_odd6 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" diff --git a/src/fx/fx.hgr.lr.by.pixel.a b/src/fx/fx.hgr.lr.by.pixel.a new file mode 100644 index 0000000..6d65bf1 --- /dev/null +++ b/src/fx/fx.hgr.lr.by.pixel.a @@ -0,0 +1,115 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/LR.BY.PIXEL",plain +*=$6000 + +maskindex = $fd +row = $fe +col = $ff + + !source "src/constants.a" + +@jump + jmp @copy ; skip clear the first time + + ;clear + lda #$27 + sta col +@clearcolloop + lda #$06 + sta maskindex + jsr WaitForVBL +@clearmaskloop + ldx maskindex + lda clearmasks,x + sta @clearmask + lda #$17 + sta row +@clearrowloop + lda row + asl + asl + asl + jsr HGRCalc + clc + ldx #$08 + ldy col +@clearblockloop + lda ($26),y +@clearmask=*+1 + and #$FD ; SMC + sta ($26),y + lda $27 + adc #4 + sta $27 + dex + bne @clearblockloop + dec row + bpl @clearrowloop + lda #8 + jsr WaitForKeyWithTimeout + bmi @exit + dec maskindex + bpl @clearmaskloop + dec col + bpl @clearcolloop + +@copy + lda #$2C ; BIT opcode + sta @jump ; don't skip clear after first time + + ; copy + lda #$00 + sta col +@colloop + lda #$06 + sta maskindex + jsr WaitForVBL +@maskloop + ldx maskindex + lda copymasks,x + sta @mask + lda #$17 + sta row +@rowloop + lda row + asl + asl + asl + jsr HGRCalc + clc + ldx #$08 + ldy col +@blockloop + lda ($3c),y +@mask=*+1 + and #$FD ; SMC + sta ($26),y + lda $27 + adc #4 + sta $27 + eor #$60 + sta $3d + dex + bne @blockloop + dec row + bpl @rowloop + lda #8 + jsr WaitForKeyWithTimeout + bmi @exit + dec maskindex + bpl @maskloop + inc col + lda col + cmp #40 + bne @colloop +@exit jmp UnwaitForVBL +clearmasks + !byte $80,$81,$83,$87,$8F,$9F,$BF +copymasks + !byte $FF,$BF,$9F,$8F,$87,$83,$81 + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.mandelbrot.a b/src/fx/fx.hgr.mandelbrot.a new file mode 100644 index 0000000..3e5a89e --- /dev/null +++ b/src/fx/fx.hgr.mandelbrot.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MANDELBROT",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/MANDELBROT.DATA" diff --git a/src/fx/fx.hgr.mandelbrot.data.a b/src/fx/fx.hgr.mandelbrot.data.a new file mode 100644 index 0000000..8b776bc --- /dev/null +++ b/src/fx/fx.hgr.mandelbrot.data.a @@ -0,0 +1,10243 @@ +!cpu 6502 +!to "build/FX/MANDELBROT.DATA",plain +*=$6B00 + !byte $1F,%00010100 + !byte $20,%00010100 + !byte $20,%00110100 + !byte $1F,%00110100 + !byte $1F,%10110011 + !byte $20,%11110011 + !byte $1F,%11110011 + !byte $20,%01010100 + !byte $1F,%01010100 + !byte $1E,%00010100 + !byte $1E,%00110100 + !byte $1E,%01010100 + !byte $20,%01110100 + !byte $20,%10010101; + !byte $1F,%01110100 + !byte $1F,%10010101; + !byte $1E,%01110100 + !byte $1E,%10010101; + !byte $1F,%01010010 + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $1F,%11010011 + !byte $1E,%11110011 + !byte $21,%00010100 + !byte $21,%00110100 + !byte $21,%01010100 + !byte $21,%01110100 + !byte $21,%10010101; + !byte $20,%10110101 + !byte $1E,%10110101 + !byte $1D,%00110100 + !byte $1D,%01010100 + !byte $1C,%01010100 + !byte $1D,%01110100 + !byte $1D,%10010101; + !byte $21,%10110101 + !byte $1F,%10110101 + !byte $20,%11010101 + !byte $1E,%11010101 + !byte $20,%00110010 + !byte $1F,%00110010 + !byte $20,%01010010 + !byte $20,%01110010 + !byte $20,%10010011; + !byte $20,%11010011 + !byte $1E,%11010011 + !byte $21,%11110011 + !byte $1D,%00010100 + !byte $22,%00110100 + !byte $23,%01010100 + !byte $22,%01010100 + !byte $22,%01110100 + !byte $22,%10010101; + !byte $1D,%10110101 + !byte $21,%11010101 + !byte $1F,%11010101 + !byte $1D,%11010101 + !byte $20,%00010010 + !byte $1F,%00010010 + !byte $21,%11010011 + !byte $1D,%11110011 + !byte $22,%00010100 + !byte $22,%10110101 + !byte $22,%11010101 + !byte $21,%11110101 + !byte $20,%11110101 + !byte $1F,%11110101 + !byte $1E,%11110101 + !byte $1D,%11110101 + !byte $20,%11110001 + !byte $1F,%11110001 + !byte $1E,%00010010 + !byte $1E,%00110010 + !byte $20,%10110011 + !byte $1E,%10110011 + !byte $1D,%11010011 + !byte $22,%11110011 + !byte $1C,%11110011 + !byte $1C,%00010100 + !byte $1C,%00110100 + !byte $1C,%01110100 + !byte $1C,%10010101; + !byte $1C,%10110101 + !byte $1C,%11010101 + !byte $22,%11110101 + !byte $21,%00010110 + !byte $20,%00010110 + !byte $1E,%00010110 + !byte $1D,%00010110 + !byte $20,%11010001 + !byte $1F,%11010001 + !byte $1E,%11110001 + !byte $23,%00110100 + !byte $24,%01110100 + !byte $24,%10010101; + !byte $23,%01110100 + !byte $23,%10010101; + !byte $1B,%01110100 + !byte $1B,%10010101; + !byte $1A,%01110100 + !byte $1A,%10010101; + !byte $23,%10110101 + !byte $23,%11010101 + !byte $1C,%11110101 + !byte $22,%00010110 + !byte $1F,%00010110 + !byte $1C,%00010110 + !byte $21,%00110110 + !byte $20,%00110110 + !byte $1E,%00110110 + !byte $1D,%00110110 + !byte $20,%10110001 + !byte $1F,%10110001 + !byte $1E,%11010001 + !byte $1E,%01110010 + !byte $1E,%10010011; + !byte $21,%10110011 + !byte $1D,%10110011 + !byte $22,%11010011 + !byte $1C,%11010011 + !byte $23,%00010100 + !byte $1B,%00110100 + !byte $1B,%01010100 + !byte $1B,%10110101 + !byte $1B,%11010101 + !byte $23,%11110101 + !byte $1B,%11110101 + !byte $22,%00110110 + !byte $21,%01010110 + !byte $1E,%01010110 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $1E,%10110001 + !byte $21,%11110001 + !byte $22,%10110011 + !byte $23,%11110011 + !byte $1B,%00010100 + !byte $24,%01010100 + !byte $25,%01110100 + !byte $25,%10010101; + !byte $25,%10110101 + !byte $24,%10110101 + !byte $19,%10110101 + !byte $24,%11010101 + !byte $24,%11110101 + !byte $23,%00010110 + !byte $1B,%00010110 + !byte $23,%00110110 + !byte $1F,%00110110 + !byte $1C,%00110110 + !byte $22,%01010110 + !byte $20,%01010110 + !byte $1D,%01010110 + !byte $1C,%01010110 + !byte $21,%01110110 + !byte $21,%10010111; + !byte $1E,%01110110 + !byte $1E,%10010111; + !byte $1D,%01110110 + !byte $1D,%10010111; + !byte $20,%01010000 + !byte $1F,%01010000 + !byte $20,%01110000 + !byte $20,%10010001; + !byte $1E,%01110000 + !byte $1E,%10010001; + !byte $21,%10110001 + !byte $21,%11010001 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $1C,%10110011 + !byte $23,%11010011 + !byte $1B,%11110011 + !byte $24,%00010100 + !byte $24,%00110100 + !byte $26,%01110100 + !byte $26,%10010101; + !byte $19,%01110100 + !byte $19,%10010101; + !byte $26,%10110101 + !byte $24,%00010110 + !byte $1B,%00110110 + !byte $23,%01010110 + !byte $1F,%01010110 + !byte $22,%01110110 + !byte $22,%10010111; + !byte $20,%01110110 + !byte $20,%10010111; + !byte $1C,%01110110 + !byte $1C,%10010111; + !byte $1E,%01010000 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $22,%01110010 + !byte $22,%10010011; + !byte $23,%10110011 + !byte $24,%11110011 + !byte $1A,%00110100 + !byte $1A,%01010100 + !byte $1A,%10110101 + !byte $26,%11010101 + !byte $1A,%11010101 + !byte $19,%11010101 + !byte $1A,%11110101 + !byte $1A,%00010110 + !byte $24,%00110110 + !byte $24,%01010110 + !byte $1B,%01010110 + !byte $23,%01110110 + !byte $23,%10010111; + !byte $1F,%01110110 + !byte $1F,%10010111; + !byte $1B,%01110110 + !byte $1B,%10010111; + !byte $22,%10110111 + !byte $21,%10110111 + !byte $20,%10110111 + !byte $1E,%10110111 + !byte $1D,%10110111 + !byte $1C,%10110111 + !byte $1F,%11101111 + !byte $1F,%00010000 + !byte $20,%00110000 + !byte $1F,%00110000 + !byte $1E,%00110000 + !byte $21,%01010000 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $1D,%10110001 + !byte $21,%01010010 + !byte $1E,%01010010 + !byte $1D,%01010010 + !byte $1C,%01110010 + !byte $1C,%10010011; + !byte $1B,%11010011 + !byte $1A,%00010100 + !byte $25,%01010100 + !byte $27,%10110101 + !byte $18,%10110101 + !byte $25,%11010101 + !byte $18,%11010101 + !byte $25,%11110101 + !byte $25,%00010110 + !byte $1A,%00110110 + !byte $1A,%01010110 + !byte $24,%01110110 + !byte $24,%10010111; + !byte $23,%10110111 + !byte $1B,%10110111 + !byte $1A,%10110111 + !byte $22,%11010111 + !byte $21,%11010111 + !byte $1E,%11010111 + !byte $1D,%11010111 + !byte $1C,%11010111 + !byte $1F,%11001111 + !byte $20,%00010000 + !byte $1E,%00010000 + !byte $21,%00110000 + !byte $1D,%01010000 + !byte $1B,%10110011 + !byte $25,%11010011 + !byte $24,%11010011 + !byte $1A,%11110011 + !byte $25,%00110100 + !byte $19,%01010100 + !byte $17,%10110101 + !byte $27,%11010101 + !byte $17,%11010101 + !byte $27,%11110101 + !byte $19,%11110101 + !byte $19,%00010110 + !byte $25,%00110110 + !byte $25,%01010110 + !byte $1A,%01110110 + !byte $1A,%10010111; + !byte $24,%10110111 + !byte $1F,%10110111 + !byte $23,%11010111 + !byte $20,%11010111 + !byte $1B,%11010111 + !byte $22,%11110111 + !byte $21,%11110111 + !byte $1E,%11110111 + !byte $1D,%11110111 + !byte $1C,%11110111 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $1F,%10101111 + !byte $20,%11101111 + !byte $1E,%11101111 + !byte $21,%00010000 + !byte $1D,%00110000 + !byte $21,%00110010 + !byte $22,%01010010 + !byte $1C,%01010010 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $24,%10110011 + !byte $1A,%11010011 + !byte $19,%11010011 + !byte $25,%00010100 + !byte $19,%00010100 + !byte $19,%00110100 + !byte $28,%11010101 + !byte $17,%11110101 + !byte $19,%00110110 + !byte $19,%01010110 + !byte $25,%01110110 + !byte $25,%10010111; + !byte $24,%11010111 + !byte $25,%11110111 + !byte $23,%11110111 + !byte $20,%11110111 + !byte $1B,%11110111 + !byte $20,%11001111 + !byte $21,%11101111 + !byte $1D,%00010000 + !byte $1D,%00110010 + !byte $23,%01010010 + !byte $24,%01110010 + !byte $24,%10010011; + !byte $26,%11010011 + !byte $25,%11110011 + !byte $26,%00110100 + !byte $26,%01010100 + !byte $28,%10110101 + !byte $16,%11010101 + !byte $28,%11110101 + !byte $26,%11110101 + !byte $16,%11110101 + !byte $26,%00010110 + !byte $26,%00110110 + !byte $26,%01010110 + !byte $26,%01110110 + !byte $26,%10010111; + !byte $19,%01110110 + !byte $19,%10010111; + !byte $25,%10110111 + !byte $19,%10110111 + !byte $25,%11010111 + !byte $1F,%11010111 + !byte $1A,%11010111 + !byte $24,%11110111 + !byte $1A,%11110111 + !byte $23,%00011000 + !byte $22,%00011000 + !byte $21,%00011000 + !byte $1E,%00011000 + !byte $1D,%00011000 + !byte $1C,%00011000 + !byte $1B,%00011000 + !byte $1F,%01001110 + !byte $20,%10101111 + !byte $1E,%10101111 + !byte $21,%11001111 + !byte $1E,%11001111 + !byte $1D,%11101111 + !byte $22,%00010000 + !byte $22,%00110000 + !byte $22,%01010000 + !byte $22,%00110010 + !byte $1B,%01010010 + !byte $25,%10110011 + !byte $1A,%10110011 + !byte $19,%11110011 + !byte $26,%00010100 + !byte $18,%01010100 + !byte $18,%01110100 + !byte $18,%10010101; + !byte $16,%10110101 + !byte $29,%11010101 + !byte $29,%11110101 + !byte $18,%11110101 + !byte $28,%00010110 + !byte $18,%00010110 + !byte $16,%00010110 + !byte $18,%00110110 + !byte $18,%01010110 + !byte $26,%10110111 + !byte $19,%11010111 + !byte $1F,%11110111 + !byte $26,%00011000 + !byte $24,%00011000 + !byte $20,%00011000 + !byte $19,%00011000 + !byte $23,%00111000 + !byte $22,%00111000 + !byte $21,%00111000 + !byte $1E,%00111000 + !byte $1D,%00111000 + !byte $1C,%00111000 + !byte $1F,%00101110 + !byte $20,%01101110 + !byte $20,%10001111; + !byte $21,%10101111 + !byte $1D,%11001111 + !byte $22,%11101111 + !byte $21,%00010010 + !byte $1C,%00110010 + !byte $18,%11010011 + !byte $26,%11110011 + !byte $18,%00110100 + !byte $27,%01110100 + !byte $27,%10010101; + !byte $15,%11110101 + !byte $29,%00010110 + !byte $27,%00010110 + !byte $27,%00110110 + !byte $27,%01010110 + !byte $18,%01110110 + !byte $18,%10010111; + !byte $18,%10110111 + !byte $26,%11010111 + !byte $26,%11110111 + !byte $19,%11110111 + !byte $25,%00011000 + !byte $1F,%00011000 + !byte $1A,%00011000 + !byte $26,%00111000 + !byte $24,%00111000 + !byte $20,%00111000 + !byte $1B,%00111000 + !byte $1A,%00111000 + !byte $23,%01011000 + !byte $22,%01011000 + !byte $21,%01011000 + !byte $1E,%01011000 + !byte $1D,%01011000 + !byte $1C,%01011000 + !byte $1B,%01111000 + !byte $1B,%10011001; + !byte $1F,%11101101 + !byte $1F,%00001110 + !byte $20,%01001110 + !byte $1E,%01001110 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $1E,%01101110 + !byte $1E,%10001111; + !byte $1D,%10101111 + !byte $1C,%10101111 + !byte $22,%11001111 + !byte $22,%00010010 + !byte $1D,%00010010 + !byte $23,%00110010 + !byte $1B,%00110010 + !byte $24,%01010010 + !byte $1A,%01010010 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $1A,%01110010 + !byte $1A,%10010011; + !byte $19,%10110011 + !byte $18,%11110011 + !byte $18,%00010100 + !byte $27,%00110100 + !byte $27,%01010100 + !byte $17,%01110100 + !byte $17,%10010101; + !byte $15,%11010101 + !byte $2A,%11110101 + !byte $17,%00010110 + !byte $15,%00010110 + !byte $17,%00110110 + !byte $17,%01010110 + !byte $27,%01110110 + !byte $27,%10010111; + !byte $27,%10110111 + !byte $18,%11010111 + !byte $18,%11110111 + !byte $25,%00111000 + !byte $18,%00111000 + !byte $24,%01011000 + !byte $20,%01011000 + !byte $1B,%01011000 + !byte $1A,%01011000 + !byte $18,%01011000 + !byte $23,%01111000 + !byte $23,%10011001; + !byte $22,%01111000 + !byte $22,%10011001; + !byte $1D,%01111000 + !byte $1D,%10011001; + !byte $1C,%01111000 + !byte $1C,%10011001; + !byte $21,%01001110 + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $22,%10101111 + !byte $1C,%11101111 + !byte $1C,%00010000 + !byte $1C,%00110000 + !byte $1C,%00010010 + !byte $27,%10110011 + !byte $27,%11010011 + !byte $27,%00010100 + !byte $17,%01010100 + !byte $2A,%11010101 + !byte $14,%11110101 + !byte $2A,%00010110 + !byte $14,%00010110 + !byte $2A,%00110110 + !byte $29,%00110110 + !byte $15,%00110110 + !byte $17,%01110110 + !byte $17,%10010111; + !byte $17,%10110111 + !byte $27,%11010111 + !byte $17,%11010111 + !byte $18,%00011000 + !byte $1F,%00111000 + !byte $19,%00111000 + !byte $25,%01011000 + !byte $19,%01011000 + !byte $24,%01111000 + !byte $24,%10011001; + !byte $21,%01111000 + !byte $21,%10011001; + !byte $20,%01111000 + !byte $20,%10011001; + !byte $1E,%01111000 + !byte $1E,%10011001; + !byte $1A,%01111000 + !byte $1A,%10011001; + !byte $23,%10111001 + !byte $22,%10111001 + !byte $1D,%10111001 + !byte $1C,%10111001 + !byte $1F,%10101101 + !byte $1F,%11001101 + !byte $20,%00001110 + !byte $21,%00101110 + !byte $20,%00101110 + !byte $1E,%00101110 + !byte $1D,%01001110 + !byte $22,%01101110 + !byte $22,%10001111; + !byte $1C,%11001111 + !byte $1D,%11110001 + !byte $23,%00010010 + !byte $1B,%00010010 + !byte $24,%00110010 + !byte $1A,%00110010 + !byte $19,%00110010 + !byte $25,%01010010 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $26,%10110011 + !byte $17,%10110011 + !byte $27,%11110011 + !byte $17,%00010100 + !byte $17,%00110100 + !byte $28,%01110100 + !byte $28,%10010101; + !byte $14,%11010101 + !byte $2B,%11110101 + !byte $2B,%00010110 + !byte $28,%00110110 + !byte $14,%00110110 + !byte $28,%01010110 + !byte $28,%01110110 + !byte $28,%10010111; + !byte $27,%11110111 + !byte $17,%11110111 + !byte $27,%00011000 + !byte $26,%01011000 + !byte $27,%01111000 + !byte $27,%10011001; + !byte $25,%01111000 + !byte $25,%10011001; + !byte $19,%01111000 + !byte $19,%10011001; + !byte $24,%10111001 + !byte $21,%10111001 + !byte $1B,%10111001 + !byte $1A,%10111001 + !byte $24,%11011001 + !byte $21,%00001110 + !byte $1E,%00001110 + !byte $1D,%00101110 + !byte $23,%01001110 + !byte $22,%01001110 + !byte $1C,%01001110 + !byte $22,%11110001 + !byte $26,%01110010 + !byte $26,%10010011; + !byte $28,%10110011 + !byte $18,%10110011 + !byte $28,%00110100 + !byte $28,%01010100 + !byte $16,%01110100 + !byte $16,%10010101; + !byte $13,%11110101 + !byte $13,%00010110 + !byte $2B,%00110110 + !byte $16,%00110110 + !byte $13,%00110110 + !byte $2B,%01010110 + !byte $2A,%01010110 + !byte $16,%01010110 + !byte $14,%01010110 + !byte $16,%01110110 + !byte $16,%10010111; + !byte $28,%10110111 + !byte $28,%11010111 + !byte $28,%11110111 + !byte $17,%00011000 + !byte $27,%00111000 + !byte $27,%01011000 + !byte $1F,%01011000 + !byte $26,%01111000 + !byte $26,%10011001; + !byte $1F,%01111000 + !byte $1F,%10011001; + !byte $27,%10111001 + !byte $25,%10111001 + !byte $20,%10111001 + !byte $1E,%10111001 + !byte $19,%10111001 + !byte $17,%10111001 + !byte $23,%11011001 + !byte $22,%11011001 + !byte $21,%11011001 + !byte $1E,%11011001 + !byte $1D,%11011001 + !byte $1C,%11011001 + !byte $1B,%11011001 + !byte $1A,%11011001 + !byte $1F,%01001100 + !byte $20,%01101100 + !byte $20,%10001101; + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $21,%11101101 + !byte $20,%11101101 + !byte $1E,%11101101 + !byte $22,%00001110 + !byte $1D,%00001110 + !byte $23,%00101110 + !byte $22,%00101110 + !byte $1C,%01101110 + !byte $1C,%10001111; + !byte $23,%10101111 + !byte $23,%11001111 + !byte $1D,%11010001 + !byte $23,%11110001 + !byte $1C,%11110001 + !byte $24,%00010010 + !byte $25,%00110010 + !byte $26,%01010010 + !byte $19,%01010010 + !byte $18,%01110010 + !byte $18,%10010011; + !byte $17,%11010011 + !byte $28,%11110011 + !byte $17,%11110011 + !byte $28,%00010100 + !byte $16,%00110100 + !byte $16,%01010100 + !byte $29,%01110100 + !byte $29,%10010101; + !byte $29,%10110101 + !byte $2B,%11010101 + !byte $2C,%11110101 + !byte $2C,%00010110 + !byte $2C,%00110110 + !byte $29,%01010110 + !byte $13,%01010110 + !byte $29,%01110110 + !byte $29,%10010111; + !byte $29,%10110111 + !byte $16,%10110111 + !byte $16,%11010111 + !byte $28,%00011000 + !byte $28,%00111000 + !byte $17,%00111000 + !byte $18,%01111000 + !byte $18,%10011001; + !byte $28,%10111001 + !byte $26,%10111001 + !byte $25,%11011001 + !byte $19,%11011001 + !byte $17,%11011001 + !byte $24,%11111001 + !byte $23,%11111001 + !byte $22,%11111001 + !byte $1D,%11111001 + !byte $1C,%11111001 + !byte $1B,%11111001 + !byte $1A,%00011010 + !byte $20,%01001100 + !byte $21,%11001101 + !byte $20,%11001101 + !byte $1E,%11001101 + !byte $1D,%11101101 + !byte $1C,%00101110 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $23,%11101111 + !byte $1B,%11110001 + !byte $1A,%00010010 + !byte $16,%10110011 + !byte $16,%00010100 + !byte $29,%01010100 + !byte $12,%00010110 + !byte $2D,%00110110 + !byte $12,%00110110 + !byte $2C,%01010110 + !byte $13,%01110110 + !byte $13,%10010111; + !byte $29,%11010111 + !byte $29,%11110111 + !byte $16,%11110111 + !byte $16,%00011000 + !byte $28,%01011000 + !byte $17,%01011000 + !byte $17,%01111000 + !byte $17,%10011001; + !byte $1F,%10111001 + !byte $18,%10111001 + !byte $28,%11011001 + !byte $26,%11011001 + !byte $20,%11011001 + !byte $18,%11011001 + !byte $28,%11111001 + !byte $25,%11111001 + !byte $21,%11111001 + !byte $1E,%11111001 + !byte $1A,%11111001 + !byte $19,%11111001 + !byte $24,%00011010 + !byte $23,%00011010 + !byte $22,%00011010 + !byte $1D,%00011010 + !byte $1C,%00011010 + !byte $1B,%00011010 + !byte $1A,%00111010 + !byte $1F,%00001100 + !byte $1F,%00101100 + !byte $21,%10101101 + !byte $20,%10101101 + !byte $1E,%10101101 + !byte $1D,%11001101 + !byte $22,%11101101 + !byte $1C,%11101101 + !byte $1B,%11101101 + !byte $1C,%00001110 + !byte $23,%11010001 + !byte $22,%11010001 + !byte $1C,%11010001 + !byte $24,%11110001 + !byte $25,%00010010 + !byte $19,%00010010 + !byte $18,%00010010 + !byte $26,%00110010 + !byte $18,%01010010 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $17,%01110010 + !byte $17,%10010011; + !byte $29,%10110011 + !byte $28,%11010011 + !byte $16,%11110011 + !byte $29,%00110100 + !byte $15,%01010100 + !byte $15,%01110100 + !byte $15,%10010101; + !byte $15,%10110101 + !byte $12,%11110101 + !byte $2D,%00010110 + !byte $11,%00110110 + !byte $15,%01010110 + !byte $12,%01010110 + !byte $2C,%01110110 + !byte $2C,%10010111; + !byte $15,%01110110 + !byte $15,%10010111; + !byte $12,%01110110 + !byte $12,%10010111; + !byte $15,%10110111 + !byte $15,%11010111 + !byte $15,%11110111 + !byte $29,%00011000 + !byte $16,%00111000 + !byte $16,%01011000 + !byte $28,%01111000 + !byte $28,%10011001; + !byte $27,%11011001 + !byte $16,%11011001 + !byte $26,%11111001 + !byte $20,%11111001 + !byte $18,%11111001 + !byte $16,%11111001 + !byte $25,%00011010 + !byte $21,%00011010 + !byte $19,%00011010 + !byte $1C,%00111010 + !byte $1B,%00111010 + !byte $1E,%01101100 + !byte $1E,%10001101; + !byte $1D,%10101101 + !byte $22,%11001101 + !byte $23,%11101101 + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $1B,%10101111 + !byte $1A,%11110001 + !byte $18,%00110010 + !byte $29,%01110010 + !byte $29,%10010011; + !byte $15,%10110011 + !byte $16,%11010011 + !byte $29,%00010100 + !byte $15,%00110100 + !byte $2A,%10110101 + !byte $2D,%11110101 + !byte $11,%00010110 + !byte $2D,%01010110 + !byte $11,%01010110 + !byte $2D,%01110110 + !byte $2D,%10010111; + !byte $2A,%01110110 + !byte $2A,%10010111; + !byte $11,%01110110 + !byte $11,%10010111; + !byte $2A,%10110111 + !byte $2A,%11010111 + !byte $15,%00011000 + !byte $29,%00111000 + !byte $15,%00111000 + !byte $29,%01011000 + !byte $16,%01111000 + !byte $16,%10011001; + !byte $16,%10111001 + !byte $1F,%11011001 + !byte $27,%11111001 + !byte $28,%00011010 + !byte $26,%00011010 + !byte $20,%00011010 + !byte $1E,%00011010 + !byte $18,%00011010 + !byte $16,%00011010 + !byte $25,%00111010 + !byte $24,%00111010 + !byte $23,%00111010 + !byte $22,%00111010 + !byte $21,%00111010 + !byte $1D,%00111010 + !byte $19,%00111010 + !byte $23,%01011010 + !byte $1C,%01011010 + !byte $1B,%01011010 + !byte $1F,%11001011 + !byte $20,%11101011 + !byte $1F,%11101011 + !byte $20,%00001100 + !byte $1E,%01001100 + !byte $21,%01101100 + !byte $21,%10001101; + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $22,%10101101 + !byte $23,%11001101 + !byte $1C,%11001101 + !byte $1B,%11001101 + !byte $23,%00001110 + !byte $24,%01001110 + !byte $1B,%01001110 + !byte $23,%10110001 + !byte $22,%10110001 + !byte $1C,%10110001 + !byte $24,%11010001 + !byte $1B,%11010001 + !byte $25,%11110001 + !byte $27,%00010010 + !byte $26,%00010010 + !byte $27,%01010010 + !byte $17,%01010010 + !byte $2A,%01110010 + !byte $2A,%10010011; + !byte $28,%01110010 + !byte $28,%10010011; + !byte $15,%01110010 + !byte $15,%10010011; + !byte $29,%11010011 + !byte $29,%11110011 + !byte $15,%00010100 + !byte $2A,%00110100 + !byte $14,%00110100 + !byte $2A,%01010100 + !byte $2A,%01110100 + !byte $2A,%10010101; + !byte $11,%11110101 + !byte $2E,%00010110 + !byte $2E,%00110110 + !byte $2F,%01010110 + !byte $2E,%01010110 + !byte $2E,%01110110 + !byte $2E,%10010111; + !byte $14,%01110110 + !byte $14,%10010111; + !byte $14,%10110111 + !byte $14,%11010111 + !byte $2A,%11110111 + !byte $2A,%00011000 + !byte $2A,%00111000 + !byte $15,%01011000 + !byte $29,%01111000 + !byte $29,%10011001; + !byte $29,%10111001 + !byte $29,%11111001 + !byte $1F,%11111001 + !byte $17,%11111001 + !byte $29,%00011010 + !byte $27,%00011010 + !byte $29,%00111010 + !byte $26,%00111010 + !byte $1E,%00111010 + !byte $18,%00111010 + !byte $25,%01011010 + !byte $24,%01011010 + !byte $22,%01011010 + !byte $1D,%01011010 + !byte $1A,%01011010 + !byte $19,%01111010 + !byte $19,%10011011; + !byte $20,%11001011 + !byte $20,%00101100 + !byte $21,%01001100 + !byte $1D,%01001100 + !byte $22,%01101100 + !byte $22,%10001101; + !byte $24,%10101101 + !byte $1C,%10101101 + !byte $1B,%10101101 + !byte $1B,%00001110 + !byte $1B,%00101110 + !byte $27,%00110010 + !byte $28,%01010010 + !byte $2A,%10110011 + !byte $15,%11110011 + !byte $2A,%00010100 + !byte $14,%01110100 + !byte $14,%10010101; + !byte $14,%10110101 + !byte $10,%00110110 + !byte $10,%01010110 + !byte $2B,%01110110 + !byte $2B,%10010111; + !byte $10,%01110110 + !byte $10,%10010111; + !byte $2E,%10110111 + !byte $2D,%10110111 + !byte $2B,%10110111 + !byte $12,%10110111 + !byte $11,%10110111 + !byte $2B,%11010111 + !byte $2B,%11110111 + !byte $14,%11110111 + !byte $14,%00011000 + !byte $14,%00111000 + !byte $2A,%01011000 + !byte $2A,%01111000 + !byte $2A,%10011001; + !byte $15,%01111000 + !byte $15,%10011001; + !byte $15,%10111001 + !byte $29,%11011001 + !byte $1F,%00011010 + !byte $17,%00011010 + !byte $27,%00111010 + !byte $20,%00111010 + !byte $17,%00111010 + !byte $15,%00111010 + !byte $26,%01011010 + !byte $21,%01011010 + !byte $1E,%01011010 + !byte $19,%01011010 + !byte $18,%01011010 + !byte $15,%01011010 + !byte $25,%01111010 + !byte $25,%10011011; + !byte $24,%01111010 + !byte $24,%10011011; + !byte $23,%01111010 + !byte $23,%10011011; + !byte $22,%01111010 + !byte $22,%10011011; + !byte $1D,%01111010 + !byte $1D,%10011011; + !byte $1C,%01111010 + !byte $1C,%10011011; + !byte $1B,%01111010 + !byte $1B,%10011011; + !byte $1A,%01111010 + !byte $1A,%10011011; + !byte $19,%10111011 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $20,%10101011 + !byte $1F,%10101011 + !byte $1E,%00001100 + !byte $22,%00101100 + !byte $21,%00101100 + !byte $1E,%00101100 + !byte $1D,%00101100 + !byte $22,%01001100 + !byte $1C,%01001100 + !byte $24,%01101100 + !byte $24,%10001101; + !byte $1C,%01101100 + !byte $1C,%10001101; + !byte $23,%10101101 + !byte $22,%01110000 + !byte $22,%10010001; + !byte $24,%10110001 + !byte $1B,%10110001 + !byte $25,%11010001 + !byte $1A,%11010001 + !byte $26,%11110001 + !byte $19,%11110001 + !byte $17,%11110001 + !byte $17,%00110010 + !byte $16,%01110010 + !byte $16,%10010011; + !byte $14,%01110010 + !byte $14,%10010011; + !byte $15,%11010011 + !byte $2A,%11110011 + !byte $14,%01010100 + !byte $2B,%01110100 + !byte $2B,%10010101; + !byte $2B,%10110101 + !byte $10,%00010110 + !byte $2F,%00110110 + !byte $30,%01010110 + !byte $2F,%01110110 + !byte $2F,%10010111; + !byte $10,%10110111 + !byte $2B,%00011000 + !byte $2B,%00111000 + !byte $14,%01011000 + !byte $2B,%01111000 + !byte $2B,%10011001; + !byte $2A,%10111001 + !byte $15,%11011001 + !byte $2A,%00111010 + !byte $28,%00111010 + !byte $2A,%01011010 + !byte $27,%01011010 + !byte $17,%01011010 + !byte $26,%01111010 + !byte $26,%10011011; + !byte $21,%01111010 + !byte $21,%10011011; + !byte $24,%10111011 + !byte $23,%10111011 + !byte $1C,%10111011 + !byte $1B,%10111011 + !byte $1A,%10111011 + !byte $19,%11011011 + !byte $20,%01101010 + !byte $20,%10001011; + !byte $21,%00001100 + !byte $1D,%00001100 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $1C,%01110000 + !byte $1C,%10010001; + !byte $19,%11010001 + !byte $18,%11110001 + !byte $17,%00010010 + !byte $16,%01010010 + !byte $14,%10110011 + !byte $14,%00010100 + !byte $2B,%01010100 + !byte $13,%01110100 + !byte $13,%10010101; + !byte $13,%10110101 + !byte $13,%11010101 + !byte $2F,%00010110 + !byte $0F,%00110110 + !byte $0F,%01010110 + !byte $0F,%01110110 + !byte $0F,%10010111; + !byte $0E,%01110110 + !byte $0E,%10010111; + !byte $2F,%10110111 + !byte $13,%10110111 + !byte $0F,%10110111 + !byte $2E,%11010111 + !byte $13,%11010111 + !byte $11,%11010111 + !byte $10,%11010111 + !byte $13,%11110111 + !byte $13,%00011000 + !byte $13,%00111000 + !byte $2B,%01011000 + !byte $14,%01111000 + !byte $14,%10011001; + !byte $14,%10111001 + !byte $13,%10111001 + !byte $2A,%11011001 + !byte $14,%11011001 + !byte $2A,%11111001 + !byte $15,%11111001 + !byte $15,%00011010 + !byte $1F,%00111010 + !byte $16,%00111010 + !byte $28,%01011010 + !byte $20,%01011010 + !byte $16,%01011010 + !byte $14,%01011010 + !byte $2A,%01111010 + !byte $2A,%10011011; + !byte $27,%01111010 + !byte $27,%10011011; + !byte $20,%01111010 + !byte $20,%10011011; + !byte $1E,%01111010 + !byte $1E,%10011011; + !byte $18,%01111010 + !byte $18,%10011011; + !byte $17,%01111010 + !byte $17,%10011011; + !byte $15,%01111010 + !byte $15,%10011011; + !byte $14,%01111010 + !byte $14,%10011011; + !byte $26,%10111011 + !byte $25,%10111011 + !byte $22,%10111011 + !byte $21,%10111011 + !byte $1D,%10111011 + !byte $18,%10111011 + !byte $25,%11011011 + !byte $24,%11011011 + !byte $23,%11011011 + !byte $1C,%11011011 + !byte $1B,%11011011 + !byte $1A,%11011011 + !byte $26,%11111011 + !byte $1F,%00101010 + !byte $20,%01001010 + !byte $1F,%01001010 + !byte $21,%11101011 + !byte $1E,%11101011 + !byte $1D,%11101011 + !byte $22,%00001100 + !byte $1C,%00001100 + !byte $24,%00101100 + !byte $1C,%00101100 + !byte $24,%01001100 + !byte $23,%01001100 + !byte $1B,%01001100 + !byte $1A,%01001100 + !byte $24,%11001101 + !byte $24,%11101101 + !byte $24,%00001110 + !byte $24,%00101110 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $25,%10110001 + !byte $1A,%10110001 + !byte $26,%11010001 + !byte $28,%11110001 + !byte $27,%11110001 + !byte $28,%00110010 + !byte $16,%00110010 + !byte $29,%01010010 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $13,%01110010 + !byte $13,%10010011; + !byte $2B,%10110011 + !byte $2A,%11010011 + !byte $14,%11110011 + !byte $2B,%00010100 + !byte $2B,%00110100 + !byte $13,%01010100 + !byte $2C,%11010101 + !byte $0F,%00010110 + !byte $30,%00110110 + !byte $31,%01110110 + !byte $31,%10010111; + !byte $30,%01110110 + !byte $30,%10010111; + !byte $2C,%10110111 + !byte $2F,%11010111 + !byte $2C,%11010111 + !byte $0F,%11010111 + !byte $2C,%11110111 + !byte $2C,%00011000 + !byte $13,%01011000 + !byte $13,%01111000 + !byte $13,%10011001; + !byte $2B,%10111001 + !byte $14,%11111001 + !byte $2A,%00011010 + !byte $28,%01111010 + !byte $28,%10011011; + !byte $16,%01111010 + !byte $16,%10011011; + !byte $2A,%10111011 + !byte $27,%10111011 + !byte $1E,%10111011 + !byte $17,%10111011 + !byte $14,%10111011 + !byte $26,%11011011 + !byte $22,%11011011 + !byte $1D,%11011011 + !byte $20,%00101010 + !byte $21,%11001011 + !byte $1E,%11001011 + !byte $1D,%11001011 + !byte $22,%11101011 + !byte $23,%00101100 + !byte $1A,%00101100 + !byte $1A,%11101101 + !byte $1A,%01001110 + !byte $24,%01110000 + !byte $24,%10010001; + !byte $19,%10110001 + !byte $18,%10110001 + !byte $16,%11110001 + !byte $13,%10110011 + !byte $14,%11010011 + !byte $13,%00010100 + !byte $13,%00110100 + !byte $2C,%01110100 + !byte $2C,%10010101; + !byte $2C,%10110101 + !byte $12,%11010101 + !byte $0E,%01010110 + !byte $0D,%01110110 + !byte $0D,%10010111; + !byte $30,%10110111 + !byte $0E,%10110111 + !byte $30,%11010111 + !byte $12,%11010111 + !byte $0E,%11010111 + !byte $2F,%11110111 + !byte $12,%11110111 + !byte $10,%11110111 + !byte $0F,%11110111 + !byte $12,%00011000 + !byte $2C,%00111000 + !byte $12,%00111000 + !byte $2C,%01011000 + !byte $2C,%11011001 + !byte $2B,%11011001 + !byte $13,%11011001 + !byte $2B,%11111001 + !byte $14,%00011010 + !byte $14,%00111010 + !byte $29,%01011010 + !byte $1F,%01011010 + !byte $29,%01111010 + !byte $29,%10011011; + !byte $2B,%10111011 + !byte $28,%10111011 + !byte $20,%10111011 + !byte $16,%10111011 + !byte $27,%11011011 + !byte $21,%11011011 + !byte $1E,%11011011 + !byte $18,%11011011 + !byte $17,%11011011 + !byte $14,%11011011 + !byte $25,%11111011 + !byte $24,%11111011 + !byte $23,%11111011 + !byte $22,%11111011 + !byte $1C,%11111011 + !byte $1B,%11111011 + !byte $1A,%11111011 + !byte $19,%11111011 + !byte $18,%11111011 + !byte $18,%00011100 + !byte $1F,%11101001 + !byte $20,%00001010 + !byte $1F,%00001010 + !byte $21,%10101011 + !byte $1E,%10101011 + !byte $1D,%10101011 + !byte $22,%11001011 + !byte $23,%11101011 + !byte $1C,%11101011 + !byte $23,%00001100 + !byte $1A,%00001100 + !byte $1B,%00101100 + !byte $25,%11001101 + !byte $23,%01010000 + !byte $1C,%01010000 + !byte $1B,%01010000 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $1A,%01110000 + !byte $1A,%10010001; + !byte $26,%10110001 + !byte $27,%11010001 + !byte $18,%11010001 + !byte $16,%11010001 + !byte $28,%00010010 + !byte $16,%00010010 + !byte $29,%00110010 + !byte $2C,%01010010 + !byte $15,%01010010 + !byte $13,%01010010 + !byte $2C,%01110010 + !byte $2C,%10010011; + !byte $2B,%11010011 + !byte $2B,%11110011 + !byte $2C,%00110100 + !byte $2C,%01010100 + !byte $12,%01110100 + !byte $12,%10010101; + !byte $12,%10110101 + !byte $30,%00010110 + !byte $31,%00110110 + !byte $0E,%00110110 + !byte $31,%01010110 + !byte $32,%01110110 + !byte $32,%10010111; + !byte $31,%10110111 + !byte $31,%11010111 + !byte $2D,%11010111 + !byte $30,%11110111 + !byte $2D,%11110111 + !byte $2D,%00011000 + !byte $12,%01011000 + !byte $2C,%01111000 + !byte $2C,%10011001; + !byte $2C,%10111001 + !byte $12,%11011001 + !byte $13,%11111001 + !byte $2B,%00011010 + !byte $2B,%00111010 + !byte $2B,%01111010 + !byte $2B,%10011011; + !byte $1F,%01111010 + !byte $1F,%10011011; + !byte $29,%10111011 + !byte $13,%10111011 + !byte $2B,%11011011 + !byte $28,%11011011 + !byte $16,%11011011 + !byte $27,%11111011 + !byte $21,%11111011 + !byte $1D,%11111011 + !byte $26,%00011100 + !byte $25,%00011100 + !byte $24,%00011100 + !byte $23,%00011100 + !byte $1C,%00011100 + !byte $1B,%00011100 + !byte $1A,%00011100 + !byte $19,%00011100 + !byte $18,%00111100 + !byte $20,%11101001 + !byte $21,%01101010 + !byte $21,%10001011; + !byte $1E,%01101010 + !byte $1E,%10001011; + !byte $22,%10101011 + !byte $1C,%11001011 + !byte $1A,%11101011 + !byte $24,%00001100 + !byte $1B,%00001100 + !byte $1A,%01101100 + !byte $1A,%10001101; + !byte $1A,%10101101 + !byte $1A,%11001101 + !byte $29,%11010001 + !byte $15,%00110010 + !byte $2A,%01010010 + !byte $2C,%10110011 + !byte $13,%11110011 + !byte $2C,%00010100 + !byte $12,%01010100 + !byte $2D,%10110101 + !byte $2D,%11010101 + !byte $0D,%01010110 + !byte $32,%10110111 + !byte $0D,%10110111 + !byte $0C,%10110111 + !byte $0D,%11010111 + !byte $31,%11110111 + !byte $0E,%11110111 + !byte $2D,%00111000 + !byte $2D,%01011000 + !byte $2D,%01111000 + !byte $2D,%10011001; + !byte $12,%01111000 + !byte $12,%10011001; + !byte $12,%10111001 + !byte $2D,%11111001 + !byte $2C,%11111001 + !byte $2C,%00011010 + !byte $13,%00011010 + !byte $13,%00111010 + !byte $2B,%01011010 + !byte $1F,%10111011 + !byte $15,%10111011 + !byte $2C,%11011011 + !byte $29,%11011011 + !byte $20,%11011011 + !byte $13,%11011011 + !byte $2B,%11111011 + !byte $28,%11111011 + !byte $1E,%11111011 + !byte $17,%11111011 + !byte $16,%11111011 + !byte $14,%11111011 + !byte $13,%11111011 + !byte $27,%00011100 + !byte $22,%00011100 + !byte $21,%00011100 + !byte $1D,%00011100 + !byte $17,%00011100 + !byte $26,%00111100 + !byte $25,%00111100 + !byte $24,%00111100 + !byte $23,%00111100 + !byte $1C,%00111100 + !byte $1B,%00111100 + !byte $1A,%00111100 + !byte $19,%00111100 + !byte $27,%01011100 + !byte $18,%01011100 + !byte $1F,%10101001 + !byte $20,%11001001 + !byte $1F,%11001001 + !byte $21,%01001010 + !byte $1E,%01001010 + !byte $22,%01101010 + !byte $22,%10001011; + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $1C,%01101010 + !byte $1C,%10001011; + !byte $23,%10101011 + !byte $1C,%10101011 + !byte $25,%11001011 + !byte $23,%11001011 + !byte $1B,%11001011 + !byte $1A,%11001011 + !byte $25,%11101011 + !byte $24,%11101011 + !byte $1B,%11101011 + !byte $25,%10101101 + !byte $1A,%00001110 + !byte $23,%00110000 + !byte $24,%01010000 + !byte $1A,%01010000 + !byte $27,%01110000 + !byte $27,%10010001; + !byte $26,%01110000 + !byte $26,%10010001; + !byte $19,%01110000 + !byte $19,%10010001; + !byte $27,%10110001 + !byte $28,%11010001 + !byte $17,%11010001 + !byte $29,%00010010 + !byte $2A,%00110010 + !byte $14,%01010010 + !byte $12,%01010010 + !byte $12,%01110010 + !byte $12,%10010011; + !byte $13,%11010011 + !byte $2C,%11110011 + !byte $12,%00110100 + !byte $2D,%01010100 + !byte $2D,%01110100 + !byte $2D,%10010101; + !byte $0D,%00110110 + !byte $32,%01010110 + !byte $33,%10110111 + !byte $32,%11010111 + !byte $11,%11110111 + !byte $0D,%11110111 + !byte $11,%00011000 + !byte $0E,%00011000 + !byte $11,%00111000 + !byte $11,%01011000 + !byte $2D,%10111001 + !byte $2D,%11011001 + !byte $12,%11111001 + !byte $2C,%00111010 + !byte $13,%01011010 + !byte $2A,%11011011 + !byte $15,%11011011 + !byte $2C,%11111011 + !byte $29,%11111011 + !byte $20,%11111011 + !byte $2C,%00011100 + !byte $28,%00011100 + !byte $1E,%00011100 + !byte $13,%00011100 + !byte $27,%00111100 + !byte $22,%00111100 + !byte $1D,%00111100 + !byte $25,%01011100 + !byte $24,%01011100 + !byte $1B,%01011100 + !byte $1A,%01011100 + !byte $27,%01111100 + !byte $27,%10011101; + !byte $20,%10101001 + !byte $1E,%11001001 + !byte $1E,%00101010 + !byte $1D,%01001010 + !byte $1B,%10101011 + !byte $1B,%00110000 + !byte $25,%01010000 + !byte $15,%11010001 + !byte $15,%00010010 + !byte $2D,%01010010 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $12,%11110011 + !byte $12,%00010100 + !byte $11,%01010100 + !byte $11,%01110100 + !byte $11,%10010101; + !byte $11,%10110101 + !byte $11,%11010101 + !byte $2E,%11110101 + !byte $0C,%01010110 + !byte $0C,%01110110 + !byte $0C,%10010111; + !byte $0C,%11010111 + !byte $0B,%11010111 + !byte $32,%11110111 + !byte $2E,%11110111 + !byte $0C,%11110111 + !byte $31,%00011000 + !byte $30,%00011000 + !byte $2E,%00011000 + !byte $0D,%00011000 + !byte $2E,%00111000 + !byte $11,%01111000 + !byte $11,%10011001; + !byte $11,%10111001 + !byte $11,%11011001 + !byte $2D,%00011010 + !byte $12,%00011010 + !byte $11,%00011010 + !byte $12,%00111010 + !byte $2C,%01011010 + !byte $12,%01011010 + !byte $13,%01111010 + !byte $13,%10011011; + !byte $1F,%11011011 + !byte $2A,%11111011 + !byte $15,%11111011 + !byte $12,%11111011 + !byte $2B,%00011100 + !byte $29,%00011100 + !byte $20,%00011100 + !byte $16,%00011100 + !byte $15,%00011100 + !byte $12,%00011100 + !byte $2C,%00111100 + !byte $28,%00111100 + !byte $21,%00111100 + !byte $17,%00111100 + !byte $16,%00111100 + !byte $26,%01011100 + !byte $23,%01011100 + !byte $22,%01011100 + !byte $1C,%01011100 + !byte $19,%01011100 + !byte $17,%01011100 + !byte $25,%01111100 + !byte $25,%10011101; + !byte $24,%01111100 + !byte $24,%10011101; + !byte $1B,%01111100 + !byte $1B,%10011101; + !byte $1A,%01111100 + !byte $1A,%10011101; + !byte $19,%01111100 + !byte $19,%10011101; + !byte $27,%10111101 + !byte $1A,%10111101 + !byte $17,%10111101 + !byte $1F,%01001000 + !byte $20,%01101000 + !byte $20,%10001001; + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $1E,%10101001 + !byte $1E,%00001010 + !byte $22,%00101010 + !byte $21,%00101010 + !byte $1D,%00101010 + !byte $22,%01001010 + !byte $1C,%01001010 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $25,%10101011 + !byte $19,%10101011 + !byte $24,%11001011 + !byte $25,%11101101 + !byte $24,%00110000 + !byte $1A,%00110000 + !byte $19,%01010000 + !byte $18,%01110000 + !byte $18,%10010001; + !byte $17,%10110001 + !byte $15,%10110001 + !byte $29,%11110001 + !byte $15,%11110001 + !byte $2A,%00010010 + !byte $14,%00110010 + !byte $2B,%01010010 + !byte $11,%01010010 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $2C,%11010011 + !byte $12,%11010011 + !byte $2D,%00010100 + !byte $2D,%00110100 + !byte $11,%00110100 + !byte $2E,%11010101 + !byte $10,%11110101 + !byte $32,%00110110 + !byte $0C,%00110110 + !byte $33,%01110110 + !byte $33,%10010111; + !byte $34,%11010111 + !byte $33,%11010111 + !byte $32,%00011000 + !byte $10,%00011000 + !byte $0C,%00011000 + !byte $10,%00111000 + !byte $2E,%01011000 + !byte $10,%01011000 + !byte $2E,%01111000 + !byte $2E,%10011001; + !byte $2E,%10111001 + !byte $11,%11111001 + !byte $2D,%00111010 + !byte $2C,%01111010 + !byte $2C,%10011011; + !byte $12,%01111010 + !byte $12,%10011011; + !byte $2A,%00011100 + !byte $29,%00111100 + !byte $1E,%00111100 + !byte $15,%00111100 + !byte $13,%00111100 + !byte $12,%00111100 + !byte $28,%01011100 + !byte $21,%01011100 + !byte $1D,%01011100 + !byte $16,%01011100 + !byte $26,%01111100 + !byte $26,%10011101; + !byte $23,%01111100 + !byte $23,%10011101; + !byte $1C,%01111100 + !byte $1C,%10011101; + !byte $18,%01111100 + !byte $18,%10011101; + !byte $1F,%00101000 + !byte $20,%01001000 + !byte $1E,%01001000 + !byte $1E,%01101000 + !byte $1E,%10001001; + !byte $21,%00001010 + !byte $1D,%00001010 + !byte $1C,%00101010 + !byte $23,%01001010 + !byte $1B,%01001010 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $19,%01101010 + !byte $19,%10001011; + !byte $24,%10101011 + !byte $1A,%10101011 + !byte $25,%00001100 + !byte $25,%00101100 + !byte $25,%01001100 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $26,%01010000 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $28,%10110001 + !byte $12,%10110011 + !byte $2D,%11110011 + !byte $11,%00010100 + !byte $2E,%01010100 + !byte $10,%01010100 + !byte $2E,%01110100 + !byte $2E,%10010101; + !byte $2E,%10110101 + !byte $10,%11010101 + !byte $0B,%01110110 + !byte $0B,%10010111; + !byte $0B,%10110111 + !byte $0A,%11010111 + !byte $33,%11110111 + !byte $0B,%11110111 + !byte $33,%00011000 + !byte $32,%00111000 + !byte $31,%00111000 + !byte $0D,%00111000 + !byte $0C,%00111000 + !byte $10,%01111000 + !byte $10,%10011001; + !byte $10,%10111001 + !byte $2E,%11011001 + !byte $10,%11011001 + !byte $2E,%11111001 + !byte $2E,%00111010 + !byte $11,%00111010 + !byte $10,%00111010 + !byte $2D,%01011010 + !byte $11,%01011010 + !byte $2D,%01111010 + !byte $2D,%10011011; + !byte $2C,%10111011 + !byte $12,%10111011 + !byte $1F,%11111011 + !byte $2D,%00011100 + !byte $14,%00011100 + !byte $2D,%00111100 + !byte $2A,%00111100 + !byte $20,%00111100 + !byte $14,%00111100 + !byte $2C,%01011100 + !byte $29,%01011100 + !byte $1E,%01011100 + !byte $15,%01011100 + !byte $12,%01011100 + !byte $28,%01111100 + !byte $28,%10011101; + !byte $22,%01111100 + !byte $22,%10011101; + !byte $21,%01111100 + !byte $21,%10011101; + !byte $1D,%01111100 + !byte $1D,%10011101; + !byte $17,%01111100 + !byte $17,%10011101; + !byte $16,%01111100 + !byte $16,%10011101; + !byte $26,%10111101 + !byte $25,%10111101 + !byte $24,%10111101 + !byte $23,%10111101 + !byte $22,%10111101 + !byte $1C,%10111101 + !byte $1B,%10111101 + !byte $19,%10111101 + !byte $18,%10111101 + !byte $17,%11011101 + !byte $20,%00001000 + !byte $1F,%00001000 + !byte $20,%00101000 + !byte $22,%11101001 + !byte $21,%11101001 + !byte $1E,%11101001 + !byte $1D,%11101001 + !byte $23,%00001010 + !byte $22,%00001010 + !byte $1C,%00001010 + !byte $23,%00101010 + !byte $1B,%00101010 + !byte $24,%01001010 + !byte $19,%01001010 + !byte $24,%01101010 + !byte $24,%10001011; + !byte $1A,%01101010 + !byte $1A,%10001011; + !byte $19,%11001101 + !byte $24,%00010000 + !byte $23,%00010000 + !byte $1B,%00010000 + !byte $25,%00110000 + !byte $19,%00110000 + !byte $27,%01010000 + !byte $18,%01010000 + !byte $28,%01110000 + !byte $28,%10010001; + !byte $2A,%10110001 + !byte $29,%10110001 + !byte $16,%10110001 + !byte $2A,%11110001 + !byte $2B,%00010010 + !byte $14,%00010010 + !byte $2E,%00110010 + !byte $2B,%00110010 + !byte $13,%00110010 + !byte $11,%00110010 + !byte $10,%00110010 + !byte $2E,%01010010 + !byte $2E,%01110010 + !byte $2E,%10010011; + !byte $2D,%11010011 + !byte $11,%11110011 + !byte $2E,%00010100 + !byte $2E,%00110100 + !byte $10,%01110100 + !byte $10,%10010101; + !byte $10,%10110101 + !byte $2F,%11010101 + !byte $2F,%11110101 + !byte $33,%01010110 + !byte $0B,%01010110 + !byte $34,%01110110 + !byte $34,%10010111; + !byte $34,%10110111 + !byte $35,%11010111 + !byte $34,%11110111 + !byte $34,%00011000 + !byte $2F,%00011000 + !byte $0B,%00011000 + !byte $33,%00111000 + !byte $2F,%00111000 + !byte $2F,%01011000 + !byte $2F,%01111000 + !byte $2F,%10011001; + !byte $2F,%10111001 + !byte $2F,%11011001 + !byte $10,%11111001 + !byte $2E,%00011010 + !byte $11,%01111010 + !byte $11,%10011011; + !byte $2D,%10111011 + !byte $12,%11011011 + !byte $1F,%00011100 + !byte $2B,%00111100 + !byte $11,%00111100 + !byte $2D,%01011100 + !byte $2A,%01011100 + !byte $11,%01011100 + !byte $2D,%01111100 + !byte $2D,%10011101; + !byte $29,%01111100 + !byte $29,%10011101; + !byte $15,%01111100 + !byte $15,%10011101; + !byte $12,%01111100 + !byte $12,%10011101; + !byte $28,%10111101 + !byte $1D,%10111101 + !byte $26,%11011101 + !byte $25,%11011101 + !byte $24,%11011101 + !byte $1B,%11011101 + !byte $1A,%11011101 + !byte $19,%11011101 + !byte $18,%11011101 + !byte $28,%11111101 + !byte $17,%11111101 + !byte $1E,%00101000 + !byte $21,%11001001 + !byte $1D,%11001001 + !byte $23,%11101001 + !byte $1C,%11101001 + !byte $24,%00101010 + !byte $26,%01001010 + !byte $26,%00101100 + !byte $19,%00101100 + !byte $1A,%00010000 + !byte $26,%00110000 + !byte $28,%01010000 + !byte $14,%10110001 + !byte $2A,%11010001 + !byte $2F,%00110010 + !byte $10,%01010010 + !byte $10,%01110010 + !byte $10,%10010011; + !byte $2D,%10110011 + !byte $2F,%01010100 + !byte $2F,%01110100 + !byte $2F,%10010101; + !byte $2F,%10110101 + !byte $34,%01010110 + !byte $0A,%10110111 + !byte $36,%11110111 + !byte $0A,%11110111 + !byte $09,%11110111 + !byte $0F,%00011000 + !byte $0A,%00011000 + !byte $34,%00111000 + !byte $0F,%00111000 + !byte $0B,%00111000 + !byte $33,%01011000 + !byte $32,%01011000 + !byte $0F,%01011000 + !byte $0C,%01011000 + !byte $0B,%01011000 + !byte $0F,%01111000 + !byte $0F,%10011001; + !byte $0F,%10111001 + !byte $2F,%11111001 + !byte $2F,%00011010 + !byte $10,%00011010 + !byte $2F,%01011010 + !byte $2E,%01011010 + !byte $10,%01011010 + !byte $2E,%01111010 + !byte $2E,%10011011; + !byte $11,%10111011 + !byte $2D,%11011011 + !byte $2D,%11111011 + !byte $1F,%00111100 + !byte $2E,%01011100 + !byte $2B,%01011100 + !byte $20,%01011100 + !byte $14,%01011100 + !byte $2E,%01111100 + !byte $2E,%10011101; + !byte $2A,%01111100 + !byte $2A,%10011101; + !byte $1E,%01111100 + !byte $1E,%10011101; + !byte $14,%01111100 + !byte $14,%10011101; + !byte $11,%01111100 + !byte $11,%10011101; + !byte $2D,%10111101 + !byte $29,%10111101 + !byte $21,%10111101 + !byte $16,%10111101 + !byte $15,%10111101 + !byte $11,%10111101 + !byte $28,%11011101 + !byte $27,%11011101 + !byte $23,%11011101 + !byte $22,%11011101 + !byte $1D,%11011101 + !byte $1C,%11011101 + !byte $16,%11011101 + !byte $26,%11111101 + !byte $25,%11111101 + !byte $24,%11111101 + !byte $1B,%11111101 + !byte $1A,%11111101 + !byte $19,%11111101 + !byte $18,%11111101 + !byte $28,%00011110 + !byte $25,%00011110 + !byte $20,%11000111 + !byte $1F,%11000111 + !byte $20,%11100111 + !byte $1F,%11100111 + !byte $1E,%00001000 + !byte $22,%10101001 + !byte $21,%10101001 + !byte $1D,%10101001 + !byte $23,%11001001 + !byte $22,%11001001 + !byte $1C,%11001001 + !byte $1B,%11101001 + !byte $24,%00001010 + !byte $1B,%00001010 + !byte $19,%00001010 + !byte $26,%00101010 + !byte $19,%00101010 + !byte $25,%01001010 + !byte $1A,%01001010 + !byte $19,%11001011 + !byte $19,%11101011 + !byte $19,%00001100 + !byte $19,%01001100 + !byte $24,%11101111 + !byte $1B,%11101111 + !byte $25,%00010000 + !byte $18,%00110000 + !byte $17,%01010000 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $16,%01110000 + !byte $16,%10010001; + !byte $14,%01110000 + !byte $14,%10010001; + !byte $2B,%11110001 + !byte $14,%11110001 + !byte $13,%00010010 + !byte $2C,%00110010 + !byte $2F,%01010010 + !byte $2E,%11010011 + !byte $11,%11010011 + !byte $2E,%11110011 + !byte $10,%00010100 + !byte $10,%00110100 + !byte $0F,%11010101 + !byte $0F,%11110101 + !byte $0A,%01110110 + !byte $0A,%10010111; + !byte $35,%10110111 + !byte $35,%11110111 + !byte $35,%00011000 + !byte $30,%00111000 + !byte $0A,%00111000 + !byte $34,%01011000 + !byte $30,%01011000 + !byte $30,%01111000 + !byte $30,%10011001; + !byte $30,%10111001 + !byte $0F,%11011001 + !byte $0F,%11111001 + !byte $2F,%00111010 + !byte $10,%01111010 + !byte $10,%10011011; + !byte $0F,%01111010 + !byte $0F,%10011011; + !byte $2E,%10111011 + !byte $11,%11011011 + !byte $13,%01011100 + !byte $2B,%01111100 + !byte $2B,%10011101; + !byte $20,%01111100 + !byte $20,%10011101; + !byte $2E,%10111101 + !byte $2A,%10111101 + !byte $1E,%10111101 + !byte $12,%10111101 + !byte $29,%11011101 + !byte $27,%11111101 + !byte $23,%11111101 + !byte $1C,%11111101 + !byte $28,%00111110 + !byte $25,%00111110 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $1F,%10100111 + !byte $1E,%11000111 + !byte $1E,%11100111 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $1C,%10101001 + !byte $1B,%10101001 + !byte $26,%00001010 + !byte $1A,%00001010 + !byte $25,%00101010 + !byte $1A,%00101010 + !byte $26,%00001100 + !byte $18,%00001100 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $19,%00010000 + !byte $27,%00110000 + !byte $16,%00110000 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $2B,%10110001 + !byte $14,%11010001 + !byte $13,%11110001 + !byte $12,%00110010 + !byte $0F,%00110010 + !byte $0F,%01010010 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $11,%10110011 + !byte $10,%11110011 + !byte $2F,%00110100 + !byte $30,%01010100 + !byte $0F,%01010100 + !byte $0F,%01110100 + !byte $0F,%10010101; + !byte $0F,%10110101 + !byte $30,%11010101 + !byte $0E,%11010101 + !byte $30,%11110101 + !byte $0E,%00010110 + !byte $35,%01010110 + !byte $35,%01110110 + !byte $35,%10010111; + !byte $09,%10110111 + !byte $09,%11010111 + !byte $08,%11110111 + !byte $09,%00011000 + !byte $35,%00111000 + !byte $0E,%00111000 + !byte $09,%00111000 + !byte $0E,%01011000 + !byte $0A,%01011000 + !byte $0E,%01111000 + !byte $0E,%10011001; + !byte $0B,%01111000 + !byte $0B,%10011001; + !byte $0E,%10111001 + !byte $30,%11011001 + !byte $30,%11111001 + !byte $30,%00011010 + !byte $0F,%00011010 + !byte $0E,%00011010 + !byte $0F,%00111010 + !byte $0F,%01011010 + !byte $2F,%01111010 + !byte $2F,%10011011; + !byte $10,%10111011 + !byte $2E,%11011011 + !byte $10,%11011011 + !byte $2E,%11111011 + !byte $11,%11111011 + !byte $11,%00011100 + !byte $1F,%01011100 + !byte $2C,%01111100 + !byte $2C,%10011101; + !byte $13,%01111100 + !byte $13,%10011101; + !byte $10,%01111100 + !byte $10,%10011101; + !byte $2B,%10111101 + !byte $20,%10111101 + !byte $14,%10111101 + !byte $13,%10111101 + !byte $10,%10111101 + !byte $2E,%11011101 + !byte $2D,%11011101 + !byte $2A,%11011101 + !byte $21,%11011101 + !byte $1E,%11011101 + !byte $15,%11011101 + !byte $14,%11011101 + !byte $11,%11011101 + !byte $10,%11011101 + !byte $29,%11111101 + !byte $22,%11111101 + !byte $21,%11111101 + !byte $1D,%11111101 + !byte $16,%11111101 + !byte $15,%11111101 + !byte $27,%00011110 + !byte $26,%00011110 + !byte $24,%00011110 + !byte $23,%00011110 + !byte $1C,%00011110 + !byte $1B,%00011110 + !byte $1A,%00011110 + !byte $19,%00011110 + !byte $18,%00011110 + !byte $17,%00011110 + !byte $16,%00111110 + !byte $28,%01011110 + !byte $25,%01011110 + !byte $16,%01011110 + !byte $20,%10100111 + !byte $1E,%10100111 + !byte $21,%01001000 + !byte $1D,%01001000 + !byte $22,%01101000 + !byte $22,%10001001; + !byte $1C,%01101000 + !byte $1C,%10001001; + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $23,%10101001 + !byte $24,%11001001 + !byte $1B,%11001001 + !byte $26,%11101001 + !byte $24,%11101001 + !byte $1A,%11101001 + !byte $18,%11101001 + !byte $25,%00001010 + !byte $26,%11101011 + !byte $18,%11101011 + !byte $25,%11101111 + !byte $1A,%11101111 + !byte $26,%00010000 + !byte $18,%00010000 + !byte $17,%00110000 + !byte $16,%01010000 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $13,%01110000 + !byte $13,%10010001; + !byte $2B,%11010001 + !byte $2C,%00010010 + !byte $12,%00010010 + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $2E,%10110011 + !byte $10,%11010011 + !byte $2F,%00010100 + !byte $0F,%00110100 + !byte $0E,%01010100 + !byte $30,%10110101 + !byte $0E,%11110101 + !byte $0A,%01010110 + !byte $09,%01110110 + !byte $09,%10010111; + !byte $36,%10110111 + !byte $36,%11010111 + !byte $37,%11110111 + !byte $07,%11110111 + !byte $37,%00011000 + !byte $36,%00011000 + !byte $07,%00011000 + !byte $35,%01011000 + !byte $09,%01011000 + !byte $34,%01111000 + !byte $34,%10011001; + !byte $0A,%01111000 + !byte $0A,%10011001; + !byte $0E,%11011001 + !byte $0E,%11111001 + !byte $30,%00111010 + !byte $30,%10111011 + !byte $2F,%10111011 + !byte $0E,%10111011 + !byte $2F,%11011011 + !byte $10,%11111011 + !byte $2E,%00011100 + !byte $10,%00011100 + !byte $2C,%10111101 + !byte $2B,%11011101 + !byte $20,%11011101 + !byte $2E,%11111101 + !byte $2A,%11111101 + !byte $14,%11111101 + !byte $10,%11111101 + !byte $29,%00011110 + !byte $22,%00011110 + !byte $16,%00011110 + !byte $27,%00111110 + !byte $26,%00111110 + !byte $24,%00111110 + !byte $23,%00111110 + !byte $1B,%00111110 + !byte $1A,%00111110 + !byte $19,%00111110 + !byte $18,%00111110 + !byte $17,%00111110 + !byte $1F,%01000110 + !byte $20,%01100110 + !byte $20,%10000111; + !byte $1E,%01100110 + !byte $1E,%10000111; + !byte $21,%00101000 + !byte $22,%01001000 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $24,%10101001 + !byte $26,%11001001 + !byte $1A,%11001001 + !byte $25,%11101001 + !byte $19,%11101001 + !byte $26,%01101010 + !byte $26,%10001011; + !byte $26,%10101011 + !byte $26,%11001011 + !byte $1B,%11001111 + !byte $19,%11101111 + !byte $27,%00010000 + !byte $28,%00110000 + !byte $29,%01010000 + !byte $2A,%01110000 + !byte $2A,%10010001; + !byte $2C,%11110001 + !byte $30,%00110010 + !byte $2D,%00110010 + !byte $30,%01010010 + !byte $2F,%11010011 + !byte $2F,%11110011 + !byte $0F,%00010100 + !byte $30,%00110100 + !byte $31,%01010100 + !byte $30,%01110100 + !byte $30,%10010101; + !byte $0E,%10110101 + !byte $31,%11110101 + !byte $31,%00010110 + !byte $36,%01110110 + !byte $36,%10010111; + !byte $08,%11010111 + !byte $38,%00011000 + !byte $08,%00011000 + !byte $36,%00111000 + !byte $08,%00111000 + !byte $36,%01011000 + !byte $31,%01011000 + !byte $35,%01111000 + !byte $35,%10011001; + !byte $31,%01111000 + !byte $31,%10011001; + !byte $09,%01111000 + !byte $09,%10011001; + !byte $31,%10111001 + !byte $31,%11011001 + !byte $31,%11111001 + !byte $0E,%00111010 + !byte $30,%01011010 + !byte $0E,%01011010 + !byte $30,%01111010 + !byte $30,%10011011; + !byte $0F,%10111011 + !byte $0F,%11011011 + !byte $0E,%11011011 + !byte $2F,%11111011 + !byte $2F,%00011100 + !byte $2E,%00111100 + !byte $10,%00111100 + !byte $1F,%01111100 + !byte $1F,%10011101; + !byte $2F,%10111101 + !byte $2F,%11011101 + !byte $2C,%11011101 + !byte $13,%11011101 + !byte $2F,%11111101 + !byte $2B,%11111101 + !byte $1E,%11111101 + !byte $13,%11111101 + !byte $11,%11111101 + !byte $2A,%00011110 + !byte $21,%00011110 + !byte $1D,%00011110 + !byte $15,%00011110 + !byte $14,%00011110 + !byte $10,%00011110 + !byte $29,%00111110 + !byte $22,%00111110 + !byte $1D,%00111110 + !byte $1C,%00111110 + !byte $15,%00111110 + !byte $27,%01011110 + !byte $26,%01011110 + !byte $24,%01011110 + !byte $23,%01011110 + !byte $1B,%01011110 + !byte $1A,%01011110 + !byte $19,%01011110 + !byte $18,%01011110 + !byte $17,%01011110 + !byte $29,%01111110 + !byte $29,%10011111; + !byte $16,%01111110 + !byte $16,%10011111; + !byte $20,%00100110 + !byte $1F,%00100110 + !byte $20,%01000110 + !byte $1E,%01000110 + !byte $21,%00001000 + !byte $22,%00101000 + !byte $1D,%00101000 + !byte $1C,%00101000 + !byte $23,%01001000 + !byte $1C,%01001000 + !byte $1B,%01001000 + !byte $24,%01101000 + !byte $24,%10001001; + !byte $26,%10101001 + !byte $1A,%10101001 + !byte $25,%11001001 + !byte $18,%11001001 + !byte $27,%11001011 + !byte $25,%11001111 + !byte $24,%11001111 + !byte $1A,%11001111 + !byte $26,%11101111 + !byte $18,%11101111 + !byte $29,%00010000 + !byte $28,%00010000 + !byte $17,%00010000 + !byte $29,%00110000 + !byte $2C,%01010000 + !byte $15,%01010000 + !byte $13,%01010000 + !byte $2C,%01110000 + !byte $2C,%10010001; + !byte $2C,%11010001 + !byte $13,%11010001 + !byte $12,%11110001 + !byte $30,%00010010 + !byte $2D,%00010010 + !byte $0F,%00010010 + !byte $30,%01110010 + !byte $30,%10010011; + !byte $2F,%10110011 + !byte $10,%10110011 + !byte $0F,%11110011 + !byte $30,%00010100 + !byte $0E,%01110100 + !byte $0E,%10010101; + !byte $31,%10110101 + !byte $31,%11010101 + !byte $0D,%11010101 + !byte $0D,%00010110 + !byte $08,%01010110 + !byte $37,%10110111 + !byte $08,%10110111 + !byte $37,%11010111 + !byte $06,%00011000 + !byte $37,%00111000 + !byte $0D,%01011000 + !byte $08,%01011000 + !byte $36,%01111000 + !byte $36,%10011001; + !byte $0D,%01111000 + !byte $0D,%10011001; + !byte $0D,%10111001 + !byte $0D,%11011001 + !byte $31,%00011010 + !byte $31,%00111010 + !byte $31,%01011010 + !byte $0E,%01111010 + !byte $0E,%10011011; + !byte $31,%11011011 + !byte $30,%11011011 + !byte $30,%11111011 + !byte $0F,%11111011 + !byte $0F,%00011100 + !byte $2F,%00111100 + !byte $10,%01011100 + !byte $1F,%10111101 + !byte $12,%11011101 + !byte $0F,%11011101 + !byte $2C,%11111101 + !byte $0F,%11111101 + !byte $2F,%00011110 + !byte $2E,%00011110 + !byte $2B,%00011110 + !byte $1E,%00011110 + !byte $2A,%00111110 + !byte $0F,%00111110 + !byte $29,%01011110 + !byte $1C,%01011110 + !byte $27,%01111110 + !byte $27,%10011111; + !byte $26,%01111110 + !byte $26,%10011111; + !byte $25,%01111110 + !byte $25,%10011111; + !byte $1A,%01111110 + !byte $1A,%10011111; + !byte $19,%01111110 + !byte $19,%10011111; + !byte $18,%01111110 + !byte $18,%10011111; + !byte $29,%10111111 + !byte $19,%10111111 + !byte $16,%10111111 + !byte $1F,%00000110 + !byte $1E,%00100110 + !byte $22,%00001000 + !byte $1D,%00001000 + !byte $23,%00101000 + !byte $1B,%00101000 + !byte $24,%01001000 + !byte $1A,%01101000 + !byte $1A,%10001001; + !byte $25,%10101001 + !byte $18,%10101001 + !byte $19,%11001001 + !byte $2A,%01010000 + !byte $13,%10110001 + !byte $2D,%11110001 + !byte $11,%00010010 + !byte $0E,%00110010 + !byte $0E,%01010010 + !byte $0F,%11010011 + !byte $30,%11110011 + !byte $0E,%00110100 + !byte $0D,%01010100 + !byte $31,%01110100 + !byte $31,%10010101; + !byte $0D,%11110101 + !byte $37,%01110110 + !byte $37,%10010111; + !byte $07,%11010111 + !byte $39,%00011000 + !byte $39,%00111000 + !byte $07,%00111000 + !byte $06,%00111000 + !byte $37,%01011000 + !byte $07,%01011000 + !byte $37,%01111000 + !byte $37,%10011001; + !byte $32,%01111000 + !byte $32,%10011001; + !byte $08,%01111000 + !byte $08,%10011001; + !byte $36,%10111001 + !byte $35,%10111001 + !byte $34,%10111001 + !byte $32,%10111001 + !byte $0A,%10111001 + !byte $09,%10111001 + !byte $08,%10111001 + !byte $32,%11011001 + !byte $0D,%11111001 + !byte $0D,%00011010 + !byte $0D,%00111010 + !byte $32,%01011010 + !byte $31,%01111010 + !byte $31,%10011011; + !byte $31,%10111011 + !byte $30,%00011100 + !byte $30,%00111100 + !byte $0F,%00111100 + !byte $2F,%01011100 + !byte $1F,%11011101 + !byte $30,%11111101 + !byte $2D,%11111101 + !byte $20,%11111101 + !byte $12,%11111101 + !byte $30,%00011110 + !byte $2C,%00011110 + !byte $13,%00011110 + !byte $0F,%00011110 + !byte $2F,%00111110 + !byte $2B,%00111110 + !byte $21,%00111110 + !byte $1E,%00111110 + !byte $14,%00111110 + !byte $13,%00111110 + !byte $10,%00111110 + !byte $30,%01011110 + !byte $2A,%01011110 + !byte $22,%01011110 + !byte $1D,%01011110 + !byte $15,%01011110 + !byte $14,%01011110 + !byte $28,%01111110 + !byte $28,%10011111; + !byte $24,%01111110 + !byte $24,%10011111; + !byte $23,%01111110 + !byte $23,%10011111; + !byte $1C,%01111110 + !byte $1C,%10011111; + !byte $1B,%01111110 + !byte $1B,%10011111; + !byte $17,%01111110 + !byte $17,%10011111; + !byte $27,%10111111 + !byte $26,%10111111 + !byte $25,%10111111 + !byte $1A,%10111111 + !byte $18,%10111111 + !byte $29,%11011111 + !byte $19,%11011111 + !byte $15,%11011111 + !byte $20,%11100101 + !byte $1F,%11100101 + !byte $20,%00000110 + !byte $1E,%00000110 + !byte $22,%11100111 + !byte $21,%11100111 + !byte $1D,%11100111 + !byte $1C,%11100111 + !byte $23,%00001000 + !byte $1C,%00001000 + !byte $1B,%00001000 + !byte $24,%00101000 + !byte $1A,%01001000 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $26,%01101000 + !byte $26,%10001001; + !byte $25,%01101000 + !byte $25,%10001001; + !byte $18,%01101000 + !byte $18,%10001001; + !byte $19,%10101001 + !byte $18,%00101010 + !byte $18,%01001010 + !byte $18,%01101010 + !byte $18,%10001011; + !byte $17,%01101010 + !byte $17,%10001011; + !byte $18,%10101011 + !byte $18,%11001011 + !byte $24,%10101111 + !byte $1A,%10101111 + !byte $26,%11001111 + !byte $19,%11001111 + !byte $18,%11001111 + !byte $27,%11101111 + !byte $17,%11101111 + !byte $16,%00010000 + !byte $15,%00010000 + !byte $15,%00110000 + !byte $14,%01010000 + !byte $12,%01010000 + !byte $2C,%10110001 + !byte $12,%11010001 + !byte $11,%11110001 + !byte $31,%00010010 + !byte $0E,%00010010 + !byte $0D,%00010010 + !byte $31,%00110010 + !byte $31,%01010010 + !byte $0E,%01110010 + !byte $0E,%10010011; + !byte $0F,%10110011 + !byte $30,%11010011 + !byte $0E,%11110011 + !byte $0E,%00010100 + !byte $32,%01010100 + !byte $0D,%01110100 + !byte $0D,%10010101; + !byte $0D,%10110101 + !byte $32,%00010110 + !byte $08,%01110110 + !byte $08,%10010111; + !byte $07,%01110110 + !byte $07,%10010111; + !byte $07,%10110111 + !byte $38,%11010111 + !byte $38,%11110111 + !byte $05,%00011000 + !byte $38,%00111000 + !byte $05,%00111000 + !byte $38,%01011000 + !byte $0C,%01111000 + !byte $0C,%10011001; + !byte $07,%01111000 + !byte $07,%10011001; + !byte $37,%10111001 + !byte $0C,%10111001 + !byte $0C,%11011001 + !byte $32,%11111001 + !byte $32,%00011010 + !byte $0D,%01011010 + !byte $0D,%01111010 + !byte $0D,%10011011; + !byte $0D,%10111011 + !byte $0E,%11111011 + !byte $0E,%00011100 + !byte $0F,%01011100 + !byte $2F,%01111100 + !byte $2F,%10011101; + !byte $0F,%01111100 + !byte $0F,%10011101; + !byte $2D,%00011110 + !byte $20,%00011110 + !byte $12,%00011110 + !byte $0E,%00011110 + !byte $30,%00111110 + !byte $2C,%00111110 + !byte $12,%00111110 + !byte $2F,%01011110 + !byte $2B,%01011110 + !byte $21,%01011110 + !byte $13,%01011110 + !byte $0F,%01011110 + !byte $2A,%01111110 + !byte $2A,%10011111; + !byte $22,%01111110 + !byte $22,%10011111; + !byte $15,%01111110 + !byte $15,%10011111; + !byte $14,%01111110 + !byte $14,%10011111; + !byte $28,%10111111 + !byte $24,%10111111 + !byte $23,%10111111 + !byte $1B,%10111111 + !byte $17,%10111111 + !byte $29,%11111111 + !byte $15,%11111111 + !byte $1F,%10100101 + !byte $1F,%11000101 + !byte $1E,%11100101 + !byte $21,%11000111 + !byte $1D,%11000111 + !byte $23,%11100111 + !byte $1A,%00101000 + !byte $25,%01001000 + !byte $18,%01001000 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $18,%00001010 + !byte $27,%01101010 + !byte $27,%10001011; + !byte $2A,%00110000 + !byte $2E,%00010010 + !byte $0D,%00110010 + !byte $0D,%01010010 + !byte $31,%01110010 + !byte $31,%10010011; + !byte $0E,%11010011 + !byte $31,%00010100 + !byte $31,%00110100 + !byte $0C,%01010100 + !byte $32,%11010101 + !byte $32,%11110101 + !byte $0C,%11110101 + !byte $0C,%00010110 + !byte $38,%01110110 + !byte $38,%10010111; + !byte $06,%11010111 + !byte $06,%11110111 + !byte $3A,%00111000 + !byte $06,%01011000 + !byte $38,%01111000 + !byte $38,%10011001; + !byte $06,%01111000 + !byte $06,%10011001; + !byte $07,%10111001 + !byte $37,%11011001 + !byte $36,%11011001 + !byte $09,%11011001 + !byte $08,%11011001 + !byte $0C,%11111001 + !byte $0C,%00011010 + !byte $32,%00111010 + !byte $0C,%00111010 + !byte $32,%01111010 + !byte $32,%10011011; + !byte $0D,%11011011 + !byte $31,%11111011 + !byte $0D,%11111011 + !byte $32,%00011100 + !byte $31,%00011100 + !byte $0C,%00011100 + !byte $0E,%00111100 + !byte $30,%01011100 + !byte $0E,%01011100 + !byte $30,%01111100 + !byte $30,%10011101; + !byte $0F,%10111101 + !byte $1F,%11111101 + !byte $11,%00011110 + !byte $2D,%00111110 + !byte $20,%00111110 + !byte $11,%00111110 + !byte $0E,%00111110 + !byte $2C,%01011110 + !byte $1E,%01011110 + !byte $12,%01011110 + !byte $0E,%01011110 + !byte $30,%01111110 + !byte $30,%10011111; + !byte $2B,%01111110 + !byte $2B,%10011111; + !byte $21,%01111110 + !byte $21,%10011111; + !byte $1D,%01111110 + !byte $1D,%10011111; + !byte $13,%01111110 + !byte $13,%10011111; + !byte $0F,%01111110 + !byte $0F,%10011111; + !byte $0E,%01111110 + !byte $0E,%10011111; + !byte $2A,%10111111 + !byte $22,%10111111 + !byte $1C,%10111111 + !byte $15,%10111111 + !byte $14,%10111111 + !byte $28,%11011111 + !byte $27,%11011111 + !byte $26,%11011111 + !byte $25,%11011111 + !byte $24,%11011111 + !byte $23,%11011111 + !byte $1B,%11011111 + !byte $1A,%11011111 + !byte $18,%11011111 + !byte $17,%11011111 + !byte $16,%11011111 + !byte $2A,%11111111 + !byte $66,%00000000 + !byte $55,%00000000 + !byte $20,%10100101 + !byte $20,%11000101 + !byte $1E,%11000101 + !byte $22,%10100111 + !byte $21,%10100111 + !byte $1D,%10100111 + !byte $24,%11000111 + !byte $23,%11000111 + !byte $22,%11000111 + !byte $1C,%11000111 + !byte $24,%11100111 + !byte $1B,%11100111 + !byte $24,%00001000 + !byte $1A,%00001000 + !byte $27,%00101000 + !byte $25,%00101000 + !byte $18,%00101000 + !byte $27,%01001000 + !byte $26,%01001000 + !byte $19,%01001000 + !byte $27,%01001010 + !byte $17,%01001010 + !byte $24,%01101110 + !byte $24,%10001111; + !byte $25,%10101111 + !byte $19,%10101111 + !byte $27,%11001111 + !byte $17,%11001111 + !byte $28,%11101111 + !byte $16,%11101111 + !byte $14,%00110000 + !byte $12,%00110000 + !byte $2B,%01010000 + !byte $12,%10110001 + !byte $2D,%11010001 + !byte $11,%11010001 + !byte $2E,%11110001 + !byte $10,%00010010 + !byte $30,%10110011 + !byte $0E,%10110011 + !byte $0D,%00010100 + !byte $0D,%00110100 + !byte $32,%01110100 + !byte $32,%10010101; + !byte $32,%10110101 + !byte $0C,%11010101 + !byte $38,%10110111 + !byte $06,%10110111 + !byte $39,%11110111 + !byte $04,%00111000 + !byte $3A,%01011000 + !byte $39,%01011000 + !byte $04,%01011000 + !byte $33,%01111000 + !byte $33,%10011001; + !byte $38,%10111001 + !byte $33,%10111001 + !byte $06,%10111001 + !byte $33,%11011001 + !byte $07,%11011001 + !byte $33,%11111001 + !byte $0C,%01011010 + !byte $33,%01111010 + !byte $33,%10011011; + !byte $0C,%01111010 + !byte $0C,%10011011; + !byte $32,%10111011 + !byte $0C,%10111011 + !byte $32,%11011011 + !byte $0D,%00011100 + !byte $31,%00111100 + !byte $0E,%01111100 + !byte $0E,%10011101; + !byte $30,%10111101 + !byte $31,%01011110 + !byte $2D,%01011110 + !byte $20,%01011110 + !byte $2F,%01111110 + !byte $2F,%10011111; + !byte $2C,%01111110 + !byte $2C,%10011111; + !byte $12,%01111110 + !byte $12,%10011111; + !byte $2B,%10111111 + !byte $1D,%10111111 + !byte $13,%10111111 + !byte $2A,%11011111 + !byte $28,%11111111 + !byte $27,%11111111 + !byte $26,%11111111 + !byte $25,%11111111 + !byte $24,%11111111 + !byte $1A,%11111111 + !byte $19,%11111111 + !byte $18,%11111111 + !byte $17,%11111111 + !byte $6A,%00000000 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $1E,%10100101 + !byte $21,%11100101 + !byte $22,%01100110 + !byte $22,%10000111; + !byte $21,%01100110 + !byte $21,%10000111; + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $23,%10100111 + !byte $1C,%10100111 + !byte $1B,%11000111 + !byte $1A,%11100111 + !byte $27,%00001000 + !byte $25,%00001000 + !byte $19,%00101000 + !byte $17,%00101000 + !byte $27,%11101001 + !byte $27,%00001010 + !byte $27,%00101010 + !byte $28,%01001010 + !byte $27,%10101011 + !byte $27,%11101011 + !byte $26,%10101111 + !byte $28,%11001111 + !byte $2A,%11101111 + !byte $29,%11101111 + !byte $2A,%00010000 + !byte $2D,%00110000 + !byte $2B,%00110000 + !byte $2D,%01010000 + !byte $12,%01110000 + !byte $12,%10010001; + !byte $2D,%10110001 + !byte $32,%00010010 + !byte $32,%00110010 + !byte $32,%01010010 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $31,%11010011 + !byte $31,%11110011 + !byte $32,%00110100 + !byte $33,%01010100 + !byte $0C,%10110101 + !byte $33,%11010101 + !byte $33,%11110101 + !byte $33,%00010110 + !byte $33,%00110110 + !byte $39,%10110111 + !byte $39,%11010111 + !byte $05,%11110111 + !byte $3B,%00111000 + !byte $3B,%01011000 + !byte $05,%01011000 + !byte $39,%01111000 + !byte $39,%10011001; + !byte $05,%01111000 + !byte $05,%10011001; + !byte $39,%10111001 + !byte $0B,%10111001 + !byte $39,%11011001 + !byte $38,%11011001 + !byte $0B,%11011001 + !byte $06,%11011001 + !byte $37,%11111001 + !byte $0B,%11111001 + !byte $07,%11111001 + !byte $33,%00011010 + !byte $0B,%00011010 + !byte $33,%00111010 + !byte $33,%01011010 + !byte $0C,%11011011 + !byte $32,%11111011 + !byte $33,%00111100 + !byte $0D,%00111100 + !byte $31,%01011100 + !byte $0D,%01011100 + !byte $31,%01111100 + !byte $31,%10011101; + !byte $0E,%10111101 + !byte $30,%11011101 + !byte $1F,%00011110 + !byte $31,%00111110 + !byte $2E,%00111110 + !byte $2E,%01011110 + !byte $11,%01011110 + !byte $31,%01111110 + !byte $31,%10011111; + !byte $2D,%01111110 + !byte $2D,%10011111; + !byte $1E,%01111110 + !byte $1E,%10011111; + !byte $11,%01111110 + !byte $11,%10011111; + !byte $31,%10111111 + !byte $30,%10111111 + !byte $2C,%10111111 + !byte $21,%10111111 + !byte $12,%10111111 + !byte $0F,%10111111 + !byte $0E,%10111111 + !byte $2B,%11011111 + !byte $22,%11011111 + !byte $1D,%11011111 + !byte $1C,%11011111 + !byte $14,%11011111 + !byte $13,%11011111 + !byte $23,%11111111 + !byte $1C,%11111111 + !byte $1B,%11111111 + !byte $16,%11111111 + !byte $68,%00000000 + !byte $67,%00000000 + !byte $65,%00000000 + !byte $5A,%00000000 + !byte $59,%00000000 + !byte $58,%00000000 + !byte $57,%00000000 + !byte $56,%00000000 + !byte $6A,%00100000 + !byte $64,%00100000 + !byte $55,%00100000 + !byte $54,%00100000 + !byte $20,%01000100 + !byte $1F,%01000100 + !byte $20,%01100100 + !byte $20,%10000101; + !byte $1E,%01100100 + !byte $1E,%10000101; + !byte $21,%10100101 + !byte $21,%11000101 + !byte $22,%01000110 + !byte $21,%01000110 + !byte $1D,%01000110 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $1C,%01100110 + !byte $1C,%10000111; + !byte $24,%10100111 + !byte $1B,%10100111 + !byte $25,%11000111 + !byte $1A,%11000111 + !byte $27,%11100111 + !byte $25,%11100111 + !byte $19,%00001000 + !byte $18,%00001000 + !byte $17,%00001000 + !byte $26,%00101000 + !byte $27,%11001001 + !byte $28,%00101010 + !byte $17,%00101010 + !byte $26,%01101110 + !byte $26,%10001111; + !byte $25,%01101110 + !byte $25,%10001111; + !byte $1A,%01101110 + !byte $1A,%10001111; + !byte $19,%01101110 + !byte $19,%10001111; + !byte $27,%10101111 + !byte $18,%10101111 + !byte $16,%11001111 + !byte $15,%11101111 + !byte $14,%00010000 + !byte $13,%00110000 + !byte $11,%00110000 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $11,%10110001 + !byte $2E,%11010001 + !byte $33,%11110001 + !byte $32,%11110001 + !byte $2F,%11110001 + !byte $10,%11110001 + !byte $0D,%11110001 + !byte $2F,%00010010 + !byte $0C,%00010010 + !byte $0C,%00110010 + !byte $31,%10110011 + !byte $0D,%11110011 + !byte $32,%00010100 + !byte $0B,%01010100 + !byte $0C,%01110100 + !byte $0C,%10010101; + !byte $33,%10110101 + !byte $0B,%11110101 + !byte $0B,%00010110 + !byte $0B,%00110110 + !byte $05,%11010111 + !byte $3A,%11110111 + !byte $3A,%00011000 + !byte $03,%00111000 + !byte $03,%01011000 + !byte $3A,%01111000 + !byte $3A,%10011001; + !byte $05,%10111001 + !byte $34,%11011001 + !byte $38,%11111001 + !byte $34,%11111001 + !byte $08,%11111001 + !byte $34,%00011010 + !byte $0B,%00111010 + !byte $0B,%01011010 + !byte $34,%10111011 + !byte $33,%10111011 + !byte $0B,%10111011 + !byte $33,%11011011 + !byte $33,%11111011 + !byte $0C,%11111011 + !byte $32,%00111100 + !byte $32,%01011100 + !byte $0D,%01111100 + !byte $0D,%10011101; + !byte $31,%10111101 + !byte $31,%11011101 + !byte $0E,%11011101 + !byte $1F,%00111110 + !byte $10,%01011110 + !byte $0D,%01011110 + !byte $2E,%01111110 + !byte $2E,%10011111; + !byte $20,%01111110 + !byte $20,%10011111; + !byte $0D,%01111110 + !byte $0D,%10011111; + !byte $2D,%10111111 + !byte $1E,%10111111 + !byte $0D,%10111111 + !byte $31,%11011111 + !byte $2C,%11011111 + !byte $0E,%11011111 + !byte $2B,%11111111 + !byte $22,%11111111 + !byte $14,%11111111 + !byte $69,%00000000 + !byte $64,%00000000 + !byte $5B,%00000000 + !byte $59,%00100000 + !byte $6A,%01000000 + !byte $54,%01000000 + !byte $1F,%00100100 + !byte $21,%01000100 + !byte $1E,%01000100 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $21,%00100110 + !byte $1C,%01000110 + !byte $24,%01100110 + !byte $24,%10000111; + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $1A,%10100111 + !byte $28,%11100111 + !byte $19,%11100111 + !byte $17,%11100111 + !byte $26,%00001000 + !byte $27,%10101001 + !byte $17,%11001011 + !byte $17,%10101111 + !byte $16,%10101111 + !byte $14,%11001111 + !byte $2B,%00010000 + !byte $11,%01010000 + !byte $2E,%10110001 + !byte $10,%11010001 + !byte $33,%00010010 + !byte $33,%00110010 + !byte $0C,%01010010 + !byte $0D,%11010011 + !byte $32,%11110011 + !byte $0C,%00110100 + !byte $34,%01010100 + !byte $33,%01110100 + !byte $33,%10010101; + !byte $0B,%11010101 + !byte $34,%00010110 + !byte $34,%00110110 + !byte $3A,%10110111 + !byte $04,%11110111 + !byte $04,%00011000 + !byte $3C,%01011000 + !byte $3C,%01111000 + !byte $3C,%10011001; + !byte $04,%01111000 + !byte $04,%10011001; + !byte $03,%01111000 + !byte $03,%10011001; + !byte $3A,%10111001 + !byte $04,%10111001 + !byte $3A,%11011001 + !byte $0A,%11011001 + !byte $05,%11011001 + !byte $39,%11111001 + !byte $06,%11111001 + !byte $05,%00011010 + !byte $34,%00111010 + !byte $34,%01011010 + !byte $34,%01111010 + !byte $34,%10011011; + !byte $0B,%01111010 + !byte $0B,%10011011; + !byte $0B,%11011011 + !byte $33,%00011100 + !byte $0C,%00111100 + !byte $0C,%01011100 + !byte $0B,%01011100 + !byte $32,%01111100 + !byte $32,%10011101; + !byte $32,%10111101 + !byte $0D,%10111101 + !byte $0D,%11011101 + !byte $31,%11111101 + !byte $0E,%11111101 + !byte $1F,%01011110 + !byte $32,%01111110 + !byte $32,%10011111; + !byte $10,%01111110 + !byte $10,%10011111; + !byte $32,%10111111 + !byte $2E,%10111111 + !byte $20,%10111111 + !byte $11,%10111111 + !byte $32,%11011111 + !byte $30,%11011111 + !byte $2D,%11011111 + !byte $21,%11011111 + !byte $1E,%11011111 + !byte $12,%11011111 + !byte $11,%11011111 + !byte $0D,%11011111 + !byte $31,%11111111 + !byte $2C,%11111111 + !byte $21,%11111111 + !byte $1D,%11111111 + !byte $13,%11111111 + !byte $12,%11111111 + !byte $0E,%11111111 + !byte $6B,%00000000 + !byte $63,%00000000 + !byte $62,%00000000 + !byte $5C,%00000000 + !byte $54,%00000000 + !byte $53,%00000000 + !byte $69,%00100000 + !byte $68,%00100000 + !byte $67,%00100000 + !byte $66,%00100000 + !byte $65,%00100000 + !byte $5B,%00100000 + !byte $5A,%00100000 + !byte $58,%00100000 + !byte $57,%00100000 + !byte $56,%00100000 + !byte $67,%01000000 + !byte $66,%01000000 + !byte $59,%01000000 + !byte $58,%01000000 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $6A,%01100000 + !byte $6A,%10000001; + !byte $58,%01100000 + !byte $58,%10000001; + !byte $54,%01100000 + !byte $54,%10000001; + !byte $20,%00000100 + !byte $1F,%00000100 + !byte $20,%00100100 + !byte $1E,%00100100 + !byte $21,%00000110 + !byte $1D,%00000110 + !byte $22,%00100110 + !byte $1D,%00100110 + !byte $1C,%00100110 + !byte $24,%01000110 + !byte $23,%01000110 + !byte $1B,%01000110 + !byte $1A,%01100110 + !byte $1A,%10000111; + !byte $25,%10100111 + !byte $28,%11000111 + !byte $27,%11000111 + !byte $19,%11000111 + !byte $17,%11000111 + !byte $26,%11100111 + !byte $17,%10101001 + !byte $17,%11001001 + !byte $17,%11101001 + !byte $28,%00001010 + !byte $17,%00001010 + !byte $16,%00001010 + !byte $25,%01001110 + !byte $19,%01001110 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $18,%01101110 + !byte $18,%10001111; + !byte $28,%10101111 + !byte $29,%11001111 + !byte $15,%11001111 + !byte $14,%11101111 + !byte $13,%00010000 + !byte $11,%00010000 + !byte $2E,%00110000 + !byte $2C,%00110000 + !byte $11,%01110000 + !byte $11,%10010001; + !byte $10,%10110001 + !byte $2F,%11010001 + !byte $0F,%11110001 + !byte $0C,%11110001 + !byte $0B,%00010010 + !byte $0B,%00110010 + !byte $33,%01010010 + !byte $0D,%10110011 + !byte $32,%11010011 + !byte $0C,%11110011 + !byte $0C,%00010100 + !byte $33,%00110100 + !byte $0A,%01010100 + !byte $0B,%01110100 + !byte $0B,%10010101; + !byte $0B,%10110101 + !byte $34,%11110101 + !byte $0A,%11110101 + !byte $0A,%00010110 + !byte $0A,%00110110 + !byte $05,%10110111 + !byte $04,%10110111 + !byte $3A,%11010111 + !byte $04,%11010111 + !byte $3B,%11110111 + !byte $3B,%00011000 + !byte $02,%01011000 + !byte $3B,%01111000 + !byte $3B,%10011001; + !byte $02,%01111000 + !byte $02,%10011001; + !byte $3B,%10111001 + !byte $04,%11011001 + !byte $3A,%11111001 + !byte $0A,%11111001 + !byte $05,%11111001 + !byte $0A,%00011010 + !byte $06,%00011010 + !byte $0A,%00111010 + !byte $0A,%01011010 + !byte $0A,%01111010 + !byte $0A,%10011011; + !byte $34,%11011011 + !byte $0A,%11011011 + !byte $0B,%11111011 + !byte $0B,%00011100 + !byte $0B,%00111100 + !byte $34,%01011100 + !byte $33,%01011100 + !byte $0C,%01111100 + !byte $0C,%10011101; + !byte $0C,%10111101 + !byte $32,%11011101 + !byte $0C,%11011101 + !byte $0D,%11111101 + !byte $31,%00011110 + !byte $10,%10111111 + !byte $0C,%10111111 + !byte $2E,%11011111 + !byte $10,%11011111 + !byte $0C,%11011111 + !byte $32,%11111111 + !byte $2D,%11111111 + !byte $11,%11111111 + !byte $0D,%11111111 + !byte $6C,%00000000 + !byte $5D,%00000000 + !byte $52,%00000000 + !byte $4C,%00000000 + !byte $6B,%00100000 + !byte $63,%00100000 + !byte $5C,%00100000 + !byte $69,%01000000 + !byte $68,%01000000 + !byte $65,%01000000 + !byte $64,%01000000 + !byte $5A,%01000000 + !byte $57,%01000000 + !byte $56,%01000000 + !byte $55,%01000000 + !byte $64,%01100000 + !byte $64,%10000001; + !byte $58,%10100001 + !byte $54,%10100001 + !byte $1F,%11000011 + !byte $1F,%11100011 + !byte $1E,%00000100 + !byte $22,%00000110 + !byte $1C,%00000110 + !byte $23,%00100110 + !byte $1B,%00100110 + !byte $1A,%00100110 + !byte $1A,%01000110 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $19,%10100111 + !byte $17,%10100111 + !byte $18,%11100111 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $28,%11101001 + !byte $16,%11101001 + !byte $17,%10101011 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $2B,%11001111 + !byte $2E,%00010000 + !byte $10,%00110000 + !byte $2E,%01110000 + !byte $2E,%10010001; + !byte $34,%11110001 + !byte $0B,%01010010 + !byte $32,%10110011 + !byte $0C,%11010011 + !byte $33,%00010100 + !byte $0B,%00110100 + !byte $34,%10110101 + !byte $34,%11010101 + !byte $0A,%11010101 + !byte $3B,%10110111 + !byte $03,%00011000 + !byte $3D,%01011000 + !byte $3D,%01111000 + !byte $3D,%10011001; + !byte $01,%01111000 + !byte $01,%10011001; + !byte $3D,%10111001 + !byte $03,%10111001 + !byte $3B,%11011001 + !byte $35,%11011001 + !byte $03,%11011001 + !byte $35,%11111001 + !byte $04,%11111001 + !byte $3A,%00011010 + !byte $39,%00011010 + !byte $38,%00011010 + !byte $35,%00011010 + !byte $07,%00011010 + !byte $04,%00011010 + !byte $35,%00111010 + !byte $0A,%10111011 + !byte $34,%11111011 + !byte $34,%00011100 + !byte $34,%01111100 + !byte $34,%10011101; + !byte $33,%01111100 + !byte $33,%10011101; + !byte $0A,%01111100 + !byte $0A,%10011101; + !byte $33,%10111101 + !byte $32,%11111101 + !byte $32,%00011110 + !byte $0D,%00011110 + !byte $0D,%00111110 + !byte $1F,%01111110 + !byte $1F,%10011111; + !byte $2F,%10111111 + !byte $2F,%11011111 + !byte $20,%11011111 + !byte $2E,%11111111 + !byte $1E,%11111111 + !byte $10,%11111111 + !byte $0C,%11111111 + !byte $72,%00000000 + !byte $71,%00000000 + !byte $6D,%00000000 + !byte $61,%00000000 + !byte $51,%00000000 + !byte $4D,%00000000 + !byte $6C,%00100000 + !byte $62,%00100000 + !byte $5D,%00100000 + !byte $53,%00100000 + !byte $52,%00100000 + !byte $6B,%01000000 + !byte $63,%01000000 + !byte $5C,%01000000 + !byte $5B,%01000000 + !byte $53,%01000000 + !byte $69,%01100000 + !byte $69,%10000001; + !byte $68,%01100000 + !byte $68,%10000001; + !byte $67,%01100000 + !byte $67,%10000001; + !byte $66,%01100000 + !byte $66,%10000001; + !byte $65,%01100000 + !byte $65,%10000001; + !byte $5A,%01100000 + !byte $5A,%10000001; + !byte $59,%01100000 + !byte $59,%10000001; + !byte $57,%01100000 + !byte $57,%10000001; + !byte $56,%01100000 + !byte $56,%10000001; + !byte $55,%01100000 + !byte $55,%10000001; + !byte $6B,%10100001 + !byte $53,%10100001 + !byte $6B,%11000001 + !byte $54,%11000001 + !byte $20,%11000011 + !byte $20,%11100011 + !byte $1E,%11100011 + !byte $21,%00100100 + !byte $22,%11100101 + !byte $1D,%11100101 + !byte $1C,%11100101 + !byte $23,%00000110 + !byte $1B,%00000110 + !byte $24,%00100110 + !byte $25,%01000110 + !byte $19,%01000110 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $17,%01100110 + !byte $17,%10000111; + !byte $28,%10100111 + !byte $27,%10100111 + !byte $26,%10100111 + !byte $26,%11000111 + !byte $18,%11000111 + !byte $17,%01001000 + !byte $16,%11001001 + !byte $1A,%00101110 + !byte $26,%01001110 + !byte $18,%01001110 + !byte $29,%01101110 + !byte $29,%10001111; + !byte $28,%01101110 + !byte $28,%10001111; + !byte $2B,%10101111 + !byte $29,%10101111 + !byte $15,%10101111 + !byte $2A,%11001111 + !byte $2B,%11101111 + !byte $13,%11101111 + !byte $2C,%00010000 + !byte $12,%00010000 + !byte $10,%00010000 + !byte $10,%01110000 + !byte $10,%10010001; + !byte $2F,%10110001 + !byte $0F,%11010001 + !byte $30,%11110001 + !byte $0B,%11110001 + !byte $34,%00010010 + !byte $32,%01110010 + !byte $32,%10010011; + !byte $0C,%10110011 + !byte $33,%11110011 + !byte $0B,%00010100 + !byte $35,%01010100 + !byte $34,%01110100 + !byte $34,%10010101; + !byte $0A,%10110101 + !byte $09,%11110101 + !byte $35,%00110110 + !byte $03,%10110111 + !byte $3B,%11010111 + !byte $03,%11110111 + !byte $3C,%00111000 + !byte $01,%01011000 + !byte $3C,%10111001 + !byte $01,%10111001 + !byte $3B,%11111001 + !byte $09,%11111001 + !byte $03,%11111001 + !byte $09,%00011010 + !byte $09,%00111010 + !byte $35,%01011010 + !byte $09,%01011010 + !byte $35,%01111010 + !byte $35,%10011011; + !byte $35,%10111011 + !byte $0A,%11111011 + !byte $09,%11111011 + !byte $0A,%00011100 + !byte $34,%00111100 + !byte $0A,%00111100 + !byte $0B,%01111100 + !byte $0B,%10011101; + !byte $0B,%10111101 + !byte $33,%11011101 + !byte $0C,%11111101 + !byte $0C,%00011110 + !byte $0F,%11011111 + !byte $33,%11111111 + !byte $2F,%11111111 + !byte $20,%11111111 + !byte $6E,%00000000 + !byte $50,%00000000 + !byte $72,%00100000 + !byte $6D,%00100000 + !byte $61,%00100000 + !byte $51,%00100000 + !byte $4D,%00100000 + !byte $6C,%01000000 + !byte $62,%01000000 + !byte $52,%01000000 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $68,%10100001 + !byte $67,%10100001 + !byte $66,%10100001 + !byte $65,%10100001 + !byte $59,%10100001 + !byte $57,%10100001 + !byte $56,%10100001 + !byte $53,%11000001 + !byte $20,%10100011 + !byte $1F,%10100011 + !byte $1E,%11000011 + !byte $21,%11100011 + !byte $21,%00000100 + !byte $22,%11000101 + !byte $1D,%11000101 + !byte $23,%11100101 + !byte $1B,%11100101 + !byte $1A,%11100101 + !byte $24,%00000110 + !byte $1A,%00000110 + !byte $25,%00100110 + !byte $28,%01100110 + !byte $28,%10000111; + !byte $26,%01100110 + !byte $26,%10000111; + !byte $16,%01100110 + !byte $16,%10000111; + !byte $18,%10100111 + !byte $28,%10101001 + !byte $29,%11001001 + !byte $28,%11001001 + !byte $28,%01101010 + !byte $28,%10001011; + !byte $25,%00101110 + !byte $27,%01001110 + !byte $2A,%10101111 + !byte $2F,%00010000 + !byte $2E,%01010000 + !byte $30,%11010001 + !byte $0E,%11110001 + !byte $0A,%11110001 + !byte $34,%00110010 + !byte $34,%01010010 + !byte $33,%11010011 + !byte $34,%00110100 + !byte $09,%01010100 + !byte $0A,%01110100 + !byte $0A,%10010101; + !byte $09,%01110100 + !byte $09,%10010101; + !byte $35,%11010101 + !byte $35,%11110101 + !byte $35,%00010110 + !byte $09,%00110110 + !byte $09,%01010110 + !byte $3C,%11110111 + !byte $3C,%00011000 + !byte $02,%00011000 + !byte $02,%00111000 + !byte $3E,%01111000 + !byte $3E,%10011001; + !byte $3E,%10111001 + !byte $02,%10111001 + !byte $3C,%11011001 + !byte $02,%11011001 + !byte $3C,%11111001 + !byte $36,%11111001 + !byte $3C,%00011010 + !byte $3B,%00011010 + !byte $36,%00011010 + !byte $03,%00011010 + !byte $3B,%00111010 + !byte $3A,%00111010 + !byte $39,%00111010 + !byte $36,%00111010 + !byte $05,%00111010 + !byte $04,%00111010 + !byte $09,%01111010 + !byte $09,%10011011; + !byte $09,%10111011 + !byte $35,%11011011 + !byte $09,%11011011 + !byte $35,%11111011 + !byte $35,%00011100 + !byte $35,%00111100 + !byte $0A,%01011100 + !byte $35,%10111101 + !byte $34,%10111101 + !byte $0B,%11011101 + !byte $33,%11111101 + !byte $33,%00011110 + !byte $0B,%00011110 + !byte $32,%00111110 + !byte $0C,%00111110 + !byte $32,%01011110 + !byte $1F,%10111111 + !byte $33,%11011111 + !byte $30,%11111111 + !byte $0F,%11111111 + !byte $73,%00000000 + !byte $6F,%00000000 + !byte $5E,%00000000 + !byte $4B,%00000000 + !byte $73,%00100000 + !byte $6E,%00100000 + !byte $5E,%00100000 + !byte $50,%00100000 + !byte $4C,%00100000 + !byte $72,%01000000 + !byte $6D,%01000000 + !byte $5D,%01000000 + !byte $51,%01000000 + !byte $4C,%01000000 + !byte $6E,%01100000 + !byte $6E,%10000001; + !byte $6C,%01100000 + !byte $6C,%10000001; + !byte $62,%01100000 + !byte $62,%10000001; + !byte $5C,%01100000 + !byte $5C,%10000001; + !byte $53,%01100000 + !byte $53,%10000001; + !byte $52,%01100000 + !byte $52,%10000001; + !byte $6A,%10100001 + !byte $69,%10100001 + !byte $64,%10100001 + !byte $5B,%10100001 + !byte $5A,%10100001 + !byte $55,%10100001 + !byte $69,%11000001 + !byte $68,%11000001 + !byte $67,%11000001 + !byte $66,%11000001 + !byte $59,%11000001 + !byte $58,%11000001 + !byte $57,%11000001 + !byte $56,%11000001 + !byte $6B,%11100001 + !byte $67,%11100001 + !byte $53,%11100001 + !byte $67,%00000010 + !byte $20,%01100010 + !byte $20,%10000011; + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $21,%10100011 + !byte $1E,%10100011 + !byte $21,%11000011 + !byte $22,%10100101 + !byte $1D,%10100101 + !byte $1C,%10100101 + !byte $25,%11000101 + !byte $23,%11000101 + !byte $1C,%11000101 + !byte $1B,%11000101 + !byte $24,%11100101 + !byte $25,%00000110 + !byte $26,%00100110 + !byte $19,%00100110 + !byte $28,%01000110 + !byte $26,%01000110 + !byte $17,%01000110 + !byte $16,%01000110 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $18,%01100110 + !byte $18,%10000111; + !byte $28,%00101000 + !byte $28,%01001000 + !byte $28,%01101000 + !byte $28,%10001001; + !byte $29,%10101001 + !byte $16,%10101001 + !byte $26,%00101110 + !byte $19,%00101110 + !byte $18,%00101110 + !byte $28,%01001110 + !byte $17,%01001110 + !byte $16,%01101110 + !byte $16,%10001111; + !byte $13,%10101111 + !byte $2F,%11101111 + !byte $2C,%11101111 + !byte $12,%11101111 + !byte $10,%11101111 + !byte $2D,%00010000 + !byte $10,%01010000 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $30,%10110001 + !byte $0F,%10110001 + !byte $34,%11010001 + !byte $0B,%11010001 + !byte $31,%11110001 + !byte $0A,%00010010 + !byte $0A,%00110010 + !byte $0C,%01110010 + !byte $0C,%10010011; + !byte $33,%10110011 + !byte $0B,%11010011 + !byte $0B,%11110011 + !byte $34,%00010100 + !byte $0A,%00110100 + !byte $36,%01010100 + !byte $35,%01110100 + !byte $35,%10010101; + !byte $35,%10110101 + !byte $09,%11010101 + !byte $09,%00010110 + !byte $36,%00110110 + !byte $36,%01010110 + !byte $03,%11010111 + !byte $02,%11110111 + !byte $3D,%00011000 + !byte $3D,%00111000 + !byte $3F,%01111000 + !byte $3F,%10011001; + !byte $00,%01111000 + !byte $00,%10011001; + !byte $3F,%10111001 + !byte $00,%10111001 + !byte $3D,%11011001 + !byte $3D,%11111001 + !byte $02,%11111001 + !byte $03,%00111010 + !byte $3C,%01011010 + !byte $36,%01011010 + !byte $36,%01111010 + !byte $36,%10011011; + !byte $36,%10111011 + !byte $35,%01011100 + !byte $0A,%10111101 + !byte $09,%10111101 + !byte $34,%11011101 + !byte $34,%11111101 + !byte $0B,%11111101 + !byte $33,%00111110 + !byte $0C,%01011110 + !byte $1F,%11011111 + !byte $0B,%11111111 + !byte $74,%00000000 + !byte $70,%00000000 + !byte $60,%00000000 + !byte $4F,%00000000 + !byte $6F,%00100000 + !byte $4B,%00100000 + !byte $73,%01000000 + !byte $6E,%01000000 + !byte $61,%01000000 + !byte $4D,%01000000 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $6C,%10100001 + !byte $63,%10100001 + !byte $5C,%10100001 + !byte $6A,%11000001 + !byte $65,%11000001 + !byte $64,%11000001 + !byte $5A,%11000001 + !byte $55,%11000001 + !byte $6C,%11100001 + !byte $5A,%11100001 + !byte $6C,%00000010 + !byte $6B,%00000010 + !byte $53,%00000010 + !byte $20,%01000010 + !byte $1F,%01000010 + !byte $1E,%01100010 + !byte $1E,%10000011; + !byte $22,%01100100 + !byte $22,%10000101; + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $25,%10100101 + !byte $23,%10100101 + !byte $24,%11000101 + !byte $1A,%11000101 + !byte $25,%11100101 + !byte $19,%00000110 + !byte $28,%00100110 + !byte $17,%00100110 + !byte $18,%01000110 + !byte $28,%00001000 + !byte $15,%01001110 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $2C,%10101111 + !byte $14,%10101111 + !byte $13,%11001111 + !byte $2F,%01010000 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $0E,%11010001 + !byte $35,%11110001 + !byte $35,%00010010 + !byte $35,%00110010 + !byte $0A,%01010010 + !byte $33,%01110010 + !byte $33,%10010011; + !byte $34,%11110011 + !byte $0A,%00010100 + !byte $36,%01110100 + !byte $36,%10010101; + !byte $36,%11110101 + !byte $36,%00010110 + !byte $3D,%11010111 + !byte $01,%00111000 + !byte $3F,%11011001 + !byte $01,%11011001 + !byte $00,%11011001 + !byte $01,%11111001 + !byte $3D,%00011010 + !byte $08,%00011010 + !byte $02,%00011010 + !byte $3C,%00111010 + !byte $08,%00111010 + !byte $06,%00111010 + !byte $02,%00111010 + !byte $3B,%01011010 + !byte $3A,%01011010 + !byte $08,%01011010 + !byte $05,%01011010 + !byte $04,%01011010 + !byte $08,%01111010 + !byte $08,%10011011; + !byte $36,%11011011 + !byte $08,%11011011 + !byte $36,%11111011 + !byte $36,%00011100 + !byte $09,%00011100 + !byte $09,%00111100 + !byte $09,%01011100 + !byte $35,%01111100 + !byte $35,%10011101; + !byte $36,%11011101 + !byte $0A,%11011101 + !byte $09,%11011101 + !byte $0A,%11111101 + !byte $34,%00011110 + !byte $34,%00111110 + !byte $0B,%00111110 + !byte $33,%01011110 + !byte $33,%01111110 + !byte $33,%10011111; + !byte $0C,%01111110 + !byte $0C,%10011111; + !byte $1F,%11111111 + !byte $4E,%00000000 + !byte $74,%00100000 + !byte $70,%00100000 + !byte $60,%00100000 + !byte $4F,%00100000 + !byte $74,%01000000 + !byte $6F,%01000000 + !byte $5E,%01000000 + !byte $50,%01000000 + !byte $4B,%01000000 + !byte $73,%01100000 + !byte $73,%10000001; + !byte $72,%01100000 + !byte $72,%10000001; + !byte $61,%01100000 + !byte $61,%10000001; + !byte $51,%01100000 + !byte $51,%10000001; + !byte $50,%01100000 + !byte $50,%10000001; + !byte $4C,%01100000 + !byte $4C,%10000001; + !byte $74,%10100001 + !byte $6D,%10100001 + !byte $62,%10100001 + !byte $5D,%10100001 + !byte $52,%10100001 + !byte $51,%10100001 + !byte $6C,%11000001 + !byte $63,%11000001 + !byte $5C,%11000001 + !byte $5B,%11000001 + !byte $52,%11000001 + !byte $6A,%11100001 + !byte $69,%11100001 + !byte $68,%11100001 + !byte $66,%11100001 + !byte $65,%11100001 + !byte $64,%11100001 + !byte $59,%11100001 + !byte $58,%11100001 + !byte $57,%11100001 + !byte $56,%11100001 + !byte $55,%11100001 + !byte $54,%11100001 + !byte $5A,%00000010 + !byte $6C,%00100010 + !byte $67,%00100010 + !byte $53,%00100010 + !byte $1F,%11100001 + !byte $20,%00100010 + !byte $1F,%00100010 + !byte $1E,%00100010 + !byte $21,%01000010 + !byte $1E,%01000010 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $22,%01000100 + !byte $1D,%01000100 + !byte $1C,%01000100 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $23,%01100100 + !byte $23,%10000101; + !byte $1C,%01100100 + !byte $1C,%10000101; + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $24,%10100101 + !byte $1B,%10100101 + !byte $1A,%10100101 + !byte $19,%11000101 + !byte $19,%11100101 + !byte $28,%00000110 + !byte $26,%00000110 + !byte $18,%00000110 + !byte $16,%00000110 + !byte $18,%00100110 + !byte $16,%00100110 + !byte $27,%01000110 + !byte $29,%01101000 + !byte $29,%10001001; + !byte $16,%01101000 + !byte $16,%10001001; + !byte $15,%01101000 + !byte $15,%10001001; + !byte $16,%00101010 + !byte $26,%00001110 + !byte $25,%00001110 + !byte $19,%00001110 + !byte $28,%00101110 + !byte $27,%00101110 + !byte $17,%00101110 + !byte $29,%01001110 + !byte $16,%01001110 + !byte $2C,%01101110 + !byte $2C,%10001111; + !byte $2A,%01101110 + !byte $2A,%10001111; + !byte $14,%01101110 + !byte $14,%10001111; + !byte $2C,%11001111 + !byte $12,%11001111 + !byte $2D,%11101111 + !byte $11,%11101111 + !byte $0F,%11101111 + !byte $0F,%00010000 + !byte $0F,%01010000 + !byte $30,%01110000 + !byte $30,%10010001; + !byte $0E,%10110001 + !byte $31,%11010001 + !byte $0D,%11010001 + !byte $0A,%11010001 + !byte $09,%11110001 + !byte $09,%00010010 + !byte $09,%00110010 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $0B,%10110011 + !byte $34,%11010011 + !byte $0A,%11010011 + !byte $0A,%11110011 + !byte $35,%00110100 + !byte $08,%01010100 + !byte $08,%01110100 + !byte $08,%10010101; + !byte $09,%10110101 + !byte $36,%11010101 + !byte $08,%00010110 + !byte $08,%00110110 + !byte $3C,%11010111 + !byte $01,%11010111 + !byte $3D,%11110111 + !byte $01,%00011000 + !byte $3E,%00111000 + !byte $3E,%01011000 + !byte $00,%01011000 + !byte $3E,%11011001 + !byte $3E,%11111001 + !byte $37,%00011010 + !byte $01,%00011010 + !byte $3D,%00111010 + !byte $37,%00111010 + !byte $37,%01011010 + !byte $03,%01011010 + !byte $08,%10111011 + !byte $08,%11111011 + !byte $08,%00011100 + !byte $36,%00111100 + !byte $36,%01011100 + !byte $09,%01111100 + !byte $09,%10011101; + !byte $35,%11011101 + !byte $08,%11011101 + !byte $36,%11111101 + !byte $08,%11111101 + !byte $0A,%00011110 + !byte $0A,%00111110 + !byte $0B,%01011110 + !byte $0B,%01111110 + !byte $0B,%10011111; + !byte $33,%10111111 + !byte $4E,%00100000 + !byte $4A,%00100000 + !byte $70,%01000000 + !byte $60,%01000000 + !byte $4F,%01000000 + !byte $4A,%01000000 + !byte $74,%01100000 + !byte $74,%10000001; + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $4A,%01100000 + !byte $4A,%10000001; + !byte $73,%10100001 + !byte $6E,%10100001 + !byte $50,%10100001 + !byte $4B,%10100001 + !byte $6D,%11000001 + !byte $62,%11000001 + !byte $51,%11000001 + !byte $5B,%11100001 + !byte $6A,%00000010 + !byte $69,%00000010 + !byte $68,%00000010 + !byte $66,%00000010 + !byte $65,%00000010 + !byte $59,%00000010 + !byte $58,%00000010 + !byte $57,%00000010 + !byte $56,%00000010 + !byte $55,%00000010 + !byte $57,%00100010 + !byte $52,%00100010 + !byte $6C,%01000010 + !byte $57,%01000010 + !byte $53,%01000010 + !byte $1F,%00000010 + !byte $1D,%00100100 + !byte $23,%01000100 + !byte $1B,%01000100 + !byte $24,%01100100 + !byte $24,%10000101; + !byte $26,%11100101 + !byte $16,%11100101 + !byte $29,%00000110 + !byte $29,%00100110 + !byte $27,%00100110 + !byte $16,%11100111 + !byte $16,%00001000 + !byte $16,%00101000 + !byte $16,%01001000 + !byte $15,%01001000 + !byte $12,%01101110 + !byte $12,%10001111; + !byte $2F,%00110000 + !byte $0E,%01110000 + !byte $0E,%10010001; + !byte $36,%11010001 + !byte $35,%11010001 + !byte $35,%01010010 + !byte $09,%01010010 + !byte $34,%10110011 + !byte $35,%00010100 + !byte $09,%00110100 + !byte $37,%01110100 + !byte $37,%10010101; + !byte $36,%10110101 + !byte $08,%11010101 + !byte $08,%11110101 + !byte $37,%00010110 + !byte $07,%00010110 + !byte $37,%01010110 + !byte $01,%11110111 + !byte $3E,%00011000 + !byte $00,%00111000 + !byte $00,%11111001 + !byte $3E,%00011010 + !byte $00,%00011010 + !byte $3E,%00111010 + !byte $07,%00111010 + !byte $01,%00111010 + !byte $3D,%01011010 + !byte $07,%01011010 + !byte $02,%01011010 + !byte $37,%01111010 + !byte $37,%10011011; + !byte $07,%01111010 + !byte $07,%10011011; + !byte $01,%01111010 + !byte $01,%10011011; + !byte $37,%10111011 + !byte $07,%10111011 + !byte $37,%11011011 + !byte $37,%11111011 + !byte $08,%00111100 + !byte $08,%01011100 + !byte $36,%01111100 + !byte $36,%10011101; + !byte $08,%01111100 + !byte $08,%10011101; + !byte $36,%10111101 + !byte $35,%11111101 + !byte $09,%11111101 + !byte $35,%00011110 + !byte $08,%00011110 + !byte $34,%01011110 + !byte $0A,%01011110 + !byte $34,%01111110 + !byte $34,%10011111; + !byte $0B,%10111111 + !byte $0B,%11011111 + !byte $5F,%00000000 + !byte $71,%00100000 + !byte $71,%01000000 + !byte $4E,%01000000 + !byte $70,%01100000 + !byte $70,%10000001; + !byte $60,%01100000 + !byte $60,%10000001; + !byte $5E,%01100000 + !byte $5E,%10000001; + !byte $4E,%01100000 + !byte $4E,%10000001; + !byte $6F,%10100001 + !byte $61,%10100001 + !byte $4F,%10100001 + !byte $4C,%10100001 + !byte $4A,%10100001 + !byte $73,%11000001 + !byte $6E,%11000001 + !byte $5D,%11000001 + !byte $50,%11000001 + !byte $4B,%11000001 + !byte $4A,%11000001 + !byte $6D,%11100001 + !byte $63,%11100001 + !byte $62,%11100001 + !byte $5C,%11100001 + !byte $52,%11100001 + !byte $51,%11100001 + !byte $64,%00000010 + !byte $5B,%00000010 + !byte $54,%00000010 + !byte $6A,%00100010 + !byte $69,%00100010 + !byte $68,%00100010 + !byte $66,%00100010 + !byte $65,%00100010 + !byte $59,%00100010 + !byte $58,%00100010 + !byte $56,%00100010 + !byte $55,%00100010 + !byte $54,%00100010 + !byte $52,%01000010 + !byte $6C,%01100010 + !byte $6C,%10000011; + !byte $57,%01100010 + !byte $57,%10000011; + !byte $52,%01100010 + !byte $52,%10000011; + !byte $20,%11100001 + !byte $21,%00000010 + !byte $20,%00000010 + !byte $1E,%00000010 + !byte $21,%00100010 + !byte $22,%00000100 + !byte $1D,%00000100 + !byte $23,%00100100 + !byte $22,%00100100 + !byte $1C,%00100100 + !byte $24,%01000100 + !byte $1A,%01100100 + !byte $1A,%10000101; + !byte $26,%10100101 + !byte $19,%10100101 + !byte $26,%11000101 + !byte $16,%11000101 + !byte $29,%11100101 + !byte $28,%11100101 + !byte $18,%11100101 + !byte $27,%00000110 + !byte $17,%00000110 + !byte $16,%11000111 + !byte $15,%00101000 + !byte $29,%01001000 + !byte $29,%00001010 + !byte $19,%11101101 + !byte $27,%00001110 + !byte $18,%00001110 + !byte $17,%00001110 + !byte $29,%00101110 + !byte $16,%00101110 + !byte $2A,%01001110 + !byte $12,%01001110 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $30,%11001111 + !byte $2D,%11001111 + !byte $0F,%11001111 + !byte $30,%11101111 + !byte $2E,%11101111 + !byte $0F,%00110000 + !byte $30,%01010000 + !byte $0E,%01010000 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $31,%10110001 + !byte $32,%11010001 + !byte $09,%11010001 + !byte $08,%11010001 + !byte $36,%11110001 + !byte $36,%00010010 + !byte $36,%00110010 + !byte $34,%01110010 + !byte $34,%10010011; + !byte $0A,%10110011 + !byte $35,%11010011 + !byte $35,%11110011 + !byte $09,%00010100 + !byte $36,%00110100 + !byte $37,%01010100 + !byte $07,%01010100 + !byte $08,%10110101 + !byte $37,%11110101 + !byte $37,%00110110 + !byte $07,%01010110 + !byte $00,%11010111 + !byte $3E,%11110111 + !byte $00,%00011000 + !byte $3F,%00111000 + !byte $3F,%01011000 + !byte $3F,%11111001 + !byte $3F,%00011010 + !byte $38,%00111010 + !byte $00,%00111010 + !byte $3E,%01011010 + !byte $38,%01011010 + !byte $01,%01011010 + !byte $3E,%01111010 + !byte $3E,%10011011; + !byte $3C,%01111010 + !byte $3C,%10011011; + !byte $38,%01111010 + !byte $38,%10011011; + !byte $03,%01111010 + !byte $03,%10011011; + !byte $02,%01111010 + !byte $02,%10011011; + !byte $07,%11011011 + !byte $07,%11111011 + !byte $37,%00011100 + !byte $37,%00111100 + !byte $37,%01011100 + !byte $08,%10111101 + !byte $37,%11111101 + !byte $37,%00011110 + !byte $09,%00011110 + !byte $35,%00111110 + !byte $09,%00111110 + !byte $35,%01011110 + !byte $0A,%01111110 + !byte $0A,%10011111; + !byte $34,%10111111 + !byte $34,%11011111 + !byte $5F,%00100000 + !byte $75,%01000000 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $71,%01100000 + !byte $71,%10000001; + !byte $75,%10100001 + !byte $70,%10100001 + !byte $5E,%10100001 + !byte $74,%11000001 + !byte $6F,%11000001 + !byte $4F,%11000001 + !byte $75,%11100001 + !byte $6E,%11100001 + !byte $5D,%11100001 + !byte $6D,%00000010 + !byte $63,%00000010 + !byte $5C,%00000010 + !byte $52,%00000010 + !byte $6B,%00100010 + !byte $64,%00100010 + !byte $5A,%00100010 + !byte $6D,%01000010 + !byte $69,%01000010 + !byte $68,%01000010 + !byte $67,%01000010 + !byte $58,%01000010 + !byte $56,%01000010 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $20,%11000001 + !byte $1F,%11000001 + !byte $1E,%11100001 + !byte $23,%00000100 + !byte $1C,%00000100 + !byte $24,%00100100 + !byte $1B,%00100100 + !byte $25,%01000100 + !byte $1A,%01000100 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $29,%11000101 + !byte $18,%11000101 + !byte $27,%11100101 + !byte $2A,%00101000 + !byte $29,%00101000 + !byte $16,%00001110 + !byte $14,%01001110 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $12,%10101111 + !byte $11,%11001111 + !byte $0E,%11101111 + !byte $0D,%10110001 + !byte $37,%11010001 + !byte $08,%11110001 + !byte $08,%00010010 + !byte $08,%00110010 + !byte $36,%01010010 + !byte $35,%10110011 + !byte $09,%11110011 + !byte $36,%00010100 + !byte $38,%01110100 + !byte $38,%10010101; + !byte $07,%01110100 + !byte $07,%10010101; + !byte $37,%10110101 + !byte $37,%11010101 + !byte $38,%00010110 + !byte $07,%00110110 + !byte $3F,%11110111 + !byte $3F,%00111010 + !byte $00,%01011010 + !byte $3D,%01111010 + !byte $3D,%10011011; + !byte $3B,%01111010 + !byte $3B,%10011011; + !byte $38,%10111011 + !byte $38,%11011011 + !byte $38,%11111011 + !byte $07,%00011100 + !byte $07,%00111100 + !byte $07,%01011100 + !byte $37,%01111100 + !byte $37,%10011101; + !byte $37,%10111101 + !byte $37,%11011101 + !byte $36,%00011110 + !byte $07,%00011110 + !byte $36,%00111110 + !byte $09,%01011110 + !byte $35,%01111110 + !byte $35,%10011111; + !byte $35,%10111111 + !byte $0A,%10111111 + !byte $0A,%11011111 + !byte $34,%11111111 + !byte $5F,%01000000 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $71,%10100001 + !byte $4E,%10100001 + !byte $49,%10100001 + !byte $75,%11000001 + !byte $70,%11000001 + !byte $61,%11000001 + !byte $5E,%11000001 + !byte $49,%11000001 + !byte $74,%11100001 + !byte $73,%11100001 + !byte $6F,%11100001 + !byte $50,%11100001 + !byte $4F,%11100001 + !byte $4B,%11100001 + !byte $4A,%11100001 + !byte $6E,%00000010 + !byte $62,%00000010 + !byte $5D,%00000010 + !byte $51,%00000010 + !byte $50,%00000010 + !byte $49,%00000010 + !byte $6D,%00100010 + !byte $63,%00100010 + !byte $5C,%00100010 + !byte $5B,%00100010 + !byte $51,%00100010 + !byte $6B,%01000010 + !byte $6A,%01000010 + !byte $66,%01000010 + !byte $65,%01000010 + !byte $64,%01000010 + !byte $5A,%01000010 + !byte $59,%01000010 + !byte $55,%01000010 + !byte $54,%01000010 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $68,%01100010 + !byte $68,%10000011; + !byte $67,%01100010 + !byte $67,%10000011; + !byte $58,%01100010 + !byte $58,%10000011; + !byte $56,%01100010 + !byte $56,%10000011; + !byte $6D,%10100011 + !byte $6C,%10100011 + !byte $68,%10100011 + !byte $57,%10100011 + !byte $52,%10100011 + !byte $52,%11000011 + !byte $1F,%01000000 + !byte $20,%10100001 + !byte $1F,%10100001 + !byte $21,%11000001 + !byte $1E,%11000001 + !byte $21,%11100001 + !byte $1D,%11000011 + !byte $23,%11100011 + !byte $22,%11100011 + !byte $1D,%11100011 + !byte $1C,%11100011 + !byte $1B,%11100011 + !byte $24,%00000100 + !byte $1B,%00000100 + !byte $19,%00000100 + !byte $25,%00100100 + !byte $1A,%00100100 + !byte $19,%01000100 + !byte $26,%01100100 + !byte $26,%10000101; + !byte $2A,%10100101 + !byte $29,%10100101 + !byte $27,%10100101 + !byte $18,%10100101 + !byte $16,%10100101 + !byte $27,%11000101 + !byte $15,%11000101 + !byte $17,%11100101 + !byte $16,%10100111 + !byte $29,%11000111 + !byte $29,%11100111 + !byte $2A,%00001000 + !byte $29,%00001000 + !byte $15,%00001000 + !byte $29,%11101001 + !byte $27,%11101101 + !byte $26,%11101101 + !byte $18,%11101101 + !byte $28,%00001110 + !byte $2A,%00101110 + !byte $15,%00101110 + !byte $2D,%01001110 + !byte $2B,%01001110 + !byte $2D,%10101111 + !byte $2E,%11001111 + !byte $0E,%11001111 + !byte $30,%00110000 + !byte $31,%01010000 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $32,%10110001 + !byte $0C,%11010001 + !byte $37,%11110001 + !byte $37,%00010010 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $0A,%01110010 + !byte $0A,%10010011; + !byte $09,%11010011 + !byte $36,%11110011 + !byte $08,%00110100 + !byte $38,%01010100 + !byte $07,%11010101 + !byte $07,%11110101 + !byte $06,%00010110 + !byte $38,%00110110 + !byte $38,%01010110 + !byte $3F,%00011000 + !byte $3F,%01011010 + !byte $06,%01011010 + !byte $06,%01111010 + !byte $06,%10011011; + !byte $00,%01111010 + !byte $00,%10011011; + !byte $3F,%10111011 + !byte $06,%10111011 + !byte $06,%11011011 + !byte $38,%00011100 + !byte $38,%00111100 + !byte $38,%01011100 + !byte $07,%01111100 + !byte $07,%10011101; + !byte $07,%10111101 + !byte $38,%00011110 + !byte $38,%00111110 + !byte $07,%00111110 + !byte $36,%01011110 + !byte $09,%01111110 + !byte $09,%10011111; + !byte $36,%10111111 + !byte $35,%11011111 + !byte $0A,%11111111 + !byte $49,%01100000 + !byte $49,%10000001; + !byte $76,%10100001 + !byte $72,%10100001 + !byte $60,%10100001 + !byte $4D,%10100001 + !byte $76,%11000001 + !byte $71,%11000001 + !byte $4E,%11000001 + !byte $70,%11100001 + !byte $61,%11100001 + !byte $4E,%11100001 + !byte $49,%11100001 + !byte $75,%00000010 + !byte $74,%00000010 + !byte $6F,%00000010 + !byte $4A,%00000010 + !byte $6E,%00100010 + !byte $4F,%00100010 + !byte $5B,%01000010 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $6A,%01100010 + !byte $6A,%10000011; + !byte $66,%01100010 + !byte $66,%10000011; + !byte $59,%01100010 + !byte $59,%10000011; + !byte $55,%01100010 + !byte $55,%10000011; + !byte $54,%01100010 + !byte $54,%10000011; + !byte $65,%10100011 + !byte $6D,%11000011 + !byte $68,%11000011 + !byte $57,%11000011 + !byte $1F,%00100000 + !byte $20,%01100000 + !byte $20,%10000001; + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $1E,%10100001 + !byte $1D,%11100001 + !byte $1D,%00000010 + !byte $22,%11000011 + !byte $1C,%11000011 + !byte $24,%11100011 + !byte $19,%11100011 + !byte $25,%00000100 + !byte $1A,%00000100 + !byte $19,%00100100 + !byte $26,%01000100 + !byte $18,%01000100 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $18,%01100100 + !byte $18,%10000101; + !byte $15,%10100101 + !byte $28,%11000101 + !byte $17,%11000101 + !byte $14,%00001000 + !byte $15,%11101001 + !byte $16,%01001010 + !byte $17,%11101101 + !byte $14,%00101110 + !byte $13,%01001110 + !byte $31,%10101111 + !byte $11,%10101111 + !byte $31,%11001111 + !byte $10,%11001111 + !byte $31,%11101111 + !byte $30,%00010000 + !byte $0E,%00110000 + !byte $0D,%01010000 + !byte $32,%01110000 + !byte $32,%10010001; + !byte $0C,%10110001 + !byte $07,%11010001 + !byte $07,%11110001 + !byte $07,%00010010 + !byte $37,%00110010 + !byte $08,%01010010 + !byte $09,%10110011 + !byte $08,%00010100 + !byte $06,%01010100 + !byte $06,%01110100 + !byte $06,%10010101; + !byte $07,%10110101 + !byte $38,%11110101 + !byte $06,%00110110 + !byte $06,%01010110 + !byte $06,%01110110 + !byte $06,%10010111; + !byte $00,%11110111 + !byte $39,%01011010 + !byte $3F,%01111010 + !byte $3F,%10011011; + !byte $39,%01111010 + !byte $39,%10011011; + !byte $3E,%10111011 + !byte $3D,%10111011 + !byte $3C,%10111011 + !byte $39,%10111011 + !byte $02,%10111011 + !byte $01,%10111011 + !byte $00,%10111011 + !byte $06,%11111011 + !byte $06,%00011100 + !byte $06,%00111100 + !byte $06,%01011100 + !byte $38,%01111100 + !byte $38,%10011101; + !byte $06,%01111100 + !byte $06,%10011101; + !byte $38,%10111101 + !byte $07,%11011101 + !byte $07,%11111101 + !byte $37,%00111110 + !byte $08,%00111110 + !byte $06,%00111110 + !byte $38,%01011110 + !byte $08,%01011110 + !byte $36,%01111110 + !byte $36,%10011111; + !byte $08,%01111110 + !byte $08,%10011111; + !byte $09,%10111111 + !byte $09,%11011111 + !byte $08,%11011111 + !byte $35,%11111111 + !byte $09,%11111111 + !byte $4A,%00000000 + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $72,%11000001 + !byte $60,%11000001 + !byte $4D,%11000001 + !byte $48,%11000001 + !byte $76,%11100001 + !byte $71,%11100001 + !byte $5E,%11100001 + !byte $4D,%11100001 + !byte $76,%00000010 + !byte $70,%00000010 + !byte $61,%00000010 + !byte $4F,%00000010 + !byte $4E,%00000010 + !byte $75,%00100010 + !byte $6F,%00100010 + !byte $62,%00100010 + !byte $5D,%00100010 + !byte $50,%00100010 + !byte $4A,%00100010 + !byte $49,%00100010 + !byte $6E,%01000010 + !byte $63,%01000010 + !byte $5C,%01000010 + !byte $51,%01000010 + !byte $50,%01000010 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $64,%01100010 + !byte $64,%10000011; + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $5A,%01100010 + !byte $5A,%10000011; + !byte $53,%01100010 + !byte $53,%10000011; + !byte $6B,%10100011 + !byte $6A,%10100011 + !byte $69,%10100011 + !byte $67,%10100011 + !byte $66,%10100011 + !byte $59,%10100011 + !byte $58,%10100011 + !byte $56,%10100011 + !byte $55,%10100011 + !byte $54,%10100011 + !byte $53,%10100011 + !byte $65,%11000011 + !byte $51,%11000011 + !byte $6D,%11100011 + !byte $68,%11100011 + !byte $56,%11100011 + !byte $52,%11100011 + !byte $51,%11100011 + !byte $1F,%00000000 + !byte $20,%01000000 + !byte $1E,%01000000 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $1E,%01100000 + !byte $1E,%10000001; + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $21,%10100001 + !byte $1D,%11000001 + !byte $22,%10100011 + !byte $1D,%10100011 + !byte $1C,%10100011 + !byte $24,%11000011 + !byte $23,%11000011 + !byte $1B,%11000011 + !byte $19,%11000011 + !byte $25,%11100011 + !byte $1A,%11100011 + !byte $26,%00100100 + !byte $18,%00100100 + !byte $29,%01000100 + !byte $15,%01000100 + !byte $27,%01100100 + !byte $27,%10000101; + !byte $17,%01100100 + !byte $17,%10000101; + !byte $16,%01100100 + !byte $16,%10000101; + !byte $15,%01100100 + !byte $15,%10000101; + !byte $28,%10100101 + !byte $17,%10100101 + !byte $29,%01100110 + !byte $29,%10000111; + !byte $29,%10100111 + !byte $2A,%11100111 + !byte $15,%11100111 + !byte $14,%11100111 + !byte $15,%11001001 + !byte $26,%11001101 + !byte $18,%11001101 + !byte $28,%11101101 + !byte $16,%11101101 + !byte $29,%00001110 + !byte $15,%00001110 + !byte $2D,%00101110 + !byte $2B,%00101110 + !byte $13,%00101110 + !byte $11,%00101110 + !byte $2C,%01001110 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $2E,%10101111 + !byte $10,%10101111 + !byte $0E,%10101111 + !byte $2F,%11001111 + !byte $0D,%11001111 + !byte $0E,%00010000 + !byte $31,%00110000 + !byte $0C,%01110000 + !byte $0C,%10010001; + !byte $38,%10110001 + !byte $36,%10110001 + !byte $33,%10110001 + !byte $08,%10110001 + !byte $33,%11010001 + !byte $07,%00110010 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $36,%10110011 + !byte $36,%11010011 + !byte $08,%11010011 + !byte $08,%11110011 + !byte $37,%00110100 + !byte $07,%00110100 + !byte $38,%11010101 + !byte $06,%11110101 + !byte $39,%01110110 + !byte $39,%10010111; + !byte $3E,%11010111 + !byte $05,%01111010 + !byte $05,%10011011; + !byte $05,%10111011 + !byte $39,%11011011 + !byte $05,%11011011 + !byte $39,%11111011 + !byte $05,%11111011 + !byte $39,%00011100 + !byte $06,%10111101 + !byte $38,%11011101 + !byte $38,%11111101 + !byte $37,%01011110 + !byte $06,%01011110 + !byte $08,%10111111 + !byte $36,%11011111 + !byte $75,%00000000 + !byte $49,%00000000 + !byte $48,%10100001 + !byte $4C,%11000001 + !byte $72,%11100001 + !byte $60,%11100001 + !byte $48,%11100001 + !byte $71,%00000010 + !byte $48,%00000010 + !byte $76,%00100010 + !byte $74,%00100010 + !byte $70,%00100010 + !byte $61,%00100010 + !byte $4E,%00100010 + !byte $6F,%01000010 + !byte $62,%01000010 + !byte $4F,%01000010 + !byte $48,%01000010 + !byte $6E,%01100010 + !byte $6E,%10000011; + !byte $63,%01100010 + !byte $63,%10000011; + !byte $5C,%01100010 + !byte $5C,%10000011; + !byte $51,%01100010 + !byte $51,%10000011; + !byte $64,%10100011 + !byte $5A,%10100011 + !byte $6A,%11000011 + !byte $69,%11000011 + !byte $67,%11000011 + !byte $66,%11000011 + !byte $58,%11000011 + !byte $56,%11000011 + !byte $55,%11000011 + !byte $6D,%00000100 + !byte $68,%00000100 + !byte $56,%00000100 + !byte $51,%00000100 + !byte $20,%00100000 + !byte $1D,%10100001 + !byte $22,%01100010 + !byte $22,%10000011; + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $1C,%01100010 + !byte $1C,%10000011; + !byte $23,%10100011 + !byte $1B,%10100011 + !byte $1A,%11000011 + !byte $26,%00000100 + !byte $2A,%01000100 + !byte $27,%01000100 + !byte $17,%01000100 + !byte $14,%01000100 + !byte $2A,%01100100 + !byte $2A,%10000101; + !byte $29,%01000110 + !byte $15,%10100111 + !byte $15,%11000111 + !byte $14,%11000111 + !byte $27,%11001101 + !byte $29,%11101101 + !byte $2A,%00001110 + !byte $11,%01001110 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $0D,%10101111 + !byte $0D,%11101111 + !byte $0D,%00110000 + !byte $32,%01010000 + !byte $37,%10110001 + !byte $06,%10110001 + !byte $38,%11110001 + !byte $38,%00010010 + !byte $37,%00010100 + !byte $07,%00010100 + !byte $39,%01010100 + !byte $39,%01110100 + !byte $39,%10010101; + !byte $05,%01110100 + !byte $05,%10010101; + !byte $38,%10110101 + !byte $06,%11010101 + !byte $39,%00110110 + !byte $39,%01010110 + !byte $05,%01110110 + !byte $05,%10010111; + !byte $3F,%11011011 + !byte $3E,%11011011 + !byte $3D,%11011011 + !byte $01,%11011011 + !byte $00,%11011011 + !byte $05,%00011100 + !byte $39,%00111100 + !byte $05,%00111100 + !byte $39,%01011100 + !byte $39,%01111100 + !byte $39,%10011101; + !byte $39,%10111101 + !byte $06,%11011101 + !byte $06,%11111101 + !byte $06,%00011110 + !byte $39,%01011110 + !byte $07,%01011110 + !byte $39,%01111110 + !byte $39,%10011111; + !byte $37,%01111110 + !byte $37,%10011111; + !byte $07,%01111110 + !byte $07,%10011111; + !byte $06,%01111110 + !byte $06,%10011111; + !byte $37,%10111111 + !byte $37,%11111111 + !byte $36,%11111111 + !byte $08,%11111111 + !byte $76,%00000000 + !byte $75,%00100000 + !byte $49,%00100000 + !byte $5F,%10100001 + !byte $4C,%11100001 + !byte $72,%00000010 + !byte $60,%00000010 + !byte $5E,%00000010 + !byte $4D,%00000010 + !byte $4C,%00000010 + !byte $71,%00100010 + !byte $4D,%00100010 + !byte $48,%00100010 + !byte $76,%01000010 + !byte $75,%01000010 + !byte $74,%01000010 + !byte $70,%01000010 + !byte $61,%01000010 + !byte $5D,%01000010 + !byte $4E,%01000010 + !byte $4A,%01000010 + !byte $49,%01000010 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $62,%01100010 + !byte $62,%10000011; + !byte $50,%01100010 + !byte $50,%10000011; + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $6E,%10100011 + !byte $63,%10100011 + !byte $5C,%10100011 + !byte $5B,%10100011 + !byte $51,%10100011 + !byte $50,%10100011 + !byte $6C,%11000011 + !byte $6B,%11000011 + !byte $64,%11000011 + !byte $5A,%11000011 + !byte $59,%11000011 + !byte $54,%11000011 + !byte $53,%11000011 + !byte $6A,%11100011 + !byte $69,%11100011 + !byte $67,%11100011 + !byte $66,%11100011 + !byte $58,%11100011 + !byte $57,%11100011 + !byte $55,%11100011 + !byte $54,%11100011 + !byte $59,%00000100 + !byte $6D,%00100100 + !byte $68,%00100100 + !byte $56,%00100100 + !byte $51,%00100100 + !byte $51,%01000100 + !byte $20,%00000000 + !byte $1E,%00000000 + !byte $21,%00100000 + !byte $1E,%00100000 + !byte $1D,%00100000 + !byte $21,%01000000 + !byte $22,%01000010 + !byte $1D,%01000010 + !byte $1C,%01000010 + !byte $24,%01100010 + !byte $24,%10000011; + !byte $23,%01100010 + !byte $23,%10000011; + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $25,%10100011 + !byte $24,%10100011 + !byte $1A,%10100011 + !byte $19,%10100011 + !byte $25,%11000011 + !byte $26,%11100011 + !byte $18,%11100011 + !byte $27,%00000100 + !byte $18,%00000100 + !byte $2A,%00100100 + !byte $29,%00100100 + !byte $27,%00100100 + !byte $16,%00100100 + !byte $15,%00100100 + !byte $14,%00100100 + !byte $16,%01000100 + !byte $28,%01100100 + !byte $28,%10000101; + !byte $15,%00100110 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $2B,%11000111 + !byte $2A,%11000111 + !byte $2A,%10101001 + !byte $15,%10101001 + !byte $26,%10101101 + !byte $19,%10101101 + !byte $28,%11001101 + !byte $17,%11001101 + !byte $2B,%11101101 + !byte $2A,%11101101 + !byte $15,%11101101 + !byte $2B,%00001110 + !byte $14,%00001110 + !byte $2E,%00101110 + !byte $2C,%00101110 + !byte $32,%01101110 + !byte $32,%10001111; + !byte $2E,%01101110 + !byte $2E,%10001111; + !byte $2F,%10101111 + !byte $31,%00010000 + !byte $32,%00110000 + !byte $33,%01010000 + !byte $0C,%01010000 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $39,%10110001 + !byte $0B,%10110001 + !byte $07,%10110001 + !byte $38,%11010001 + !byte $06,%11110001 + !byte $38,%00110010 + !byte $36,%01110010 + !byte $36,%10010011; + !byte $37,%10110011 + !byte $08,%10110011 + !byte $37,%11010011 + !byte $37,%11110011 + !byte $38,%00110100 + !byte $05,%01010100 + !byte $06,%10110101 + !byte $39,%11010101 + !byte $39,%11110101 + !byte $39,%00010110 + !byte $05,%00110110 + !byte $05,%01010110 + !byte $3A,%01110110 + !byte $3A,%10010111; + !byte $3A,%01111010 + !byte $3A,%10011011; + !byte $3A,%10111011 + !byte $3A,%11011011 + !byte $3A,%11111011 + !byte $3A,%00011100 + !byte $3A,%00111100 + !byte $05,%01011100 + !byte $05,%01111100 + !byte $05,%10011101; + !byte $39,%11011101 + !byte $39,%11111101 + !byte $38,%01111110 + !byte $38,%10011111; + !byte $05,%01111110 + !byte $05,%10011111; + !byte $07,%10111111 + !byte $37,%11011111 + !byte $48,%00000000 + !byte $76,%00100000 + !byte $49,%01000000 + !byte $5F,%11000001 + !byte $77,%11100001 + !byte $77,%00000010 + !byte $73,%00000010 + !byte $47,%00000010 + !byte $77,%00100010 + !byte $72,%00100010 + !byte $5E,%00100010 + !byte $77,%01000010 + !byte $71,%01000010 + !byte $4D,%01000010 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $76,%01100010 + !byte $76,%10000011; + !byte $70,%01100010 + !byte $70,%10000011; + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $49,%01100010 + !byte $49,%10000011; + !byte $6F,%10100011 + !byte $4E,%10100011 + !byte $6E,%11000011 + !byte $5B,%11000011 + !byte $6C,%11100011 + !byte $6B,%11100011 + !byte $65,%11100011 + !byte $5A,%11100011 + !byte $59,%11100011 + !byte $53,%11100011 + !byte $6E,%00000100 + !byte $6E,%00100100 + !byte $21,%00000000 + !byte $1D,%01000000 + !byte $22,%00100010 + !byte $1D,%00100010 + !byte $24,%01000010 + !byte $23,%01000010 + !byte $1B,%01000010 + !byte $26,%01100010 + !byte $26,%10000011; + !byte $1A,%01100010 + !byte $1A,%10000011; + !byte $26,%11000011 + !byte $2A,%00000100 + !byte $29,%00000100 + !byte $15,%00000100 + !byte $17,%00100100 + !byte $28,%01000100 + !byte $15,%01000110 + !byte $2B,%10100111 + !byte $14,%10100111 + !byte $18,%10101101 + !byte $16,%11001101 + !byte $2E,%00001110 + !byte $12,%00101110 + !byte $32,%10101111 + !byte $0F,%10101111 + !byte $32,%11001111 + !byte $0D,%00010000 + !byte $0B,%01010000 + !byte $34,%10110001 + !byte $06,%11010001 + !byte $06,%00010010 + !byte $08,%01110010 + !byte $08,%10010011; + !byte $07,%11010011 + !byte $07,%11110011 + !byte $38,%00010100 + !byte $3A,%01110100 + !byte $3A,%10010101; + !byte $39,%10110101 + !byte $05,%11110101 + !byte $05,%00010110 + !byte $3A,%00110110 + !byte $04,%00110110 + !byte $3A,%01010110 + !byte $04,%01111010 + !byte $04,%10011011; + !byte $04,%10111011 + !byte $04,%11011011 + !byte $3F,%11111011 + !byte $04,%11111011 + !byte $3A,%01011100 + !byte $3A,%01111100 + !byte $3A,%10011101; + !byte $3A,%10111101 + !byte $05,%10111101 + !byte $3A,%11011101 + !byte $05,%11011101 + !byte $05,%11111101 + !byte $39,%00011110 + !byte $39,%00111110 + !byte $3A,%01111110 + !byte $3A,%10011111; + !byte $3A,%10111111 + !byte $38,%10111111 + !byte $05,%10111111 + !byte $38,%11011111 + !byte $07,%11011111 + !byte $07,%11111111 + !byte $77,%00000000 + !byte $47,%00000000 + !byte $48,%00100000 + !byte $76,%01000000 + !byte $76,%01100000 + !byte $76,%10000001; + !byte $5F,%11100001 + !byte $4B,%00000010 + !byte $73,%00100010 + !byte $60,%00100010 + !byte $4C,%00100010 + !byte $47,%00100010 + !byte $72,%01000010 + !byte $5E,%01000010 + !byte $4C,%01000010 + !byte $47,%01000010 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $72,%01100010 + !byte $72,%10000011; + !byte $71,%01100010 + !byte $71,%10000011; + !byte $61,%01100010 + !byte $61,%10000011; + !byte $4E,%01100010 + !byte $4E,%10000011; + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $48,%01100010 + !byte $48,%10000011; + !byte $76,%10100011 + !byte $70,%10100011 + !byte $62,%10100011 + !byte $5D,%10100011 + !byte $4F,%10100011 + !byte $49,%10100011 + !byte $48,%10100011 + !byte $71,%11000011 + !byte $6F,%11000011 + !byte $63,%11000011 + !byte $5C,%11000011 + !byte $50,%11000011 + !byte $47,%11000011 + !byte $6E,%11100011 + !byte $64,%11100011 + !byte $5B,%11100011 + !byte $6C,%00000100 + !byte $6B,%00000100 + !byte $6A,%00000100 + !byte $69,%00000100 + !byte $67,%00000100 + !byte $66,%00000100 + !byte $65,%00000100 + !byte $58,%00000100 + !byte $57,%00000100 + !byte $55,%00000100 + !byte $54,%00000100 + !byte $53,%00000100 + !byte $52,%00000100 + !byte $59,%00100100 + !byte $6E,%01000100 + !byte $6D,%01000100 + !byte $56,%01000100 + !byte $56,%01100100 + !byte $56,%10000101; + !byte $22,%00000010 + !byte $24,%00100010 + !byte $23,%00100010 + !byte $1C,%00100010 + !byte $1B,%00100010 + !byte $26,%01000010 + !byte $1A,%01000010 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $19,%01100010 + !byte $19,%10000011; + !byte $26,%10100011 + !byte $27,%11000011 + !byte $18,%11000011 + !byte $2A,%11100011 + !byte $27,%11100011 + !byte $17,%11100011 + !byte $15,%11100011 + !byte $28,%00000100 + !byte $17,%00000100 + !byte $14,%00000100 + !byte $28,%00100100 + !byte $15,%11100101 + !byte $15,%00000110 + !byte $2A,%01000110 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $14,%01100110 + !byte $14,%10000111; + !byte $2A,%10100111 + !byte $2A,%01101000 + !byte $2A,%10001001; + !byte $26,%01101100 + !byte $26,%10001101; + !byte $28,%10101101 + !byte $27,%10101101 + !byte $17,%10101101 + !byte $29,%11001101 + !byte $15,%11001101 + !byte $14,%11101101 + !byte $2C,%00001110 + !byte $13,%00001110 + !byte $2E,%01001110 + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $10,%01101110 + !byte $10,%10001111; + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $30,%10101111 + !byte $32,%00010000 + !byte $0C,%00110000 + !byte $34,%01110000 + !byte $34,%10010001; + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $05,%10110001 + !byte $39,%11010001 + !byte $39,%11110001 + !byte $39,%00010010 + !byte $06,%00110010 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $07,%10110011 + !byte $38,%11110011 + !byte $06,%00110100 + !byte $3A,%01010100 + !byte $04,%01110100 + !byte $04,%10010101; + !byte $05,%11010101 + !byte $3A,%11110101 + !byte $3A,%00010110 + !byte $04,%01110110 + !byte $04,%10010111; + !byte $3B,%10111011 + !byte $3B,%11011011 + !byte $3B,%11111011 + !byte $04,%00011100 + !byte $04,%00111100 + !byte $04,%01011100 + !byte $3A,%11111101 + !byte $05,%00011110 + !byte $05,%00111110 + !byte $06,%10111111 + !byte $38,%11111111 + !byte $77,%00100000 + !byte $77,%01000000 + !byte $48,%01000000 + !byte $48,%01100000 + !byte $48,%10000001; + !byte $78,%00100010 + !byte $4B,%00100010 + !byte $78,%01000010 + !byte $73,%01000010 + !byte $5E,%01100010 + !byte $5E,%10000011; + !byte $47,%01100010 + !byte $47,%10000011; + !byte $77,%10100011 + !byte $71,%10100011 + !byte $4D,%10100011 + !byte $47,%10100011 + !byte $78,%11000011 + !byte $70,%11000011 + !byte $62,%11000011 + !byte $4F,%11000011 + !byte $6F,%11100011 + !byte $63,%11100011 + !byte $5C,%11100011 + !byte $50,%11100011 + !byte $64,%00000100 + !byte $5A,%00000100 + !byte $6B,%00100100 + !byte $6A,%00100100 + !byte $69,%00100100 + !byte $67,%00100100 + !byte $66,%00100100 + !byte $58,%00100100 + !byte $57,%00100100 + !byte $55,%00100100 + !byte $54,%00100100 + !byte $53,%00100100 + !byte $59,%01000100 + !byte $50,%01000100 + !byte $6E,%01100100 + !byte $6E,%10000101; + !byte $69,%01100100 + !byte $69,%10000101; + !byte $51,%01100100 + !byte $51,%10000101; + !byte $1D,%00000000 + !byte $24,%00000010 + !byte $23,%00000010 + !byte $1C,%00000010 + !byte $1B,%00000010 + !byte $26,%00100010 + !byte $1A,%00100010 + !byte $25,%01000010 + !byte $19,%01000010 + !byte $27,%10100011 + !byte $18,%10100011 + !byte $17,%11000011 + !byte $29,%11100011 + !byte $14,%11100011 + !byte $2A,%11100101 + !byte $2A,%01100110 + !byte $2A,%10000111; + !byte $13,%01100110 + !byte $13,%10000111; + !byte $2A,%01001000 + !byte $18,%01101100 + !byte $18,%10001101; + !byte $16,%10101101 + !byte $13,%11101101 + !byte $12,%00001110 + !byte $10,%00001110 + !byte $10,%01001110 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $0C,%01101110 + !byte $0C,%10001111; + !byte $0C,%10101111 + !byte $0C,%11001111 + !byte $0C,%00010000 + !byte $3A,%10110001 + !byte $0A,%10110001 + !byte $05,%11010001 + !byte $05,%11110001 + !byte $05,%00010010 + !byte $39,%00110010 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $38,%11010011 + !byte $06,%11110011 + !byte $06,%00010100 + !byte $05,%10110101 + !byte $04,%00010110 + !byte $3B,%00110110 + !byte $03,%00110110 + !byte $04,%01010110 + !byte $03,%10111011 + !byte $03,%11011011 + !byte $3E,%11111011 + !byte $03,%11111011 + !byte $00,%11111011 + !byte $3B,%00011100 + !byte $03,%00011100 + !byte $3B,%00111100 + !byte $3B,%01011100 + !byte $3B,%01111100 + !byte $3B,%10011101; + !byte $04,%01111100 + !byte $04,%10011101; + !byte $04,%10111101 + !byte $04,%11011101 + !byte $3B,%11111101 + !byte $04,%11111101 + !byte $3A,%00011110 + !byte $04,%00011110 + !byte $3A,%00111110 + !byte $05,%01011110 + !byte $39,%10111111 + !byte $04,%10111111 + !byte $3A,%11011111 + !byte $06,%11011111 + !byte $04,%11011111 + !byte $06,%11111111 + !byte $78,%00000000 + !byte $46,%00000000 + !byte $78,%00100000 + !byte $47,%00100000 + !byte $47,%01000000 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $47,%01100000 + !byte $47,%10000001; + !byte $5F,%00000010 + !byte $60,%01000010 + !byte $4B,%01000010 + !byte $78,%01100010 + !byte $78,%10000011; + !byte $73,%01100010 + !byte $73,%10000011; + !byte $4C,%01100010 + !byte $4C,%10000011; + !byte $46,%01100010 + !byte $46,%10000011; + !byte $78,%10100011 + !byte $75,%10100011 + !byte $72,%10100011 + !byte $61,%10100011 + !byte $4C,%10100011 + !byte $77,%11000011 + !byte $76,%11000011 + !byte $5D,%11000011 + !byte $4E,%11000011 + !byte $4D,%11000011 + !byte $48,%11000011 + !byte $78,%11100011 + !byte $70,%11100011 + !byte $62,%11100011 + !byte $4F,%11100011 + !byte $4E,%11100011 + !byte $46,%11100011 + !byte $6F,%00000100 + !byte $63,%00000100 + !byte $5B,%00000100 + !byte $50,%00000100 + !byte $4F,%00000100 + !byte $6C,%00100100 + !byte $65,%00100100 + !byte $64,%00100100 + !byte $5A,%00100100 + !byte $52,%00100100 + !byte $6C,%01000100 + !byte $6B,%01000100 + !byte $6A,%01000100 + !byte $69,%01000100 + !byte $68,%01000100 + !byte $67,%01000100 + !byte $66,%01000100 + !byte $58,%01000100 + !byte $57,%01000100 + !byte $55,%01000100 + !byte $54,%01000100 + !byte $53,%01000100 + !byte $50,%01100100 + !byte $50,%10000101; + !byte $6E,%10100101 + !byte $69,%10100101 + !byte $56,%10100101 + !byte $51,%10100101 + !byte $50,%10100101 + !byte $24,%11100001 + !byte $23,%11100001 + !byte $22,%11100001 + !byte $1C,%11100001 + !byte $1B,%11100001 + !byte $26,%00000010 + !byte $1A,%00000010 + !byte $25,%00100010 + !byte $19,%00100010 + !byte $18,%01000010 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $18,%01100010 + !byte $18,%10000011; + !byte $2A,%10100011 + !byte $17,%10100011 + !byte $2A,%11000011 + !byte $29,%11000011 + !byte $15,%11000011 + !byte $14,%11000011 + !byte $28,%11100011 + !byte $16,%00000100 + !byte $2A,%11000101 + !byte $14,%11000101 + !byte $2A,%00000110 + !byte $2A,%00100110 + !byte $2B,%01000110 + !byte $14,%01000110 + !byte $13,%01000110 + !byte $14,%01001000 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $17,%01101100 + !byte $17,%10001101; + !byte $29,%10101101 + !byte $2A,%11001101 + !byte $14,%11001101 + !byte $10,%11101101 + !byte $2D,%00001110 + !byte $2F,%01001110 + !byte $30,%01101110 + !byte $30,%10001111; + !byte $32,%11101111 + !byte $33,%00110000 + !byte $0B,%00110000 + !byte $0A,%00110000 + !byte $34,%01010000 + !byte $3A,%01110000 + !byte $3A,%10010001; + !byte $38,%01110000 + !byte $38,%10010001; + !byte $0A,%01110000 + !byte $0A,%10010001; + !byte $06,%01110000 + !byte $06,%10010001; + !byte $04,%01110000 + !byte $04,%10010001; + !byte $35,%10110001 + !byte $3A,%00010010 + !byte $05,%00110010 + !byte $37,%01010010 + !byte $07,%01010010 + !byte $38,%10110011 + !byte $06,%11010011 + !byte $39,%00010100 + !byte $39,%00110100 + !byte $05,%00110100 + !byte $3B,%01010100 + !byte $3B,%01110100 + !byte $3B,%10010101; + !byte $03,%01110100 + !byte $03,%10010101; + !byte $3A,%10110101 + !byte $3A,%11010101 + !byte $04,%11010101 + !byte $04,%11110101 + !byte $3B,%01010110 + !byte $3B,%01110110 + !byte $3B,%10010111; + !byte $03,%00111100 + !byte $03,%01011100 + !byte $03,%01111100 + !byte $03,%10011101; + !byte $3B,%10111101 + !byte $3B,%11011101 + !byte $04,%00111110 + !byte $3A,%01011110 + !byte $3B,%11011111 + !byte $39,%11011111 + !byte $05,%11011111 + !byte $39,%11111111 + !byte $46,%00100000 + !byte $77,%10100001 + !byte $46,%00100010 + !byte $46,%01000010 + !byte $60,%01100010 + !byte $60,%10000011; + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $73,%10100011 + !byte $5E,%10100011 + !byte $46,%10100011 + !byte $72,%11000011 + !byte $61,%11000011 + !byte $46,%11000011 + !byte $77,%11100011 + !byte $71,%11100011 + !byte $4D,%11100011 + !byte $48,%11100011 + !byte $47,%11100011 + !byte $70,%00000100 + !byte $5C,%00000100 + !byte $46,%00000100 + !byte $6F,%00100100 + !byte $5B,%00100100 + !byte $50,%00100100 + !byte $65,%01000100 + !byte $52,%01000100 + !byte $6A,%01100100 + !byte $6A,%10000101; + !byte $68,%01100100 + !byte $68,%10000101; + !byte $57,%01100100 + !byte $57,%10000101; + !byte $55,%01100100 + !byte $55,%10000101; + !byte $54,%01100100 + !byte $54,%10000101; + !byte $6F,%10100101 + !byte $6E,%11000101 + !byte $69,%11000101 + !byte $50,%11000101 + !byte $23,%11000001 + !byte $22,%11000001 + !byte $1C,%11000001 + !byte $25,%00000010 + !byte $18,%00000010 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $15,%10100011 + !byte $14,%10100011 + !byte $28,%11000011 + !byte $16,%11100011 + !byte $14,%00101000 + !byte $15,%10101101 + !byte $2C,%11101101 + !byte $11,%00001110 + !byte $10,%00101110 + !byte $33,%01001110 + !byte $33,%01101110 + !byte $33,%10001111; + !byte $0E,%01101110 + !byte $0E,%10001111; + !byte $33,%10101111 + !byte $0C,%11101111 + !byte $0A,%01010000 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $09,%10110001 + !byte $04,%10110001 + !byte $3A,%11010001 + !byte $3A,%11110001 + !byte $38,%01110010 + !byte $38,%10010011; + !byte $06,%10110011 + !byte $05,%00010100 + !byte $04,%10110101 + !byte $03,%10110101 + !byte $3B,%00010110 + !byte $03,%01010110 + !byte $03,%01110110 + !byte $03,%10010111; + !byte $3C,%11011011 + !byte $02,%11011011 + !byte $3C,%11111011 + !byte $3C,%00011100 + !byte $3C,%01011100 + !byte $3C,%10111101 + !byte $03,%10111101 + !byte $03,%11011101 + !byte $03,%11111101 + !byte $3B,%00011110 + !byte $03,%00011110 + !byte $04,%01011110 + !byte $04,%01111110 + !byte $04,%10011111; + !byte $03,%11011111 + !byte $3B,%11111111 + !byte $05,%11111111 + !byte $03,%11111111 + !byte $79,%00000000 + !byte $45,%00000000 + !byte $78,%01000000 + !byte $46,%01000000 + !byte $78,%01100000 + !byte $78,%10000001; + !byte $47,%10100001 + !byte $77,%11000001 + !byte $47,%11000001 + !byte $5F,%00100010 + !byte $74,%01100010 + !byte $74,%10000011; + !byte $4A,%01100010 + !byte $4A,%10000011; + !byte $79,%10100011 + !byte $74,%10100011 + !byte $60,%10100011 + !byte $4B,%10100011 + !byte $73,%11000011 + !byte $5E,%11000011 + !byte $4C,%11000011 + !byte $4B,%11000011 + !byte $76,%11100011 + !byte $72,%11100011 + !byte $61,%11100011 + !byte $5D,%11100011 + !byte $4C,%11100011 + !byte $77,%00000100 + !byte $71,%00000100 + !byte $62,%00000100 + !byte $4E,%00000100 + !byte $4D,%00000100 + !byte $47,%00000100 + !byte $70,%00100100 + !byte $63,%00100100 + !byte $5C,%00100100 + !byte $4F,%00100100 + !byte $4E,%00100100 + !byte $6F,%01000100 + !byte $64,%01000100 + !byte $5B,%01000100 + !byte $5A,%01000100 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $6C,%01100100 + !byte $6C,%10000101; + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $67,%01100100 + !byte $67,%10000101; + !byte $66,%01100100 + !byte $66,%10000101; + !byte $65,%01100100 + !byte $65,%10000101; + !byte $59,%01100100 + !byte $59,%10000101; + !byte $58,%01100100 + !byte $58,%10000101; + !byte $53,%01100100 + !byte $53,%10000101; + !byte $52,%01100100 + !byte $52,%10000101; + !byte $6A,%10100101 + !byte $68,%10100101 + !byte $57,%10100101 + !byte $55,%10100101 + !byte $54,%10100101 + !byte $6F,%11000101 + !byte $6E,%11100101 + !byte $69,%11100101 + !byte $55,%11100101 + !byte $50,%11100101 + !byte $23,%10100001 + !byte $22,%10100001 + !byte $1C,%10100001 + !byte $24,%11000001 + !byte $1B,%11000001 + !byte $1A,%11000001 + !byte $26,%11100001 + !byte $25,%11100001 + !byte $1A,%11100001 + !byte $19,%11100001 + !byte $19,%00000010 + !byte $27,%00100010 + !byte $18,%00100010 + !byte $27,%01000010 + !byte $17,%01000010 + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $2A,%01100010 + !byte $2A,%10000011; + !byte $28,%01100010 + !byte $28,%10000011; + !byte $15,%01100010 + !byte $15,%10000011; + !byte $14,%01100010 + !byte $14,%10000011; + !byte $2B,%10100011 + !byte $28,%10100011 + !byte $2B,%11000011 + !byte $16,%11000011 + !byte $2C,%00100110 + !byte $2B,%00100110 + !byte $14,%00100110 + !byte $13,%00100110 + !byte $27,%01001100 + !byte $26,%01001100 + !byte $18,%01001100 + !byte $29,%01101100 + !byte $29,%10001101; + !byte $28,%01101100 + !byte $28,%10001101; + !byte $16,%01101100 + !byte $16,%10001101; + !byte $2C,%10101101 + !byte $2A,%10101101 + !byte $14,%10101101 + !byte $2C,%11001101 + !byte $2B,%11001101 + !byte $13,%11001101 + !byte $2F,%11101101 + !byte $2D,%11101101 + !byte $12,%11101101 + !byte $2F,%00101110 + !byte $30,%01001110 + !byte $0F,%01001110 + !byte $0C,%01001110 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $33,%11101111 + !byte $33,%00010000 + !byte $0B,%00010000 + !byte $35,%00110000 + !byte $34,%00110000 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $35,%01110000 + !byte $35,%10010001; + !byte $09,%01110000 + !byte $09,%10010001; + !byte $05,%01110000 + !byte $05,%10010001; + !byte $04,%11010001 + !byte $04,%11110001 + !byte $38,%01010010 + !byte $06,%01110010 + !byte $06,%10010011; + !byte $39,%10110011 + !byte $39,%11010011 + !byte $39,%11110011 + !byte $3A,%00110100 + !byte $03,%01010100 + !byte $3C,%01110100 + !byte $3C,%10010101; + !byte $3B,%10110101 + !byte $3B,%11010101 + !byte $3B,%11110101 + !byte $03,%00010110 + !byte $3C,%00110110 + !byte $02,%00110110 + !byte $3C,%01110110 + !byte $3C,%10010111; + !byte $3C,%10110111 + !byte $02,%10110111 + !byte $02,%11111011 + !byte $02,%00011100 + !byte $3C,%00111100 + !byte $02,%00111100 + !byte $3C,%01111100 + !byte $3C,%10011101; + !byte $3C,%11011101 + !byte $3B,%00111110 + !byte $3B,%01011110 + !byte $3B,%01111110 + !byte $3B,%10011111; + !byte $3A,%11111111 + !byte $7A,%00000000 + !byte $79,%00100000 + !byte $45,%00100000 + !byte $79,%01000000 + !byte $46,%01100000 + !byte $46,%10000001; + !byte $45,%01100000 + !byte $45,%10000001; + !byte $78,%10100001 + !byte $78,%11000001 + !byte $47,%11100001 + !byte $5F,%01000010 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $7A,%10100011 + !byte $4A,%10100011 + !byte $79,%11000011 + !byte $74,%11000011 + !byte $79,%11100011 + !byte $73,%11100011 + !byte $79,%00000100 + !byte $78,%00000100 + !byte $72,%00000100 + !byte $5D,%00000100 + !byte $48,%00000100 + !byte $79,%00100100 + !byte $71,%00100100 + !byte $62,%00100100 + !byte $70,%01000100 + !byte $63,%01000100 + !byte $4F,%01000100 + !byte $4E,%01000100 + !byte $5A,%01100100 + !byte $5A,%10000101; + !byte $6D,%10100101 + !byte $6C,%10100101 + !byte $6B,%10100101 + !byte $67,%10100101 + !byte $66,%10100101 + !byte $64,%10100101 + !byte $58,%10100101 + !byte $53,%10100101 + !byte $52,%10100101 + !byte $66,%11000101 + !byte $4F,%11000101 + !byte $6F,%11100101 + !byte $4F,%11100101 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $22,%01100000 + !byte $22,%10000001; + !byte $1C,%01100000 + !byte $1C,%10000001; + !byte $24,%10100001 + !byte $1B,%10100001 + !byte $25,%11000001 + !byte $18,%11000001 + !byte $28,%01000010 + !byte $14,%01000010 + !byte $16,%10100011 + !byte $14,%11100101 + !byte $2C,%00000110 + !byte $14,%00000110 + !byte $13,%00000110 + !byte $2B,%00001000 + !byte $29,%01001100 + !byte $2B,%10101101 + !byte $0B,%01001110 + !byte $0B,%10101111 + !byte $34,%00010000 + !byte $35,%01010000 + !byte $36,%01110000 + !byte $36,%10010001; + !byte $03,%01110000 + !byte $03,%10010001; + !byte $3B,%11010001 + !byte $3B,%11110001 + !byte $04,%00010010 + !byte $3A,%00110010 + !byte $05,%11010011 + !byte $05,%11110011 + !byte $3A,%00010100 + !byte $04,%01010100 + !byte $02,%01110100 + !byte $02,%10010101; + !byte $3C,%10110101 + !byte $03,%11110101 + !byte $3C,%01010110 + !byte $02,%11010111 + !byte $3D,%11111011 + !byte $3D,%00011100 + !byte $3D,%00111100 + !byte $02,%01011100 + !byte $02,%01111100 + !byte $02,%10011101; + !byte $02,%10111101 + !byte $3D,%11011101 + !byte $3C,%11111101 + !byte $3C,%00011110 + !byte $3C,%00111110 + !byte $03,%00111110 + !byte $02,%00111110 + !byte $03,%01011110 + !byte $03,%01111110 + !byte $03,%10011111; + !byte $3B,%10111111 + !byte $3C,%11111111 + !byte $04,%11111111 + !byte $7C,%00000000 + !byte $43,%00000000 + !byte $7A,%00100000 + !byte $45,%01000000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $7A,%10100001 + !byte $79,%10100001 + !byte $46,%10100001 + !byte $46,%11000001 + !byte $78,%11100001 + !byte $78,%00000010 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $45,%10100011 + !byte $7A,%11000011 + !byte $75,%11000011 + !byte $60,%11000011 + !byte $4A,%11000011 + !byte $45,%11000011 + !byte $74,%11100011 + !byte $5E,%11100011 + !byte $4B,%11100011 + !byte $45,%11100011 + !byte $73,%00000100 + !byte $61,%00000100 + !byte $4C,%00000100 + !byte $4B,%00000100 + !byte $45,%00000100 + !byte $78,%00100100 + !byte $77,%00100100 + !byte $72,%00100100 + !byte $5D,%00100100 + !byte $4D,%00100100 + !byte $4C,%00100100 + !byte $47,%00100100 + !byte $46,%00100100 + !byte $71,%01000100 + !byte $62,%01000100 + !byte $5C,%01000100 + !byte $4D,%01000100 + !byte $45,%01000100 + !byte $70,%01100100 + !byte $70,%10000101; + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $64,%01100100 + !byte $64,%10000101; + !byte $63,%01100100 + !byte $63,%10000101; + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $65,%10100101 + !byte $5A,%10100101 + !byte $59,%10100101 + !byte $6D,%11000101 + !byte $6C,%11000101 + !byte $6B,%11000101 + !byte $6A,%11000101 + !byte $68,%11000101 + !byte $67,%11000101 + !byte $64,%11000101 + !byte $58,%11000101 + !byte $57,%11000101 + !byte $56,%11000101 + !byte $55,%11000101 + !byte $54,%11000101 + !byte $53,%11000101 + !byte $52,%11000101 + !byte $66,%11100101 + !byte $6F,%00000110 + !byte $69,%00000110 + !byte $55,%00000110 + !byte $50,%00000110 + !byte $4F,%00000110 + !byte $6F,%00100110 + !byte $23,%01000000 + !byte $22,%01000000 + !byte $1C,%01000000 + !byte $24,%01100000 + !byte $24,%10000001; + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $25,%10100001 + !byte $1A,%10100001 + !byte $18,%10100001 + !byte $26,%11000001 + !byte $19,%11000001 + !byte $27,%11100001 + !byte $18,%11100001 + !byte $27,%00000010 + !byte $17,%00000010 + !byte $2B,%00100010 + !byte $28,%00100010 + !byte $17,%00100010 + !byte $14,%00100010 + !byte $2B,%01000010 + !byte $2A,%01000010 + !byte $16,%01000010 + !byte $15,%01000010 + !byte $13,%01000010 + !byte $16,%01100010 + !byte $16,%10000011; + !byte $13,%01100010 + !byte $13,%10000011; + !byte $29,%10100011 + !byte $14,%01100100 + !byte $14,%10000101; + !byte $14,%10100101 + !byte $2C,%11100101 + !byte $2B,%00000110 + !byte $2B,%11100111 + !byte $18,%00101100 + !byte $28,%01001100 + !byte $17,%01001100 + !byte $16,%01001100 + !byte $2A,%01101100 + !byte $2A,%10001101; + !byte $15,%01101100 + !byte $15,%10001101; + !byte $13,%10101101 + !byte $2F,%11001101 + !byte $2D,%11001101 + !byte $12,%11001101 + !byte $2E,%11101101 + !byte $11,%11101101 + !byte $0F,%11101101 + !byte $2F,%00001110 + !byte $34,%00101110 + !byte $30,%00101110 + !byte $0F,%00101110 + !byte $34,%01001110 + !byte $31,%01001110 + !byte $0E,%01001110 + !byte $34,%01101110 + !byte $34,%10001111; + !byte $33,%11001111 + !byte $0B,%11101111 + !byte $0A,%00010000 + !byte $09,%01010000 + !byte $3B,%10110001 + !byte $3B,%00010010 + !byte $06,%01010010 + !byte $39,%01110010 + !byte $39,%10010011; + !byte $05,%10110011 + !byte $3A,%11010011 + !byte $3B,%11110011 + !byte $3A,%11110011 + !byte $04,%00010100 + !byte $3B,%00110100 + !byte $04,%00110100 + !byte $03,%11010101 + !byte $3C,%11110101 + !byte $3C,%00010110 + !byte $02,%01010110 + !byte $02,%01110110 + !byte $02,%10010111; + !byte $01,%11111011 + !byte $3D,%01011100 + !byte $3D,%01111100 + !byte $3D,%10011101; + !byte $3D,%10111101 + !byte $02,%11011101 + !byte $02,%11111101 + !byte $02,%00011110 + !byte $3D,%00111110 + !byte $3C,%01011110 + !byte $3C,%01111110 + !byte $3C,%10011111; + !byte $03,%10111111 + !byte $44,%00000000 + !byte $42,%00000000 + !byte $7C,%00100000 + !byte $44,%00100000 + !byte $7A,%01000000 + !byte $7A,%01100000 + !byte $7A,%10000001; + !byte $45,%10100001 + !byte $79,%11000001 + !byte $46,%11100001 + !byte $49,%11000011 + !byte $7A,%11100011 + !byte $4A,%11100011 + !byte $7A,%00000100 + !byte $74,%00000100 + !byte $5E,%00000100 + !byte $73,%00100100 + !byte $61,%00100100 + !byte $45,%00100100 + !byte $79,%01000100 + !byte $78,%01000100 + !byte $72,%01000100 + !byte $47,%01000100 + !byte $46,%01000100 + !byte $7A,%01100100 + !byte $7A,%10000101; + !byte $71,%01100100 + !byte $71,%10000101; + !byte $5C,%01100100 + !byte $5C,%10000101; + !byte $4E,%01100100 + !byte $4E,%10000101; + !byte $4C,%01100100 + !byte $4C,%10000101; + !byte $70,%10100101 + !byte $5B,%10100101 + !byte $4F,%10100101 + !byte $65,%11000101 + !byte $59,%11000101 + !byte $51,%11000101 + !byte $6C,%11100101 + !byte $6B,%11100101 + !byte $6A,%11100101 + !byte $68,%11100101 + !byte $67,%11100101 + !byte $57,%11100101 + !byte $56,%11100101 + !byte $54,%11100101 + !byte $53,%11100101 + !byte $70,%00000110 + !byte $66,%00000110 + !byte $69,%00100110 + !byte $55,%00100110 + !byte $50,%00100110 + !byte $4F,%00100110 + !byte $22,%00100000 + !byte $1C,%00100000 + !byte $1B,%01000000 + !byte $1A,%01000000 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $1A,%01100000 + !byte $1A,%10000001; + !byte $18,%01100000 + !byte $18,%10000001; + !byte $26,%10100001 + !byte $19,%10100001 + !byte $17,%11100001 + !byte $2C,%00100010 + !byte $2A,%00100010 + !byte $16,%00100010 + !byte $13,%00100010 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $2B,%01000100 + !byte $12,%00000110 + !byte $14,%01101100 + !byte $14,%10001101; + !byte $12,%10101101 + !byte $0F,%11001101 + !byte $0D,%01001110 + !byte $0A,%01101110 + !byte $0A,%10001111; + !byte $34,%11101111 + !byte $09,%00110000 + !byte $3C,%01110000 + !byte $3C,%10010001; + !byte $08,%01110000 + !byte $08,%10010001; + !byte $03,%10110001 + !byte $03,%11010001 + !byte $03,%11110001 + !byte $03,%00010010 + !byte $04,%00110010 + !byte $39,%01010010 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $04,%11010011 + !byte $04,%11110011 + !byte $3D,%01110100 + !byte $3D,%10010101; + !byte $01,%01110100 + !byte $01,%10010101; + !byte $3D,%10110101 + !byte $02,%10110101 + !byte $3C,%11010101 + !byte $02,%11110101 + !byte $02,%00010110 + !byte $3D,%01010110 + !byte $01,%01010110 + !byte $3D,%01110110 + !byte $3D,%10010111; + !byte $3D,%10110111 + !byte $01,%00011100 + !byte $01,%00111100 + !byte $01,%01011100 + !byte $01,%01111100 + !byte $01,%10011101; + !byte $01,%10111101 + !byte $01,%11011101 + !byte $3D,%11111101 + !byte $3D,%00011110 + !byte $3D,%01011110 + !byte $02,%01011110 + !byte $01,%01011110 + !byte $02,%01111110 + !byte $02,%10011111; + !byte $3C,%10111111 + !byte $02,%10111111 + !byte $3C,%11011111 + !byte $7B,%00000000 + !byte $7B,%00100000 + !byte $42,%00100000 + !byte $44,%01000000 + !byte $44,%01100000 + !byte $44,%10000001; + !byte $45,%11000001 + !byte $44,%11000001 + !byte $79,%11100001 + !byte $45,%11100001 + !byte $46,%00000010 + !byte $5F,%10100011 + !byte $75,%11100011 + !byte $60,%11100011 + !byte $49,%11100011 + !byte $44,%11100011 + !byte $75,%00000100 + !byte $60,%00000100 + !byte $4A,%00000100 + !byte $44,%00000100 + !byte $7A,%00100100 + !byte $74,%00100100 + !byte $4B,%00100100 + !byte $4A,%00100100 + !byte $44,%00100100 + !byte $7A,%01000100 + !byte $77,%01000100 + !byte $74,%01000100 + !byte $73,%01000100 + !byte $61,%01000100 + !byte $5D,%01000100 + !byte $4C,%01000100 + !byte $4B,%01000100 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $78,%01100100 + !byte $78,%10000101; + !byte $72,%01100100 + !byte $72,%10000101; + !byte $62,%01100100 + !byte $62,%10000101; + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $46,%01100100 + !byte $46,%10000101; + !byte $45,%01100100 + !byte $45,%10000101; + !byte $7A,%10100101 + !byte $71,%10100101 + !byte $63,%10100101 + !byte $4E,%10100101 + !byte $4D,%10100101 + !byte $44,%10100101 + !byte $70,%11000101 + !byte $5A,%11000101 + !byte $4E,%11000101 + !byte $6D,%11100101 + !byte $65,%11100101 + !byte $59,%11100101 + !byte $58,%11100101 + !byte $52,%11100101 + !byte $51,%11100101 + !byte $6C,%00000110 + !byte $6B,%00000110 + !byte $6A,%00000110 + !byte $68,%00000110 + !byte $67,%00000110 + !byte $57,%00000110 + !byte $56,%00000110 + !byte $54,%00000110 + !byte $53,%00000110 + !byte $52,%00000110 + !byte $70,%00100110 + !byte $66,%00100110 + !byte $58,%00100110 + !byte $6F,%01000110 + !byte $69,%01000110 + !byte $55,%01000110 + !byte $4F,%01000110 + !byte $22,%00000000 + !byte $1C,%00000000 + !byte $24,%00100000 + !byte $23,%00100000 + !byte $1B,%00100000 + !byte $1A,%00100000 + !byte $25,%01000000 + !byte $24,%01000000 + !byte $18,%01000000 + !byte $26,%01100000 + !byte $26,%10000001; + !byte $19,%01100000 + !byte $19,%10000001; + !byte $27,%11000001 + !byte $17,%11000001 + !byte $28,%11100001 + !byte $2C,%00000010 + !byte $2B,%00000010 + !byte $2A,%00000010 + !byte $28,%00000010 + !byte $16,%00000010 + !byte $14,%00000010 + !byte $13,%00000010 + !byte $12,%00000010 + !byte $29,%01000010 + !byte $2B,%00100100 + !byte $13,%00100100 + !byte $2B,%10100101 + !byte $2C,%11000101 + !byte $2B,%11000101 + !byte $12,%11000101 + !byte $2B,%11100101 + !byte $13,%11100101 + !byte $12,%11100101 + !byte $13,%11000111 + !byte $28,%00101100 + !byte $27,%00101100 + !byte $17,%00101100 + !byte $15,%01001100 + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $13,%01101100 + !byte $13,%10001101; + !byte $11,%11001101 + !byte $30,%00001110 + !byte $0F,%00001110 + !byte $31,%00101110 + !byte $0E,%00101110 + !byte $0B,%00101110 + !byte $0A,%00101110 + !byte $0A,%01001110 + !byte $0B,%11001111 + !byte $0A,%11101111 + !byte $36,%00010000 + !byte $35,%00010000 + !byte $36,%01010000 + !byte $04,%01010000 + !byte $02,%01110000 + !byte $02,%10010001; + !byte $3C,%11010001 + !byte $05,%01010010 + !byte $3A,%10110011 + !byte $3B,%00010100 + !byte $03,%00110100 + !byte $3D,%01010100 + !byte $02,%11010101 + !byte $3D,%00110110 + !byte $01,%01110110 + !byte $01,%10010111; + !byte $01,%10110111 + !byte $3E,%00011100 + !byte $3E,%00111100 + !byte $3E,%01011100 + !byte $3E,%11111101 + !byte $01,%11111101 + !byte $01,%00011110 + !byte $02,%11011111 + !byte $7D,%00100000 + !byte $43,%00100000 + !byte $41,%00100000 + !byte $7B,%01000000 + !byte $43,%01000000 + !byte $42,%01000000 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $44,%10100001 + !byte $7A,%11000001 + !byte $79,%00000010 + !byte $45,%00000010 + !byte $79,%00100010 + !byte $7B,%00000100 + !byte $49,%00000100 + !byte $5E,%00100100 + !byte $4A,%01000100 + !byte $44,%01000100 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $73,%10100101 + !byte $72,%10100101 + !byte $62,%10100101 + !byte $5C,%10100101 + !byte $71,%11000101 + !byte $63,%11000101 + !byte $5B,%11000101 + !byte $4D,%11000101 + !byte $5A,%11100101 + !byte $6D,%00000110 + !byte $64,%00000110 + !byte $58,%00000110 + !byte $51,%00000110 + !byte $4E,%00100110 + !byte $70,%01000110 + !byte $6A,%01000110 + !byte $4E,%01000110 + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $6A,%01100110 + !byte $6A,%10000111; + !byte $55,%01100110 + !byte $55,%10000111; + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $23,%00000000 + !byte $1B,%00000000 + !byte $19,%01000000 + !byte $27,%10100001 + !byte $17,%10100001 + !byte $2B,%11100001 + !byte $16,%11100001 + !byte $14,%11100001 + !byte $13,%11100001 + !byte $29,%00100010 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $13,%11000101 + !byte $16,%00101100 + !byte $15,%00101100 + !byte $2A,%01001100 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $30,%11001101 + !byte $2E,%11001101 + !byte $0E,%00001110 + !byte $34,%11001111 + !byte $09,%00010000 + !byte $08,%00010000 + !byte $36,%00110000 + !byte $08,%01010000 + !byte $3C,%10110001 + !byte $02,%11010001 + !byte $3C,%11110001 + !byte $02,%11110001 + !byte $3B,%00110010 + !byte $3A,%01110010 + !byte $3A,%10010011; + !byte $04,%10110011 + !byte $03,%00010100 + !byte $3C,%01010100 + !byte $3E,%01110100 + !byte $3E,%10010101; + !byte $01,%10110101 + !byte $3D,%11110101 + !byte $3D,%00010110 + !byte $01,%00110110 + !byte $3E,%01010110 + !byte $00,%01010110 + !byte $00,%00011100 + !byte $00,%00111100 + !byte $00,%01011100 + !byte $3E,%01111100 + !byte $3E,%10011101; + !byte $00,%01111100 + !byte $00,%10011101; + !byte $3E,%10111101 + !byte $3E,%11011101 + !byte $01,%00111110 + !byte $3E,%01111110 + !byte $3E,%10011111; + !byte $3D,%01111110 + !byte $3D,%10011111; + !byte $01,%01111110 + !byte $01,%10011111; + !byte $3D,%10111111 + !byte $3D,%11011111 + !byte $02,%11111111 + !byte $7D,%01000000 + !byte $41,%01000000 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $43,%01100000 + !byte $43,%10000001; + !byte $7B,%10100001 + !byte $43,%10100001 + !byte $7B,%11100001 + !byte $7A,%11100001 + !byte $44,%11100001 + !byte $7A,%00000010 + !byte $7A,%00100010 + !byte $45,%00100010 + !byte $79,%01000010 + !byte $45,%01000010 + !byte $5F,%11000011 + !byte $76,%00000100 + !byte $7B,%00100100 + !byte $75,%00100100 + !byte $60,%00100100 + !byte $49,%00100100 + !byte $43,%00100100 + !byte $7B,%01000100 + !byte $75,%01000100 + !byte $5E,%01000100 + !byte $74,%01100100 + !byte $74,%10000101; + !byte $61,%01100100 + !byte $61,%10000101; + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $4A,%01100100 + !byte $4A,%10000101; + !byte $44,%01100100 + !byte $44,%10000101; + !byte $79,%10100101 + !byte $78,%10100101 + !byte $5D,%10100101 + !byte $4C,%10100101 + !byte $4B,%10100101 + !byte $46,%10100101 + !byte $45,%10100101 + !byte $7B,%11000101 + !byte $72,%11000101 + !byte $62,%11000101 + !byte $5C,%11000101 + !byte $4C,%11000101 + !byte $71,%11100101 + !byte $70,%11100101 + !byte $64,%11100101 + !byte $63,%11100101 + !byte $5B,%11100101 + !byte $4E,%11100101 + !byte $4D,%11100101 + !byte $4B,%11100101 + !byte $6E,%00000110 + !byte $65,%00000110 + !byte $5A,%00000110 + !byte $59,%00000110 + !byte $6E,%00100110 + !byte $6D,%00100110 + !byte $6C,%00100110 + !byte $6B,%00100110 + !byte $6A,%00100110 + !byte $68,%00100110 + !byte $67,%00100110 + !byte $57,%00100110 + !byte $56,%00100110 + !byte $54,%00100110 + !byte $53,%00100110 + !byte $52,%00100110 + !byte $51,%00100110 + !byte $58,%01000110 + !byte $70,%01100110 + !byte $70,%10000111; + !byte $4E,%01100110 + !byte $4E,%10000111; + !byte $70,%10100111 + !byte $6F,%10100111 + !byte $6A,%10100111 + !byte $4F,%10100111 + !byte $27,%00000000 + !byte $25,%00000000 + !byte $24,%00000000 + !byte $1A,%00000000 + !byte $26,%00100000 + !byte $25,%00100000 + !byte $19,%00100000 + !byte $18,%00100000 + !byte $26,%01000000 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $28,%10100001 + !byte $2B,%11000001 + !byte $28,%11000001 + !byte $16,%11000001 + !byte $14,%11000001 + !byte $13,%11000001 + !byte $2C,%11100001 + !byte $29,%11100001 + !byte $29,%00000010 + !byte $15,%00100010 + !byte $2B,%11100011 + !byte $2B,%00000100 + !byte $2C,%10100101 + !byte $13,%10100101 + !byte $12,%10100101 + !byte $13,%10100111 + !byte $27,%00001100 + !byte $17,%00001100 + !byte $2B,%00101100 + !byte $29,%00101100 + !byte $2D,%01001100 + !byte $2B,%01001100 + !byte $14,%01001100 + !byte $2C,%01101100 + !byte $2C,%10001101; + !byte $12,%01101100 + !byte $12,%10001101; + !byte $30,%10101101 + !byte $2E,%10101101 + !byte $2D,%10101101 + !byte $11,%10101101 + !byte $10,%11001101 + !byte $30,%11101101 + !byte $35,%00001110 + !byte $35,%00101110 + !byte $32,%00101110 + !byte $0D,%00101110 + !byte $35,%01001110 + !byte $32,%01001110 + !byte $34,%10101111 + !byte $0A,%11001111 + !byte $35,%11101111 + !byte $08,%00110000 + !byte $3D,%01010000 + !byte $3C,%01010000 + !byte $3B,%01010000 + !byte $37,%01010000 + !byte $03,%01010000 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $07,%01110000 + !byte $07,%10010001; + !byte $02,%10110001 + !byte $3C,%00010010 + !byte $3A,%01010010 + !byte $04,%01110010 + !byte $04,%10010011; + !byte $3B,%10110011 + !byte $3B,%11010011 + !byte $03,%11110011 + !byte $3C,%00010100 + !byte $3C,%00110100 + !byte $3E,%01010100 + !byte $02,%01010100 + !byte $3E,%10110101 + !byte $3D,%11010101 + !byte $01,%11110101 + !byte $01,%00010110 + !byte $3E,%01110110 + !byte $3E,%10010111; + !byte $3E,%10110111 + !byte $3F,%11010111 + !byte $3F,%00011100 + !byte $3F,%00111100 + !byte $3F,%01011100 + !byte $3F,%01111100 + !byte $3F,%10011101; + !byte $00,%10111101 + !byte $00,%11011101 + !byte $00,%11111101 + !byte $3E,%00011110 + !byte $3E,%00111110 + !byte $3E,%01011110 + !byte $00,%01111110 + !byte $00,%10011111; + !byte $01,%10111111 + !byte $01,%11011111 + !byte $3D,%11111111 + !byte $7D,%00000000 + !byte $7E,%01000000 + !byte $7C,%01000000 + !byte $7E,%01100000 + !byte $7E,%10000001; + !byte $7C,%01100000 + !byte $7C,%10000001; + !byte $41,%01100000 + !byte $41,%10000001; + !byte $7B,%11000001 + !byte $43,%11000001 + !byte $44,%00000010 + !byte $7A,%01000010 + !byte $45,%01100010 + !byte $45,%10000011; + !byte $5F,%11100011 + !byte $76,%00100100 + !byte $48,%00100100 + !byte $76,%01000100 + !byte $49,%01000100 + !byte $43,%01000100 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $75,%01100100 + !byte $75,%10000101; + !byte $7B,%10100101 + !byte $75,%10100101 + !byte $74,%10100101 + !byte $7A,%11000101 + !byte $79,%11000101 + !byte $73,%11000101 + !byte $45,%11000101 + !byte $72,%11100101 + !byte $5C,%11100101 + !byte $71,%00000110 + !byte $5B,%00000110 + !byte $4E,%00000110 + !byte $65,%00100110 + !byte $59,%00100110 + !byte $6D,%01000110 + !byte $6C,%01000110 + !byte $6B,%01000110 + !byte $68,%01000110 + !byte $67,%01000110 + !byte $57,%01000110 + !byte $56,%01000110 + !byte $54,%01000110 + !byte $53,%01000110 + !byte $52,%01000110 + !byte $51,%01000110 + !byte $58,%01100110 + !byte $58,%10000111; + !byte $55,%10100111 + !byte $4E,%10100111 + !byte $6A,%11000111 + !byte $19,%00000000 + !byte $27,%01000000 + !byte $17,%01000000 + !byte $28,%01100000 + !byte $28,%10000001; + !byte $17,%01100000 + !byte $17,%10000001; + !byte $16,%10100001 + !byte $2C,%11000001 + !byte $29,%11000001 + !byte $12,%11000001 + !byte $15,%00000010 + !byte $13,%01000100 + !byte $12,%01100100 + !byte $12,%10000101; + !byte $2D,%10100101 + !byte $2C,%10100111 + !byte $28,%00001100 + !byte $2A,%00101100 + !byte $13,%01001100 + !byte $0E,%10101101 + !byte $0E,%11001101 + !byte $31,%00001110 + !byte $35,%01101110 + !byte $35,%10001111; + !byte $35,%11001111 + !byte $09,%11101111 + !byte $37,%00010000 + !byte $07,%01010000 + !byte $01,%01010000 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $01,%01110000 + !byte $01,%10010001; + !byte $3D,%10110001 + !byte $3D,%11010001 + !byte $3D,%11110001 + !byte $02,%00010010 + !byte $03,%00110010 + !byte $04,%01010010 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $03,%11010011 + !byte $02,%00110100 + !byte $3F,%01110100 + !byte $3F,%10010101; + !byte $00,%01110100 + !byte $00,%10010101; + !byte $00,%10110101 + !byte $01,%11010101 + !byte $3E,%00010110 + !byte $3E,%00110110 + !byte $3F,%01010110 + !byte $00,%10110111 + !byte $3F,%10111101 + !byte $3F,%11011101 + !byte $3F,%11111101 + !byte $00,%00011110 + !byte $00,%00111110 + !byte $00,%01011110 + !byte $3F,%10111111 + !byte $3E,%10111111 + !byte $3E,%11011111 + !byte $3E,%11111111 + !byte $01,%11111111 + !byte $41,%00000000 + !byte $42,%01100000 + !byte $42,%10000001; + !byte $40,%01100000 + !byte $40,%10000001; + !byte $7E,%10100001 + !byte $7C,%10100001 + !byte $41,%10100001 + !byte $7C,%11000001 + !byte $43,%11100001 + !byte $7B,%00000010 + !byte $43,%00000010 + !byte $7B,%00100010 + !byte $44,%00100010 + !byte $44,%01000010 + !byte $7A,%01100010 + !byte $7A,%10000011; + !byte $5F,%00000100 + !byte $60,%01000100 + !byte $48,%01000100 + !byte $76,%01100100 + !byte $76,%10000101; + !byte $5E,%01100100 + !byte $5E,%10000101; + !byte $49,%01100100 + !byte $49,%10000101; + !byte $43,%01100100 + !byte $43,%10000101; + !byte $61,%10100101 + !byte $4A,%10100101 + !byte $43,%10100101 + !byte $74,%11000101 + !byte $5D,%11000101 + !byte $4B,%11000101 + !byte $4A,%11000101 + !byte $46,%11000101 + !byte $44,%11000101 + !byte $7A,%11100101 + !byte $73,%11100101 + !byte $62,%11100101 + !byte $4C,%11100101 + !byte $45,%11100101 + !byte $44,%11100101 + !byte $43,%11100101 + !byte $74,%00000110 + !byte $72,%00000110 + !byte $63,%00000110 + !byte $4D,%00000110 + !byte $4C,%00000110 + !byte $43,%00000110 + !byte $71,%00100110 + !byte $64,%00100110 + !byte $5A,%00100110 + !byte $6E,%01000110 + !byte $66,%01000110 + !byte $65,%01000110 + !byte $59,%01000110 + !byte $50,%01000110 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $6C,%01100110 + !byte $6C,%10000111; + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $69,%01100110 + !byte $69,%10000111; + !byte $68,%01100110 + !byte $68,%10000111; + !byte $67,%01100110 + !byte $67,%10000111; + !byte $57,%01100110 + !byte $57,%10000111; + !byte $56,%01100110 + !byte $56,%10000111; + !byte $54,%01100110 + !byte $54,%10000111; + !byte $53,%01100110 + !byte $53,%10000111; + !byte $52,%01100110 + !byte $52,%10000111; + !byte $51,%01100110 + !byte $51,%10000111; + !byte $71,%10100111 + !byte $58,%10100111 + !byte $71,%11000111 + !byte $70,%11000111 + !byte $54,%11000111 + !byte $4F,%11000111 + !byte $4E,%11000111 + !byte $70,%11100111 + !byte $6A,%11100111 + !byte $26,%00000000 + !byte $18,%00000000 + !byte $27,%00100000 + !byte $17,%00100000 + !byte $28,%01000000 + !byte $16,%01100000 + !byte $16,%10000001; + !byte $13,%01100000 + !byte $13,%10000001; + !byte $2C,%10100001 + !byte $2B,%10100001 + !byte $29,%10100001 + !byte $14,%10100001 + !byte $13,%10100001 + !byte $12,%10100001 + !byte $15,%11000001 + !byte $2A,%11100001 + !byte $15,%11100001 + !byte $12,%11100001 + !byte $13,%11000011 + !byte $13,%11100011 + !byte $13,%00000100 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $2C,%01100100 + !byte $2C,%10000101; + !byte $13,%01100100 + !byte $13,%10000101; + !byte $2C,%01100110 + !byte $2C,%10000111; + !byte $17,%11101011 + !byte $29,%00001100 + !byte $16,%00001100 + !byte $15,%00001100 + !byte $14,%00101100 + !byte $2C,%01001100 + !byte $12,%01001100 + !byte $11,%01001100 + !byte $11,%01101100 + !byte $11,%10001101; + !byte $0E,%01101100 + !byte $0E,%10001101; + !byte $10,%10101101 + !byte $31,%11101101 + !byte $0E,%11101101 + !byte $0D,%00001110 + !byte $0A,%00001110 + !byte $09,%00001110 + !byte $0C,%00101110 + !byte $09,%00101110 + !byte $09,%01001110 + !byte $0A,%10101111 + !byte $09,%11001111 + !byte $36,%11101111 + !byte $07,%11101111 + !byte $37,%00110000 + !byte $07,%00110000 + !byte $3E,%01010000 + !byte $02,%01010000 + !byte $01,%10110001 + !byte $01,%11010001 + !byte $01,%11110001 + !byte $03,%01110010 + !byte $03,%10010011; + !byte $03,%10110011 + !byte $3C,%11010011 + !byte $3D,%11110011 + !byte $3C,%11110011 + !byte $02,%00010100 + !byte $3D,%00110100 + !byte $01,%01010100 + !byte $3F,%10110101 + !byte $3E,%11110101 + !byte $00,%00010110 + !byte $00,%00110110 + !byte $00,%01110110 + !byte $00,%10010111; + !byte $3F,%10110111 + !byte $3F,%00011110 + !byte $3F,%00111110 + !byte $00,%10111111 + !byte $00,%11011111 + !byte $7F,%10100001 + !byte $42,%10100001 + !byte $40,%10100001 + !byte $42,%11000001 + !byte $7C,%11100001 + !byte $43,%00100010 + !byte $42,%00100010 + !byte $7B,%01000010 + !byte $44,%01100010 + !byte $44,%10000011; + !byte $7C,%01000100 + !byte $7C,%01100100 + !byte $7C,%10000101; + !byte $60,%01100100 + !byte $60,%10000101; + !byte $48,%01100100 + !byte $48,%10000101; + !byte $7C,%10100101 + !byte $76,%10100101 + !byte $49,%10100101 + !byte $75,%11000101 + !byte $61,%11000101 + !byte $49,%11000101 + !byte $43,%11000101 + !byte $7B,%11100101 + !byte $79,%11100101 + !byte $74,%11100101 + !byte $7C,%00000110 + !byte $73,%00000110 + !byte $5C,%00000110 + !byte $4B,%00000110 + !byte $72,%00100110 + !byte $63,%00100110 + !byte $5B,%00100110 + !byte $4D,%00100110 + !byte $4C,%00100110 + !byte $5A,%01000110 + !byte $6E,%01100110 + !byte $6E,%10000111; + !byte $66,%01100110 + !byte $66,%10000111; + !byte $50,%01100110 + !byte $50,%10000111; + !byte $6C,%10100111 + !byte $6B,%10100111 + !byte $69,%10100111 + !byte $56,%10100111 + !byte $54,%10100111 + !byte $53,%10100111 + !byte $52,%10100111 + !byte $54,%11100111 + !byte $4E,%11100111 + !byte $17,%00000000 + !byte $16,%00100000 + !byte $16,%01000000 + !byte $2C,%01100000 + !byte $2C,%10000001; + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $15,%10100001 + !byte $13,%10100011 + !byte $2C,%11000011 + !byte $2D,%01000100 + !byte $11,%01100100 + !byte $11,%10000101; + !byte $13,%00001100 + !byte $13,%00101100 + !byte $2E,%01101100 + !byte $2E,%10001101; + !byte $31,%10101101 + !byte $2F,%10101101 + !byte $0D,%11101101 + !byte $32,%00001110 + !byte $35,%10101111 + !byte $08,%11101111 + !byte $38,%01010000 + !byte $00,%01010000 + !byte $3D,%00010010 + !byte $01,%00010010 + !byte $3B,%01010010 + !byte $02,%11010011 + !byte $02,%11110011 + !byte $3E,%11010101 + !byte $00,%11110101 + !byte $3F,%01110110 + !byte $3F,%10010111; + !byte $3F,%01011110 + !byte $3F,%01111110 + !byte $3F,%10011111; + !byte $00,%11111111 + !byte $7E,%00000000 + !byte $40,%00000000 + !byte $7E,%00100000 + !byte $7D,%10100001 + !byte $7D,%11000001 + !byte $40,%11000001 + !byte $42,%11100001 + !byte $7C,%00000010 + !byte $42,%00000010 + !byte $7C,%00100010 + !byte $43,%01000010 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $43,%01100010 + !byte $43,%10000011; + !byte $44,%10100011 + !byte $44,%11000011 + !byte $5F,%00100100 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $47,%01100100 + !byte $47,%10000101; + !byte $42,%01100100 + !byte $42,%10000101; + !byte $60,%10100101 + !byte $5E,%10100101 + !byte $48,%10100101 + !byte $42,%10100101 + !byte $7C,%11000101 + !byte $76,%11000101 + !byte $48,%11000101 + !byte $42,%11000101 + !byte $7C,%11100101 + !byte $75,%11100101 + !byte $61,%11100101 + !byte $5D,%11100101 + !byte $4A,%11100101 + !byte $49,%11100101 + !byte $42,%11100101 + !byte $7B,%00000110 + !byte $7A,%00000110 + !byte $62,%00000110 + !byte $4A,%00000110 + !byte $45,%00000110 + !byte $44,%00000110 + !byte $7C,%00100110 + !byte $73,%00100110 + !byte $5C,%00100110 + !byte $4B,%00100110 + !byte $42,%00100110 + !byte $72,%01000110 + !byte $71,%01000110 + !byte $64,%01000110 + !byte $63,%01000110 + !byte $5B,%01000110 + !byte $4D,%01000110 + !byte $4C,%01000110 + !byte $4A,%01000110 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $65,%01100110 + !byte $65,%10000111; + !byte $5A,%01100110 + !byte $5A,%10000111; + !byte $59,%01100110 + !byte $59,%10000111; + !byte $6E,%10100111 + !byte $6D,%10100111 + !byte $68,%10100111 + !byte $67,%10100111 + !byte $66,%10100111 + !byte $57,%10100111 + !byte $51,%10100111 + !byte $50,%10100111 + !byte $6C,%11000111 + !byte $6B,%11000111 + !byte $69,%11000111 + !byte $68,%11000111 + !byte $56,%11000111 + !byte $55,%11000111 + !byte $53,%11000111 + !byte $52,%11000111 + !byte $4D,%11000111 + !byte $71,%11100111 + !byte $4D,%11100111 + !byte $28,%00000000 + !byte $16,%00000000 + !byte $28,%00100000 + !byte $2C,%01000000 + !byte $2B,%01000000 + !byte $29,%01000000 + !byte $13,%01000000 + !byte $12,%01000000 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $15,%01100000 + !byte $15,%10000001; + !byte $12,%01100000 + !byte $12,%10000001; + !byte $2A,%11000001 + !byte $2C,%10100011 + !byte $2D,%00100100 + !byte $11,%00100100 + !byte $2C,%01000100 + !byte $12,%01000100 + !byte $11,%01000100 + !byte $2C,%01000110 + !byte $12,%01000110 + !byte $29,%11101011 + !byte $28,%11101011 + !byte $16,%11101011 + !byte $2A,%00001100 + !byte $14,%00001100 + !byte $2C,%00101100 + !byte $12,%00101100 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $10,%01101100 + !byte $10,%10001101; + !byte $0F,%10101101 + !byte $36,%11101101 + !byte $36,%00001110 + !byte $0C,%00001110 + !byte $36,%00101110 + !byte $33,%00101110 + !byte $09,%10101111 + !byte $36,%11001111 + !byte $08,%11001111 + !byte $07,%00010000 + !byte $06,%01010000 + !byte $3E,%01110000 + !byte $3E,%10010001; + !byte $3E,%10110001 + !byte $3E,%11010001 + !byte $03,%01010010 + !byte $3C,%10110011 + !byte $02,%10110011 + !byte $3D,%00010100 + !byte $01,%00010100 + !byte $01,%00110100 + !byte $00,%11010101 + !byte $3F,%00010110 + !byte $3F,%00110110 + !byte $3F,%11011111 + !byte $3F,%11111111 + !byte $40,%00100000 + !byte $40,%01000000 + !byte $7F,%11000001 + !byte $41,%11000001 + !byte $7D,%11100001 + !byte $7C,%01000010 + !byte $7B,%10100011 + !byte $43,%10100011 + !byte $7D,%10100101 + !byte $77,%10100101 + !byte $47,%10100101 + !byte $41,%10100101 + !byte $77,%11000101 + !byte $5E,%11000101 + !byte $76,%11100101 + !byte $75,%00000110 + !byte $61,%00000110 + !byte $5D,%00000110 + !byte $42,%00000110 + !byte $7B,%00100110 + !byte $7A,%00100110 + !byte $74,%00100110 + !byte $62,%00100110 + !byte $4A,%00100110 + !byte $44,%00100110 + !byte $43,%00100110 + !byte $73,%01000110 + !byte $4B,%01000110 + !byte $42,%01000110 + !byte $72,%01100110 + !byte $72,%10000111; + !byte $64,%01100110 + !byte $64,%10000111; + !byte $63,%01100110 + !byte $63,%10000111; + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $65,%10100111 + !byte $59,%10100111 + !byte $6E,%11000111 + !byte $6D,%11000111 + !byte $67,%11000111 + !byte $57,%11000111 + !byte $51,%11000111 + !byte $50,%11000111 + !byte $2C,%00100000 + !byte $29,%00100000 + !byte $13,%00100000 + !byte $2D,%01000000 + !byte $15,%01000000 + !byte $11,%01000000 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $2D,%10100001 + !byte $2A,%10100001 + !byte $2C,%11100011 + !byte $2C,%00000100 + !byte $2C,%00100100 + !byte $12,%00100100 + !byte $2B,%00001100 + !byte $2E,%00101100 + !byte $2E,%01001100 + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $31,%11001101 + !byte $32,%11101101 + !byte $33,%00001110 + !byte $08,%00101110 + !byte $36,%01001110 + !byte $36,%10101111 + !byte $38,%11101111 + !byte $37,%11101111 + !byte $38,%00110000 + !byte $3F,%01010000 + !byte $00,%01110000 + !byte $00,%10010001; + !byte $00,%10110001 + !byte $00,%11010001 + !byte $3F,%11110001 + !byte $3E,%11110001 + !byte $00,%11110001 + !byte $3E,%00010010 + !byte $3C,%01010010 + !byte $3C,%01110010 + !byte $3C,%10010011; + !byte $3D,%11010011 + !byte $3E,%00110100 + !byte $3F,%11010101 + !byte $3F,%11110101 + !byte $7F,%00000000 + !byte $7F,%00100000 + !byte $7F,%01000000 + !byte $7E,%11000001 + !byte $7F,%11100001 + !byte $7E,%11100001 + !byte $41,%11100001 + !byte $7D,%00000010 + !byte $41,%00000010 + !byte $7D,%00100010 + !byte $7D,%01000010 + !byte $42,%01000010 + !byte $7C,%01100010 + !byte $7C,%10000011; + !byte $42,%01100010 + !byte $42,%10000011; + !byte $7C,%10100011 + !byte $7B,%11000011 + !byte $43,%11000011 + !byte $7B,%11100011 + !byte $5F,%01000100 + !byte $7D,%11000101 + !byte $78,%11000101 + !byte $60,%11000101 + !byte $47,%11000101 + !byte $41,%11000101 + !byte $7D,%11100101 + !byte $77,%11100101 + !byte $5E,%11100101 + !byte $48,%11100101 + !byte $7D,%00000110 + !byte $76,%00000110 + !byte $49,%00000110 + !byte $75,%00100110 + !byte $5D,%00100110 + !byte $49,%00100110 + !byte $45,%00100110 + !byte $7D,%01000110 + !byte $7C,%01000110 + !byte $7B,%01000110 + !byte $74,%01000110 + !byte $62,%01000110 + !byte $5C,%01000110 + !byte $44,%01000110 + !byte $43,%01000110 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $75,%01100110 + !byte $75,%10000111; + !byte $73,%01100110 + !byte $73,%10000111; + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $4C,%01100110 + !byte $4C,%10000111; + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $72,%10100111 + !byte $64,%10100111 + !byte $5A,%10100111 + !byte $4D,%10100111 + !byte $6F,%11000111 + !byte $66,%11000111 + !byte $65,%11000111 + !byte $59,%11000111 + !byte $58,%11000111 + !byte $6F,%11100111 + !byte $6E,%11100111 + !byte $6D,%11100111 + !byte $6C,%11100111 + !byte $6B,%11100111 + !byte $69,%11100111 + !byte $68,%11100111 + !byte $67,%11100111 + !byte $5A,%11100111 + !byte $57,%11100111 + !byte $56,%11100111 + !byte $55,%11100111 + !byte $53,%11100111 + !byte $52,%11100111 + !byte $51,%11100111 + !byte $50,%11100111 + !byte $2C,%00000000 + !byte $29,%00000000 + !byte $13,%00000000 + !byte $2D,%00100000 + !byte $2B,%00100000 + !byte $15,%00100000 + !byte $12,%00100000 + !byte $11,%00100000 + !byte $2A,%01000000 + !byte $2A,%01100000 + !byte $2A,%10000001; + !byte $14,%01100000 + !byte $14,%10000001; + !byte $2C,%01100010 + !byte $2C,%10000011; + !byte $2D,%00000100 + !byte $11,%00000100 + !byte $2E,%00100100 + !byte $12,%00100110 + !byte $29,%11001011 + !byte $28,%11001011 + !byte $2C,%11101011 + !byte $2A,%11101011 + !byte $15,%11101011 + !byte $2E,%00001100 + !byte $2C,%00001100 + !byte $2D,%00101100 + !byte $11,%00101100 + !byte $31,%01001100 + !byte $10,%01001100 + !byte $0D,%01001100 + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $32,%11001101 + !byte $0D,%11001101 + !byte $0C,%11101101 + !byte $09,%11101101 + !byte $08,%11101101 + !byte $0B,%00001110 + !byte $08,%00001110 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $37,%11001111 + !byte $06,%11101111 + !byte $38,%00010000 + !byte $3D,%00110000 + !byte $39,%00110000 + !byte $06,%00110000 + !byte $02,%00110000 + !byte $01,%00110000 + !byte $39,%01010000 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $3F,%10110001 + !byte $3F,%11010001 + !byte $3C,%00110010 + !byte $02,%01110010 + !byte $02,%10010011; + !byte $3D,%10110011 + !byte $01,%11110011 + !byte $00,%11110011 + !byte $3E,%00010100 + !byte $00,%01010100 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $7E,%00000010 + !byte $41,%00100010 + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $41,%01100010 + !byte $41,%10000011; + !byte $42,%10100011 + !byte $7C,%11000011 + !byte $43,%11100011 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $47,%11100101 + !byte $41,%11100101 + !byte $77,%00000110 + !byte $5E,%00000110 + !byte $48,%00000110 + !byte $41,%00000110 + !byte $7D,%00100110 + !byte $76,%00100110 + !byte $75,%01000110 + !byte $74,%01100110 + !byte $74,%10000111; + !byte $5C,%01100110 + !byte $5C,%10000111; + !byte $41,%01100110 + !byte $41,%10000111; + !byte $73,%10100111 + !byte $5B,%10100111 + !byte $4C,%10100111 + !byte $72,%11000111 + !byte $5A,%11000111 + !byte $66,%11100111 + !byte $59,%11100111 + !byte $58,%11100111 + !byte $4F,%11100111 + !byte $2D,%00000000 + !byte $15,%00000000 + !byte $12,%00000000 + !byte $2A,%00100000 + !byte $14,%01000000 + !byte $2C,%01000010 + !byte $12,%01000010 + !byte $2E,%00000100 + !byte $12,%00000100 + !byte $16,%11001011 + !byte $14,%11101011 + !byte $2F,%01001100 + !byte $30,%01101100 + !byte $30,%10001101; + !byte $37,%11001101 + !byte $33,%11101101 + !byte $37,%00001110 + !byte $37,%00101110 + !byte $36,%01101110 + !byte $36,%10001111; + !byte $08,%10101111 + !byte $3E,%00110000 + !byte $05,%00110000 + !byte $05,%01010000 + !byte $00,%00010010 + !byte $02,%01010010 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $01,%11010011 + !byte $3E,%11110011 + !byte $00,%00110100 + !byte $3F,%01010100 + !byte $40,%11100001 + !byte $40,%00000010 + !byte $7E,%00100010 + !byte $7E,%01000010 + !byte $41,%01000010 + !byte $7E,%10100011 + !byte $7D,%10100011 + !byte $42,%11000011 + !byte $7C,%11100011 + !byte $42,%11100011 + !byte $7C,%00000100 + !byte $43,%00000100 + !byte $5F,%10100101 + !byte $78,%11100101 + !byte $60,%11100101 + !byte $46,%11100101 + !byte $7E,%00000110 + !byte $78,%00000110 + !byte $47,%00000110 + !byte $7E,%00100110 + !byte $77,%00100110 + !byte $61,%00100110 + !byte $5E,%00100110 + !byte $48,%00100110 + !byte $41,%00100110 + !byte $7A,%01000110 + !byte $76,%01000110 + !byte $5D,%01000110 + !byte $49,%01000110 + !byte $48,%01000110 + !byte $41,%01000110 + !byte $7C,%01100110 + !byte $7C,%10000111; + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $62,%01100110 + !byte $62,%10000111; + !byte $4A,%01100110 + !byte $4A,%10000111; + !byte $49,%01100110 + !byte $49,%10000111; + !byte $44,%01100110 + !byte $44,%10000111; + !byte $43,%01100110 + !byte $43,%10000111; + !byte $42,%01100110 + !byte $42,%10000111; + !byte $7E,%10100111 + !byte $74,%10100111 + !byte $63,%10100111 + !byte $5C,%10100111 + !byte $4B,%10100111 + !byte $4A,%10100111 + !byte $41,%10100111 + !byte $73,%11000111 + !byte $64,%11000111 + !byte $5B,%11000111 + !byte $4C,%11000111 + !byte $4B,%11000111 + !byte $72,%11100111 + !byte $65,%11100111 + !byte $2B,%00000000 + !byte $2A,%00000000 + !byte $11,%00000000 + !byte $14,%00100000 + !byte $12,%00100010 + !byte $12,%01100010 + !byte $12,%10000011; + !byte $12,%10100011 + !byte $12,%11000011 + !byte $2E,%11100011 + !byte $2D,%11100011 + !byte $12,%11100011 + !byte $11,%11100011 + !byte $28,%10101011 + !byte $2A,%11001011 + !byte $15,%11001011 + !byte $14,%11001011 + !byte $2B,%11101011 + !byte $13,%11101011 + !byte $2D,%00001100 + !byte $12,%00001100 + !byte $11,%00001100 + !byte $10,%00001100 + !byte $10,%00101100 + !byte $32,%01001100 + !byte $0F,%01001100 + !byte $0D,%10101101 + !byte $0C,%11001101 + !byte $0B,%11001101 + !byte $37,%11101101 + !byte $0B,%11101101 + !byte $34,%00001110 + !byte $07,%00001110 + !byte $08,%01101110 + !byte $08,%10001111; + !byte $37,%10101111 + !byte $39,%11001111 + !byte $07,%11001111 + !byte $06,%00010000 + !byte $00,%00110000 + !byte $3A,%01010000 + !byte $02,%00110010 + !byte $3D,%01010010 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $01,%10110011 + !byte $3E,%11010011 + !byte $3F,%11110011 + !byte $00,%00010100 + !byte $3F,%00110100 + !byte $7F,%00000010 + !byte $40,%00100010 + !byte $40,%01000010 + !byte $7E,%01100010 + !byte $7E,%10000011; + !byte $41,%10100011 + !byte $7D,%11000011 + !byte $41,%11000011 + !byte $7D,%11100011 + !byte $42,%00000100 + !byte $7C,%00100100 + !byte $7E,%11100101 + !byte $60,%00000110 + !byte $46,%00000110 + !byte $40,%00000110 + !byte $47,%00100110 + !byte $40,%00100110 + !byte $7E,%01000110 + !byte $77,%01000110 + !byte $61,%01000110 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $76,%01100110 + !byte $76,%10000111; + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $48,%01100110 + !byte $48,%10000111; + !byte $7D,%10100111 + !byte $7C,%10100111 + !byte $75,%10100111 + !byte $62,%10100111 + !byte $49,%10100111 + !byte $43,%10100111 + !byte $42,%10100111 + !byte $7E,%11000111 + !byte $74,%11000111 + !byte $63,%11000111 + !byte $4A,%11000111 + !byte $73,%11100111 + !byte $64,%11100111 + !byte $5B,%11100111 + !byte $4C,%11100111 + !byte $14,%00000000 + !byte $2E,%11000011 + !byte $10,%11100011 + !byte $2D,%00000110 + !byte $16,%10101011 + !byte $12,%11001011 + !byte $32,%00101100 + !byte $0C,%01001100 + !byte $07,%11001101 + !byte $07,%11101101 + !byte $07,%00101110 + !byte $07,%10101111 + !byte $38,%11001111 + !byte $05,%11001111 + !byte $39,%00010000 + !byte $3F,%00110000 + !byte $3F,%00010010 + !byte $01,%01010010 + !byte $00,%11010011 + !byte $3F,%00010100 + !byte $7F,%00100010 + !byte $7F,%01000010 + !byte $40,%01100010 + !byte $40,%10000011; + !byte $40,%10100011 + !byte $7E,%11000011 + !byte $40,%11000011 + !byte $41,%11100011 + !byte $7D,%00000100 + !byte $41,%00000100 + !byte $42,%00100100 + !byte $42,%01000100 + !byte $5F,%11000101 + !byte $79,%00000110 + !byte $7F,%00100110 + !byte $78,%00100110 + !byte $60,%00100110 + !byte $46,%00100110 + !byte $78,%01000110 + !byte $5E,%01000110 + !byte $47,%01000110 + !byte $40,%01000110 + !byte $7E,%01100110 + !byte $7E,%10000111; + !byte $61,%01100110 + !byte $61,%10000111; + !byte $47,%01100110 + !byte $47,%10000111; + !byte $40,%01100110 + !byte $40,%10000111; + !byte $7B,%10100111 + !byte $76,%10100111 + !byte $5D,%10100111 + !byte $48,%10100111 + !byte $47,%10100111 + !byte $7D,%11000111 + !byte $7C,%11000111 + !byte $75,%11000111 + !byte $62,%11000111 + !byte $5C,%11000111 + !byte $49,%11000111 + !byte $42,%11000111 + !byte $41,%11000111 + !byte $40,%11000111 + !byte $7E,%11100111 + !byte $76,%11100111 + !byte $74,%11100111 + !byte $63,%11100111 + !byte $4B,%11100111 + !byte $4A,%11100111 + !byte $40,%11100111 + !byte $2D,%00000010 + !byte $2D,%11000011 + !byte $11,%11000011 + !byte $10,%11000011 + !byte $2D,%11100101 + !byte $29,%10101011 + !byte $15,%10101011 + !byte $2B,%11001011 + !byte $13,%11001011 + !byte $2D,%11101011 + !byte $12,%11101011 + !byte $2F,%00101100 + !byte $0F,%00101100 + !byte $0C,%00101100 + !byte $30,%01001100 + !byte $0E,%01001100 + !byte $32,%10101101 + !byte $0C,%10101101 + !byte $33,%11001101 + !byte $08,%11001101 + !byte $34,%11101101 + !byte $0A,%11101101 + !byte $08,%01001110 + !byte $37,%01101110 + !byte $37,%10001111; + !byte $07,%01101110 + !byte $07,%10001111; + !byte $38,%10101111 + !byte $06,%11001111 + !byte $39,%11101111 + !byte $05,%00010000 + !byte $3A,%00110000 + !byte $3D,%00110010 + !byte $01,%00110010 + !byte $3E,%01110010 + !byte $3E,%10010011; + !byte $00,%01110010 + !byte $00,%10010011; + !byte $3E,%10110011 + !byte $00,%10110011 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $7E,%11100011 + !byte $7D,%00100100 + !byte $79,%00100110 + !byte $46,%01000110 + !byte $78,%01100110 + !byte $78,%10000111; + !byte $77,%10100111 + !byte $40,%10100111 + !byte $76,%11000111 + !byte $43,%11000111 + !byte $75,%11100111 + !byte $2D,%00100010 + !byte $2D,%01000010 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $2E,%10100011 + !byte $2D,%10100011 + !byte $10,%10100011 + !byte $2F,%11000011 + !byte $2D,%11000101 + !byte $11,%11100101 + !byte $2B,%10101011 + !byte $2A,%10101011 + !byte $2F,%11101011 + !byte $2F,%00001100 + !byte $30,%00101100 + !byte $32,%01101100 + !byte $32,%10001101; + !byte $38,%10101101 + !byte $33,%10101101 + !byte $38,%11001101 + !byte $34,%11001101 + !byte $38,%11101101 + !byte $38,%00001110 + !byte $3A,%11001111 + !byte $05,%11101111 + !byte $3A,%00010000 + !byte $04,%00110000 + !byte $3E,%01010010 + !byte $3F,%11010011 + !byte $7F,%10100011 + !byte $7F,%11000011 + !byte $7F,%11100011 + !byte $40,%11100011 + !byte $7E,%00000100 + !byte $7E,%00100100 + !byte $41,%00100100 + !byte $7D,%01000100 + !byte $41,%01000100 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $5F,%11100101 + !byte $7F,%01000110 + !byte $79,%01000110 + !byte $60,%01000110 + !byte $45,%01000110 + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $79,%01100110 + !byte $79,%10000111; + !byte $5E,%01100110 + !byte $5E,%10000111; + !byte $46,%01100110 + !byte $46,%10000111; + !byte $7F,%10100111 + !byte $78,%10100111 + !byte $61,%10100111 + !byte $7F,%11000111 + !byte $77,%11000111 + !byte $5D,%11000111 + !byte $48,%11000111 + !byte $47,%11000111 + !byte $7D,%11100111 + !byte $7C,%11100111 + !byte $62,%11100111 + !byte $5C,%11100111 + !byte $49,%11100111 + !byte $48,%11100111 + !byte $42,%11100111 + !byte $41,%11100111 + !byte $2D,%11100001 + !byte $2E,%01100010 + !byte $2E,%10000011; + !byte $10,%01100010 + !byte $10,%10000011; + !byte $2F,%10100011 + !byte $11,%10100011 + !byte $11,%11000101 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $29,%01101010 + !byte $29,%10001011; + !byte $16,%01101010 + !byte $16,%10001011; + !byte $15,%01101010 + !byte $15,%10001011; + !byte $2D,%10101011 + !byte $14,%10101011 + !byte $2F,%11001011 + !byte $2C,%11001011 + !byte $2E,%11101011 + !byte $11,%11101011 + !byte $0C,%00001100 + !byte $33,%00101100 + !byte $0E,%00101100 + !byte $0C,%01101100 + !byte $0C,%10001101; + !byte $0B,%10101101 + !byte $0A,%11001101 + !byte $35,%11101101 + !byte $37,%01001110 + !byte $38,%01101110 + !byte $38,%10001111; + !byte $06,%10101111 + !byte $3A,%11101111 + !byte $3F,%00010000 + !byte $3B,%00110000 + !byte $3E,%00110010 + !byte $00,%01010010 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $3F,%10110011 + !byte $40,%00000100 + !byte $7E,%01000100 + !byte $41,%01100100 + !byte $41,%10000101; + !byte $5F,%00000110 + !byte $45,%01100110 + !byte $45,%10000111; + !byte $79,%10100111 + !byte $5E,%10100111 + !byte $46,%10100111 + !byte $78,%11000111 + !byte $61,%11000111 + !byte $7F,%11100111 + !byte $77,%11100111 + !byte $5D,%11100111 + !byte $2D,%11000001 + !byte $11,%11000001 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $11,%01100010 + !byte $11,%10000011; + !byte $11,%10100101 + !byte $33,%00001100 + !byte $0F,%00001100 + !byte $31,%00101100 + !byte $0A,%10101101 + !byte $06,%10101101 + !byte $06,%11001101 + !byte $06,%11101101 + !byte $06,%00001110 + !byte $07,%01001110 + !byte $39,%10101111 + !byte $04,%11001111 + !byte $04,%00010000 + !byte $7F,%00000100 + !byte $7F,%00100100 + !byte $40,%00100100 + !byte $40,%01000100 + !byte $7E,%01100100 + !byte $7E,%10000101; + !byte $5F,%00100110 + !byte $7A,%01100110 + !byte $7A,%10000111; + !byte $60,%01100110 + !byte $60,%10000111; + !byte $7A,%10100111 + !byte $45,%10100111 + !byte $79,%11000111 + !byte $5E,%11000111 + !byte $46,%11000111 + !byte $78,%11100111 + !byte $61,%11100111 + !byte $47,%11100111 + !byte $43,%11100111 + !byte $11,%10100001 + !byte $11,%11100001 + !byte $11,%00000010 + !byte $11,%00100010 + !byte $2F,%01000010 + !byte $2E,%01000010 + !byte $11,%01000010 + !byte $10,%01000010 + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $2A,%01101010 + !byte $2A,%10001011; + !byte $14,%01101010 + !byte $14,%10001011; + !byte $2C,%10101011 + !byte $13,%10101011 + !byte $12,%10101011 + !byte $2D,%11001011 + !byte $11,%11001011 + !byte $0F,%11001011 + !byte $10,%11101011 + !byte $0F,%11101011 + !byte $30,%00001100 + !byte $0E,%00001100 + !byte $0B,%00001100 + !byte $0D,%00101100 + !byte $0B,%00101100 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $34,%10101101 + !byte $07,%10101101 + !byte $35,%11001101 + !byte $09,%11001101 + !byte $38,%01001110 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $06,%01101110 + !byte $06,%10001111; + !byte $05,%10101111 + !byte $04,%11101111 + !byte $3B,%00010000 + !byte $03,%00010000 + !byte $03,%00110000 + !byte $00,%00110010 + !byte $3F,%01010010 + !byte $7F,%01000100 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $40,%01100100 + !byte $40,%10000101; + !byte $7E,%10100101 + !byte $40,%10100101 + !byte $7E,%11000101 + !byte $60,%10100111 + !byte $44,%10100111 + !byte $45,%11000111 + !byte $46,%11100111 + !byte $0F,%01000010 + !byte $2E,%01100100 + !byte $2E,%10000101; + !byte $2E,%10100101 + !byte $29,%01001010 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $13,%01101010 + !byte $13,%10001011; + !byte $2E,%11001011 + !byte $10,%11001011 + !byte $0B,%11101011 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $39,%11001101 + !byte $39,%11101101 + !byte $06,%01001110 + !byte $3B,%10101111 + !byte $3F,%00110010 + !byte $7F,%10100101 + !byte $40,%11000101 + !byte $5F,%01000110 + !byte $7A,%11000111 + !byte $60,%11000111 + !byte $44,%11000111 + !byte $7A,%11100111 + !byte $79,%11100111 + !byte $5E,%11100111 + !byte $45,%11100111 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $2F,%00100010 + !byte $2E,%00100010 + !byte $10,%00100010 + !byte $0F,%00100010 + !byte $2E,%01000100 + !byte $2A,%01001010 + !byte $15,%01001010 + !byte $14,%01001010 + !byte $2C,%01101010 + !byte $2C,%10001011; + !byte $11,%01101010 + !byte $11,%10001011; + !byte $11,%10101011 + !byte $33,%11101011 + !byte $30,%11101011 + !byte $0E,%11101011 + !byte $31,%00001100 + !byte $0D,%00001100 + !byte $33,%01001100 + !byte $0B,%01001100 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $34,%01101100 + !byte $34,%10001101; + !byte $0A,%01101100 + !byte $0A,%10001101; + !byte $05,%01101100 + !byte $05,%10001101; + !byte $39,%10101101 + !byte $35,%10101101 + !byte $09,%10101101 + !byte $36,%11001101 + !byte $05,%11001101 + !byte $38,%00101110 + !byte $06,%00101110 + !byte $39,%01001110 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $3A,%10101111 + !byte $03,%10101111 + !byte $3B,%11101111 + !byte $03,%11101111 + !byte $3C,%00110000 + !byte $7F,%11000101 + !byte $40,%11100101 + !byte $7B,%11000111 + !byte $60,%11100111 + !byte $44,%11100111 + !byte $2E,%01000000 + !byte $2E,%11100001 + !byte $2F,%00000010 + !byte $2E,%00000010 + !byte $0F,%00000010 + !byte $29,%00101010 + !byte $13,%01001010 + !byte $12,%01101010 + !byte $12,%10001011; + !byte $30,%10101011 + !byte $2E,%10101011 + !byte $30,%11001011 + !byte $34,%00001100 + !byte $34,%01001100 + !byte $05,%10101101 + !byte $05,%11101101 + !byte $3A,%01101110 + !byte $3A,%10001111; + !byte $04,%10101111 + !byte $3B,%11001111 + !byte $3C,%00010000 + !byte $7F,%11100101 + !byte $7F,%00000110 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $7B,%11100111 + !byte $2E,%01100000 + !byte $2E,%10000001; + !byte $2E,%10100001 + !byte $2E,%11000001 + !byte $2F,%11100001 + !byte $0F,%11100001 + !byte $30,%00000010 + !byte $10,%00000010 + !byte $10,%00100100 + !byte $10,%01000100 + !byte $2A,%00101010 + !byte $15,%00101010 + !byte $2B,%01001010 + !byte $11,%01001010 + !byte $30,%01101010 + !byte $30,%10001011; + !byte $2F,%10101011 + !byte $10,%10101011 + !byte $34,%11001011 + !byte $34,%11101011 + !byte $31,%11101011 + !byte $0D,%11101011 + !byte $32,%00001100 + !byte $3A,%01001100 + !byte $0A,%01001100 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $06,%01101100 + !byte $06,%10001101; + !byte $3A,%10101101 + !byte $36,%10101101 + !byte $3A,%11001101 + !byte $39,%00101110 + !byte $05,%01001110 + !byte $04,%01101110 + !byte $04,%10001111; + !byte $3C,%10101111 + !byte $03,%11001111 + !byte $3C,%11101111 + !byte $02,%00010000 + !byte $5F,%10100111 + !byte $2E,%00100000 + !byte $10,%00100000 + !byte $0E,%00000010 + !byte $14,%00101010 + !byte $2C,%01001010 + !byte $0E,%01101010 + !byte $0E,%10001011; + !byte $0E,%10101011 + !byte $0E,%11001011 + !byte $0A,%11101011 + !byte $0A,%00001100 + !byte $3A,%01101100 + !byte $3A,%10001101; + !byte $08,%10101101 + !byte $04,%10101101 + !byte $04,%11001101 + !byte $05,%00101110 + !byte $02,%10101111 + !byte $02,%11101111 + !byte $5F,%11000111 + !byte $2E,%00000000 + !byte $10,%00000000 + !byte $10,%01100000 + !byte $10,%10000001; + !byte $10,%10100001 + !byte $30,%11000001 + !byte $2F,%11000001 + !byte $10,%11000001 + !byte $0F,%11000001 + !byte $30,%11100001 + !byte $10,%11100001 + !byte $0E,%11100001 + !byte $10,%00000100 + !byte $15,%00001010 + !byte $2B,%00101010 + !byte $13,%00101010 + !byte $2D,%01001010 + !byte $12,%01001010 + !byte $2E,%01101010 + !byte $2E,%10001011; + !byte $10,%01101010 + !byte $10,%10001011; + !byte $0F,%10101011 + !byte $31,%11001011 + !byte $0D,%11001011 + !byte $0A,%11001011 + !byte $32,%11101011 + !byte $0C,%11101011 + !byte $34,%00101100 + !byte $0A,%00101100 + !byte $36,%01001100 + !byte $35,%01001100 + !byte $09,%01001100 + !byte $04,%01001100 + !byte $36,%01101100 + !byte $36,%10001101; + !byte $04,%01101100 + !byte $04,%10001101; + !byte $37,%10101101 + !byte $39,%00001110 + !byte $3A,%01001110 + !byte $04,%01001110 + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $02,%01101110 + !byte $02,%10001111; + !byte $3C,%11001111 + !byte $02,%11001111 + !byte $3D,%11101111 + !byte $01,%11101111 + !byte $3D,%00010000 + !byte $01,%00010000 + !byte $10,%01000000 + !byte $0E,%11000001 + !byte $2C,%00001010 + !byte $2E,%00101010 + !byte $2C,%00101010 + !byte $08,%01001100 + !byte $08,%01101100 + !byte $08,%10001101; + !byte $3A,%11101101 + !byte $05,%00001110 + !byte $3A,%00101110 + !byte $3B,%01001110 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $5F,%11100111 + !byte $30,%10100001 + !byte $2F,%10100001 + !byte $0F,%10100001 + !byte $0E,%10100001 + !byte $31,%11000001 + !byte $2F,%11100011 + !byte $2F,%00000100 + !byte $2B,%00001010 + !byte $2A,%00001010 + !byte $14,%00001010 + !byte $2D,%00101010 + !byte $12,%00101010 + !byte $31,%01001010 + !byte $2E,%01001010 + !byte $0E,%01001010 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $31,%10101011 + !byte $0A,%10101011 + !byte $35,%11001011 + !byte $32,%11001011 + !byte $35,%11101011 + !byte $3B,%00101100 + !byte $35,%00101100 + !byte $09,%00101100 + !byte $3B,%01001100 + !byte $05,%01001100 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $37,%01101100 + !byte $37,%10001101; + !byte $3B,%10101101 + !byte $3A,%00001110 + !byte $04,%00101110 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $3C,%01101110 + !byte $3C,%10001111; + !byte $3D,%11001111 + !byte $3E,%00010000 + !byte $30,%01100000 + !byte $30,%10000001; + !byte $0E,%01100000 + !byte $0E,%10000001; + !byte $13,%00001010 + !byte $10,%01001010 + !byte $35,%10101011 + !byte $0C,%11001011 + !byte $07,%01101100 + !byte $07,%10001101; + !byte $03,%10101101 + !byte $3B,%11001101 + !byte $3B,%00101110 + !byte $03,%01001110 + !byte $3D,%10101111 + !byte $01,%11001111 + !byte $3E,%11101111 + !byte $2F,%00000000 + !byte $2F,%00100000 + !byte $30,%01000000 + !byte $2F,%01000000 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $0F,%11000011 + !byte $2B,%11101001 + !byte $2A,%11101001 + !byte $14,%11101001 + !byte $12,%11101001 + !byte $12,%00001010 + !byte $10,%00001010 + !byte $11,%00101010 + !byte $2F,%01001010 + !byte $0F,%01001010 + !byte $0D,%01001010 + !byte $32,%10101011 + !byte $0D,%10101011 + !byte $0C,%10101011 + !byte $33,%11001011 + !byte $35,%00001100 + !byte $37,%00101100 + !byte $36,%00101100 + !byte $03,%00101100 + !byte $37,%01001100 + !byte $38,%01101100 + !byte $38,%10001101; + !byte $03,%01101100 + !byte $03,%10001101; + !byte $04,%00001110 + !byte $3C,%01001110 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $00,%00010000 + !byte $0E,%01000000 + !byte $10,%00101010 + !byte $0D,%00101010 + !byte $30,%01001010 + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $09,%10101011 + !byte $0B,%11001011 + !byte $09,%11001011 + !byte $09,%00001100 + !byte $08,%00101100 + !byte $07,%01001100 + !byte $03,%01001100 + !byte $03,%11001101 + !byte $04,%11101101 + !byte $3B,%00001110 + !byte $03,%00101110 + !byte $02,%01001110 + !byte $3E,%01101110 + !byte $3E,%10001111; + !byte $01,%10101111 + !byte $3E,%11001111 + !byte $00,%11101111 + !byte $0F,%00000000 + !byte $31,%00100000 + !byte $30,%00100000 + !byte $0E,%00100000 + !byte $31,%01000000 + !byte $0F,%01000000 + !byte $0D,%01000000 + !byte $0F,%10100011 + !byte $2A,%11001001 + !byte $14,%11001001 + !byte $2C,%11101001 + !byte $13,%11101001 + !byte $2D,%00001010 + !byte $11,%00001010 + !byte $31,%00101010 + !byte $2F,%00101010 + !byte $0F,%00101010 + !byte $35,%01101010 + !byte $35,%10001011; + !byte $32,%01101010 + !byte $32,%10001011; + !byte $09,%01101010 + !byte $09,%10001011; + !byte $33,%10101011 + !byte $3C,%00001100 + !byte $36,%00001100 + !byte $08,%00001100 + !byte $07,%00101100 + !byte $04,%00101100 + !byte $3C,%01001100 + !byte $38,%01001100 + !byte $3C,%01101100 + !byte $3C,%10001101; + !byte $02,%01101100 + !byte $02,%10001101; + !byte $03,%00001110 + !byte $3C,%00101110 + !byte $02,%00101110 + !byte $3E,%01001110 + !byte $00,%01001110 + !byte $3F,%11001111 + !byte $00,%11001111 + !byte $3F,%11101111 + !byte $0F,%00100000 + !byte $0D,%00100000 + !byte $2E,%00001010 + !byte $0C,%01101010 + !byte $0C,%10001011; + !byte $36,%10101011 + !byte $0B,%10101011 + !byte $09,%11101011 + !byte $02,%00001100 + !byte $3C,%00101100 + !byte $06,%01001100 + !byte $02,%01001100 + !byte $3C,%10101101 + !byte $3B,%11101101 + !byte $3D,%01001110 + !byte $3E,%10101111 + !byte $31,%00000000 + !byte $0E,%00000000 + !byte $30,%01100010 + !byte $30,%10000011; + !byte $2D,%11001001 + !byte $2C,%11001001 + !byte $2B,%11001001 + !byte $13,%11001001 + !byte $2F,%11101001 + !byte $2D,%11101001 + !byte $11,%11101001 + !byte $32,%00001010 + !byte $2F,%00001010 + !byte $0D,%00001010 + !byte $32,%00101010 + !byte $30,%00101010 + !byte $0E,%00101010 + !byte $32,%01001010 + !byte $36,%01101010 + !byte $36,%10001011; + !byte $33,%01101010 + !byte $33,%10001011; + !byte $34,%10101011 + !byte $36,%11101011 + !byte $38,%00001100 + !byte $37,%00001100 + !byte $03,%00001100 + !byte $38,%00101100 + !byte $02,%00101100 + !byte $39,%01001100 + !byte $03,%11101101 + !byte $3C,%00001110 + !byte $3D,%00101110 + !byte $3F,%01001110 + !byte $01,%01001110 + !byte $3F,%10101111 + !byte $00,%10101111 + !byte $30,%00000000 + !byte $0D,%00000000 + !byte $32,%00100000 + !byte $30,%01000010 + !byte $13,%10101001 + !byte $2E,%11101001 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $08,%01101010 + !byte $08,%10001011; + !byte $08,%10101011 + !byte $08,%11101011 + !byte $3D,%00001100 + !byte $3D,%01001100 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $3C,%11101101 + !byte $02,%00001110 + !byte $00,%01101110 + !byte $00,%10001111; + !byte $32,%00000000 + !byte $2B,%10101001 + !byte $14,%10101001 + !byte $12,%11001001 + !byte $0F,%11001001 + !byte $10,%11101001 + !byte $30,%00001010 + !byte $0F,%00001010 + !byte $0C,%00001010 + !byte $08,%00101010 + !byte $36,%01001010 + !byte $33,%01001010 + !byte $0C,%01001010 + !byte $08,%01001010 + !byte $34,%01101010 + !byte $34,%10001011; + !byte $36,%11001011 + !byte $3D,%11101011 + !byte $37,%11101011 + !byte $07,%00001100 + !byte $3D,%00101100 + !byte $39,%00101100 + !byte $06,%00101100 + !byte $02,%11101101 + !byte $3D,%00001110 + !byte $01,%00001110 + !byte $3E,%00101110 + !byte $01,%00101110 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $30,%00100010 + !byte $0E,%00100010 + !byte $0E,%01000010 + !byte $14,%01101000 + !byte $14,%10001001; + !byte $11,%10101001 + !byte $11,%11001001 + !byte $0F,%11101001 + !byte $0E,%00001010 + !byte $0C,%00101010 + !byte $0A,%01101010 + !byte $0A,%10001011; + !byte $08,%11001011 + !byte $07,%11101011 + !byte $01,%11101011 + !byte $06,%00001100 + !byte $05,%00101100 + !byte $01,%00101100 + !byte $01,%01001100 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $3C,%11001101 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $2D,%10101001 + !byte $2C,%10101001 + !byte $12,%10101001 + !byte $2E,%11001001 + !byte $10,%11001001 + !byte $32,%11101001 + !byte $30,%11101001 + !byte $0C,%11101001 + !byte $31,%00001010 + !byte $37,%01001010 + !byte $34,%01001010 + !byte $0B,%01001010 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $37,%11001011 + !byte $02,%11101011 + !byte $01,%00001100 + !byte $02,%11001101 + !byte $3D,%11101101 + !byte $01,%11101101 + !byte $3E,%00001110 + !byte $00,%00101110 + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $33,%11101001 + !byte $0E,%11101001 + !byte $37,%00101010 + !byte $33,%00101010 + !byte $07,%01001010 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $07,%11001011 + !byte $38,%11101011 + !byte $39,%00001100 + !byte $3A,%00101100 + !byte $00,%00001110 + !byte $31,%00000010 + !byte $2C,%01101000 + !byte $2C,%10001001; + !byte $13,%01101000 + !byte $13,%10001001; + !byte $12,%01101000 + !byte $12,%10001001; + !byte $30,%10101001 + !byte $2E,%10101001 + !byte $10,%10101001 + !byte $33,%11001001 + !byte $30,%11001001 + !byte $2F,%11001001 + !byte $0C,%11001001 + !byte $31,%11101001 + !byte $0D,%11101001 + !byte $33,%00001010 + !byte $34,%00101010 + !byte $0B,%00101010 + !byte $07,%00101010 + !byte $35,%01001010 + !byte $0A,%01001010 + !byte $37,%10101011 + !byte $3E,%11001011 + !byte $38,%11001011 + !byte $3E,%11101011 + !byte $39,%11101011 + !byte $06,%11101011 + !byte $3E,%00001100 + !byte $3A,%00001100 + !byte $05,%00001100 + !byte $3E,%00101100 + !byte $3E,%01001100 + !byte $02,%10101101 + !byte $3D,%11001101 + !byte $01,%11001101 + !byte $3E,%11101101 + !byte $3F,%00101110 + !byte $31,%11100001 + !byte $2E,%01101000 + !byte $2E,%10001001; + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $07,%00001010 + !byte $0A,%00101010 + !byte $05,%11001011 + !byte $00,%11001011 + !byte $00,%00001100 + !byte $00,%00101100 + !byte $3D,%10101101 + !byte $3F,%00001110 + !byte $2E,%01001000 + !byte $2C,%01001000 + !byte $2B,%01001000 + !byte $13,%01001000 + !byte $30,%01101000 + !byte $30,%10001001; + !byte $2F,%10101001 + !byte $0F,%10101001 + !byte $31,%11001001 + !byte $0E,%11001001 + !byte $0B,%11001001 + !byte $37,%00001010 + !byte $34,%00001010 + !byte $0B,%00001010 + !byte $38,%00101010 + !byte $38,%01001010 + !byte $09,%01001010 + !byte $38,%10101011 + !byte $07,%10101011 + !byte $3D,%11001011 + !byte $06,%11001011 + !byte $01,%11001011 + !byte $05,%11101011 + !byte $00,%11101011 + !byte $04,%00001100 + !byte $00,%01001100 + !byte $01,%10101101 + !byte $3E,%11001101 + !byte $3F,%11101101 + !byte $00,%11101101 + !byte $0D,%11000001 + !byte $0D,%11100001 + !byte $12,%01001000 + !byte $10,%01001000 + !byte $10,%01101000 + !byte $10,%10001001; + !byte $0E,%01101000 + !byte $0E,%10001001; + !byte $0E,%10101001 + !byte $0D,%11001001 + !byte $0B,%11101001 + !byte $35,%00101010 + !byte $06,%00101010 + !byte $06,%10101011 + !byte $39,%11001011 + !byte $3F,%00001100 + !byte $3F,%00101100 + !byte $00,%11001101 + !byte $31,%10100001 + !byte $0D,%10100001 + !byte $2E,%00101000 + !byte $2B,%00101000 + !byte $13,%00101000 + !byte $2D,%01001000 + !byte $11,%01001000 + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $33,%10101001 + !byte $31,%10101001 + !byte $0B,%10101001 + !byte $32,%11001001 + !byte $38,%11101001 + !byte $38,%00001010 + !byte $35,%00001010 + !byte $0A,%00001010 + !byte $06,%00001010 + !byte $09,%00101010 + !byte $3F,%10101011 + !byte $3A,%10101011 + !byte $3F,%11001011 + !byte $3A,%11001011 + !byte $3F,%11101011 + !byte $3A,%11101011 + !byte $04,%11101011 + !byte $3B,%00001100 + !byte $3E,%10101101 + !byte $00,%10101101 + !byte $32,%11000001 + !byte $2C,%00101000 + !byte $12,%00101000 + !byte $0E,%01001000 + !byte $34,%10101001 + !byte $34,%11001001 + !byte $36,%00101010 + !byte $38,%01101010 + !byte $38,%10001011; + !byte $39,%10101011 + !byte $3B,%11101011 + !byte $3F,%01001100 + !byte $3F,%11001101 + !byte $32,%01100000 + !byte $32,%10000001; + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $32,%10100001 + !byte $2D,%00101000 + !byte $11,%00101000 + !byte $10,%00101000 + !byte $31,%01001000 + !byte $2F,%01001000 + !byte $34,%01101000 + !byte $34,%10001001; + !byte $32,%10101001 + !byte $0D,%10101001 + !byte $34,%11101001 + !byte $0A,%11101001 + !byte $09,%11101001 + !byte $06,%11101001 + !byte $39,%00001010 + !byte $36,%00001010 + !byte $09,%00001010 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $06,%01101010 + !byte $06,%10001011; + !byte $3E,%10101011 + !byte $05,%10101011 + !byte $04,%10101011 + !byte $00,%10101011 + !byte $04,%11001011 + !byte $03,%11101011 + !byte $3E,%01101100 + !byte $3E,%10001101; + !byte $00,%01101100 + !byte $00,%10001101; + !byte $3F,%10101101 + !byte $2D,%00001000 + !byte $13,%00001000 + !byte $0F,%01001000 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $0C,%10101001 + !byte $0A,%10101001 + !byte $39,%11001001 + !byte $35,%11101001 + !byte $39,%00101010 + !byte $3B,%11001011 + !byte $32,%01000000 + !byte $0C,%01000000 + !byte $0C,%01100000 + !byte $0C,%10000001; + !byte $2C,%00001000 + !byte $12,%00001000 + !byte $31,%00101000 + !byte $30,%01001000 + !byte $32,%01101000 + !byte $32,%10001001; + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $0A,%01101000 + !byte $0A,%10001001; + !byte $0A,%11001001 + !byte $39,%11101001 + !byte $05,%11101001 + !byte $08,%00001010 + !byte $05,%00001010 + !byte $06,%01001010 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $05,%01101010 + !byte $05,%10001011; + !byte $03,%11001011 + !byte $3C,%11101011 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $2D,%11100111 + !byte $2F,%00001000 + !byte $2F,%00101000 + !byte $0D,%00101000 + !byte $0C,%01101000 + !byte $0C,%10001001; + !byte $36,%11101001 + !byte $39,%01001010 + !byte $3A,%01101010 + !byte $3A,%10001011; + !byte $03,%01101010 + !byte $03,%10001011; + !byte $3B,%10101011 + !byte $3C,%11001011 + !byte $0C,%00100000 + !byte $2C,%11100111 + !byte $13,%11100111 + !byte $12,%11100111 + !byte $2E,%00001000 + !byte $11,%00001000 + !byte $10,%00001000 + !byte $30,%00101000 + !byte $0F,%00101000 + !byte $34,%01001000 + !byte $0D,%01001000 + !byte $0A,%01001000 + !byte $33,%01101000 + !byte $33,%10001001; + !byte $05,%10101001 + !byte $36,%11001001 + !byte $35,%11001001 + !byte $09,%11001001 + !byte $06,%11001001 + !byte $05,%11001001 + !byte $08,%11101001 + !byte $05,%01001010 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $04,%01101010 + !byte $04,%10001011; + !byte $03,%10101011 + !byte $02,%11001011 + !byte $2F,%11100111 + !byte $0D,%00001000 + !byte $0E,%00101000 + !byte $35,%01001000 + !byte $32,%01001000 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $08,%11001001 + !byte $3A,%11101001 + !byte $37,%11101001 + !byte $3A,%01001010 + !byte $33,%00000000 + !byte $0C,%00000000 + !byte $33,%00100000 + !byte $2C,%11000111 + !byte $11,%11000111 + !byte $2E,%11100111 + !byte $11,%11100111 + !byte $32,%00001000 + !byte $30,%00001000 + !byte $0F,%00001000 + !byte $35,%00101000 + !byte $33,%01001000 + !byte $0C,%01001000 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $39,%10101001 + !byte $35,%10101001 + !byte $09,%10101001 + !byte $3A,%11001001 + !byte $07,%11101001 + !byte $3A,%00101010 + !byte $05,%00101010 + !byte $3C,%01001010 + !byte $04,%01001010 + !byte $3C,%10101011 + !byte $02,%10101011 + !byte $12,%11000111 + !byte $0F,%11100111 + !byte $09,%01001000 + !byte $3A,%10101001 + !byte $36,%10101001 + !byte $3B,%01001010 + !byte $3C,%01101010 + !byte $3C,%10001011; + !byte $3D,%10101011 + !byte $0B,%00000000 + !byte $2D,%11000111 + !byte $0F,%11000111 + !byte $32,%11100111 + !byte $10,%11100111 + !byte $31,%00001000 + !byte $0E,%00001000 + !byte $32,%00101000 + !byte $0C,%00101000 + !byte $09,%00101000 + !byte $0B,%01001000 + !byte $3A,%01101000 + !byte $3A,%10001001; + !byte $09,%01101000 + !byte $09,%10001001; + !byte $04,%01101000 + !byte $04,%10001001; + !byte $08,%10101001 + !byte $04,%10101001 + !byte $37,%11001001 + !byte $07,%11001001 + !byte $04,%11001001 + !byte $04,%11101001 + !byte $04,%00101010 + !byte $03,%01001010 + !byte $02,%01001010 + !byte $02,%01101010 + !byte $02,%10001011; + !byte $01,%10101011 + !byte $10,%11000111 + !byte $0C,%11100111 + !byte $37,%10101001 + !byte $12,%01100110 + !byte $12,%10000111; + !byte $2D,%10100111 + !byte $12,%10100111 + !byte $2F,%11000111 + !byte $2E,%11000111 + !byte $0C,%11000111 + !byte $30,%11100111 + !byte $0E,%11100111 + !byte $35,%00001000 + !byte $09,%00001000 + !byte $33,%00101000 + !byte $0B,%00101000 + !byte $36,%01101000 + !byte $36,%10001001; + !byte $08,%01101000 + !byte $08,%10001001; + !byte $07,%01101000 + !byte $07,%10001001; + !byte $3B,%10101001 + !byte $07,%10101001 + !byte $38,%11001001 + !byte $3A,%00001010 + !byte $04,%00001010 + !byte $3B,%00101010 + !byte $03,%00101010 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $01,%01101010 + !byte $01,%10001011; + !byte $30,%10100111 + !byte $2E,%10100111 + !byte $11,%10100111 + !byte $30,%11000111 + !byte $31,%11100111 + !byte $36,%00001000 + !byte $0C,%00001000 + !byte $36,%00101000 + !byte $34,%00101000 + !byte $3B,%01001000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $03,%10101001 + !byte $3B,%11001001 + !byte $3B,%00001010 + !byte $3D,%01001010 + !byte $3E,%01101010 + !byte $3E,%10001011; + !byte $30,%01100110 + !byte $30,%10000111; + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $2F,%10100111 + !byte $10,%10100111 + !byte $0E,%11000111 + !byte $0D,%11100111 + !byte $33,%00001000 + !byte $0B,%00001000 + !byte $0A,%00101000 + !byte $36,%01001000 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $38,%10101001 + !byte $06,%10101001 + !byte $3C,%00001010 + !byte $03,%00001010 + !byte $3C,%00101010 + !byte $33,%11000111 + !byte $31,%11000111 + !byte $34,%00001000 + !byte $08,%00001000 + !byte $08,%01001000 + !byte $38,%01101000 + !byte $38,%10001001; + !byte $03,%01101000 + !byte $03,%10001001; + !byte $02,%00101010 + !byte $01,%00101010 + !byte $01,%01001010 + !byte $00,%01101010 + !byte $00,%10001011; + !byte $10,%01000110 + !byte $2E,%01100110 + !byte $2E,%10000111; + !byte $11,%01100110 + !byte $11,%10000111; + !byte $10,%01100110 + !byte $10,%10000111; + !byte $0E,%01100110 + !byte $0E,%10000111; + !byte $0F,%10100111 + !byte $0E,%10100111 + !byte $0D,%11000111 + !byte $36,%11100111 + !byte $33,%11100111 + !byte $0B,%11100111 + !byte $08,%11100111 + !byte $0A,%00001000 + !byte $08,%00101000 + !byte $38,%01001000 + !byte $37,%01001000 + !byte $07,%01001000 + !byte $03,%01001000 + !byte $3C,%01101000 + !byte $3C,%10001001; + !byte $06,%01101000 + !byte $06,%10001001; + !byte $3B,%11101001 + !byte $03,%11101001 + !byte $02,%00001010 + !byte $3D,%00101010 + !byte $3E,%01001010 + !byte $00,%01001010 + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $33,%10100111 + !byte $06,%01001000 + !byte $02,%01101000 + !byte $02,%10001001; + !byte $2D,%00100110 + !byte $2D,%01000110 + !byte $11,%01000110 + !byte $0E,%01000110 + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $31,%10100111 + !byte $0D,%10100111 + !byte $32,%11000111 + !byte $08,%11000111 + !byte $37,%11100111 + !byte $35,%11100111 + !byte $34,%11100111 + !byte $0A,%11100111 + !byte $3C,%00001000 + !byte $3C,%00101000 + !byte $3B,%00101000 + !byte $37,%00101000 + !byte $07,%00101000 + !byte $03,%00101000 + !byte $3C,%01001000 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $05,%01101000 + !byte $05,%10001001; + !byte $3C,%11101001 + !byte $02,%11101001 + !byte $3D,%00001010 + !byte $3E,%00101010 + !byte $3F,%01001010 + !byte $2E,%01000110 + !byte $33,%01100110 + !byte $33,%10000111; + !byte $32,%10100111 + !byte $37,%11000111 + !byte $02,%01001000 + !byte $03,%11001001 + !byte $3D,%11101001 + !byte $01,%00001010 + !byte $00,%00101010 + !byte $11,%00100110 + !byte $31,%01000110 + !byte $2F,%01000110 + !byte $0F,%01000110 + !byte $31,%01100110 + !byte $31,%10000111; + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $0C,%10100111 + !byte $34,%11000111 + !byte $0B,%11000111 + !byte $0A,%11000111 + !byte $07,%11000111 + !byte $09,%11100111 + !byte $37,%00001000 + !byte $38,%00101000 + !byte $02,%00101000 + !byte $39,%01001000 + !byte $05,%01001000 + !byte $3C,%11001001 + !byte $02,%11001001 + !byte $00,%11101001 + !byte $3E,%00001010 + !byte $00,%00001010 + !byte $3F,%00101010 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $0B,%10100111 + !byte $07,%10100111 + !byte $07,%11100111 + !byte $02,%00001000 + !byte $39,%00101000 + !byte $06,%00101000 + !byte $01,%11101001 + !byte $2F,%00000110 + !byte $11,%00000110 + !byte $31,%00100110 + !byte $2F,%00100110 + !byte $2E,%00100110 + !byte $10,%00100110 + !byte $30,%01000110 + !byte $0B,%01000110 + !byte $32,%01100110 + !byte $32,%10000111; + !byte $0C,%01100110 + !byte $0C,%10000111; + !byte $37,%10100111 + !byte $34,%10100111 + !byte $0A,%10100111 + !byte $35,%11000111 + !byte $09,%11000111 + !byte $38,%00001000 + !byte $07,%00001000 + !byte $06,%00001000 + !byte $3D,%00101000 + !byte $05,%00101000 + !byte $3D,%01001000 + !byte $3A,%01001000 + !byte $04,%01001000 + !byte $3C,%10101001 + !byte $3D,%11001001 + !byte $01,%11001001 + !byte $3F,%11101001 + !byte $3E,%11101001 + !byte $3F,%00001010 + !byte $0F,%00100110 + !byte $0D,%00100110 + !byte $34,%01000110 + !byte $0D,%01000110 + !byte $3D,%11100111 + !byte $05,%00001000 + !byte $01,%00101000 + !byte $02,%10101001 + !byte $2E,%00000110 + !byte $10,%00000110 + !byte $30,%00100110 + !byte $0E,%00100110 + !byte $32,%01000110 + !byte $34,%01100110 + !byte $34,%10000111; + !byte $07,%01100110 + !byte $07,%10000111; + !byte $38,%10100111 + !byte $35,%10100111 + !byte $36,%11000111 + !byte $38,%11100111 + !byte $3D,%00001000 + !byte $39,%00001000 + !byte $01,%00001000 + !byte $3A,%00101000 + !byte $04,%00101000 + !byte $3D,%10101001 + !byte $01,%10101001 + !byte $3E,%11001001 + !byte $0D,%00000110 + !byte $34,%00100110 + !byte $0C,%01000110 + !byte $38,%01100110 + !byte $38,%10000111; + !byte $09,%10100111 + !byte $38,%11000111 + !byte $01,%01001000 + !byte $2E,%11100101 + !byte $0F,%11100101 + !byte $0D,%11100101 + !byte $30,%00000110 + !byte $0F,%00000110 + !byte $32,%00100110 + !byte $0A,%00100110 + !byte $33,%01000110 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $0A,%01100110 + !byte $0A,%10000111; + !byte $06,%01100110 + !byte $06,%10000111; + !byte $36,%10100111 + !byte $08,%10100111 + !byte $01,%11000111 + !byte $3A,%11100111 + !byte $39,%11100111 + !byte $06,%11100111 + !byte $02,%11100111 + !byte $01,%11100111 + !byte $3E,%00001000 + !byte $3A,%00001000 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $3E,%10101001 + !byte $00,%10101001 + !byte $3F,%11001001 + !byte $00,%11001001 + !byte $10,%11100101 + !byte $0E,%00000110 + !byte $0C,%00100110 + !byte $0A,%01000110 + !byte $06,%01000110 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $06,%10100111 + !byte $05,%11100111 + !byte $04,%00001000 + !byte $00,%00001000 + !byte $3E,%00101000 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $32,%11100101 + !byte $2F,%11100101 + !byte $0E,%11100101 + !byte $34,%00000110 + !byte $31,%00000110 + !byte $0A,%00000110 + !byte $33,%00100110 + !byte $0B,%00100110 + !byte $38,%01000110 + !byte $35,%01000110 + !byte $36,%01100110 + !byte $36,%10000111; + !byte $08,%01100110 + !byte $08,%10000111; + !byte $3E,%10100111 + !byte $3D,%11000111 + !byte $39,%11000111 + !byte $06,%11000111 + !byte $04,%11000111 + !byte $3E,%11100111 + !byte $04,%11100111 + !byte $00,%11100111 + !byte $3B,%00001000 + !byte $03,%00001000 + !byte $3E,%01101000 + !byte $3E,%10001001; + !byte $00,%01101000 + !byte $00,%10001001; + !byte $3F,%10101001 + !byte $2E,%11000101 + !byte $30,%11100101 + !byte $09,%01000110 + !byte $00,%10100111 + !byte $3E,%11000111 + !byte $05,%11000111 + !byte $00,%00101000 + !byte $32,%11000101 + !byte $30,%11000101 + !byte $2F,%11000101 + !byte $10,%11000101 + !byte $0F,%11000101 + !byte $35,%11100101 + !byte $31,%11100101 + !byte $35,%00000110 + !byte $33,%00000110 + !byte $32,%00000110 + !byte $0C,%00000110 + !byte $06,%00100110 + !byte $39,%01000110 + !byte $36,%01000110 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $37,%01100110 + !byte $37,%10000111; + !byte $3A,%11000111 + !byte $00,%11000111 + !byte $3F,%11100111 + !byte $3B,%11100111 + !byte $3E,%01001000 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $30,%10100101 + !byte $0A,%11100101 + !byte $39,%00100110 + !byte $35,%00100110 + !byte $08,%01000110 + !byte $39,%10100111 + !byte $3F,%11000111 + !byte $3B,%11000111 + !byte $03,%11100111 + !byte $3F,%00001000 + !byte $2F,%10100101 + !byte $10,%10100101 + !byte $31,%11000101 + !byte $0E,%11000101 + !byte $0C,%11100101 + !byte $09,%11100101 + !byte $0B,%00000110 + !byte $36,%00100110 + !byte $09,%00100110 + !byte $05,%00100110 + !byte $37,%01000110 + !byte $05,%01000110 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $3A,%10100111 + !byte $05,%10100111 + !byte $3C,%11100111 + !byte $3F,%01001000 + !byte $00,%01001000 + !byte $10,%01100100 + !byte $10,%10000101; + !byte $32,%10100101 + !byte $0C,%10100101 + !byte $0D,%11000101 + !byte $0C,%11000101 + !byte $33,%11100101 + !byte $05,%00000110 + !byte $07,%01000110 + !byte $3F,%10100111 + !byte $03,%11000111 + !byte $0E,%01100100 + !byte $0E,%10000101; + !byte $31,%10100101 + !byte $0F,%10100101 + !byte $0E,%10100101 + !byte $35,%11000101 + !byte $09,%11000101 + !byte $34,%11100101 + !byte $0B,%11100101 + !byte $39,%00000110 + !byte $09,%00000110 + !byte $37,%00100110 + !byte $08,%00100110 + !byte $07,%00100110 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $3B,%10100111 + !byte $04,%10100111 + !byte $03,%10100111 + !byte $3C,%11000111 + !byte $3F,%00101000 + !byte $0D,%10100101 + !byte $02,%11000111 + !byte $0E,%01000100 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $30,%01100100 + !byte $30,%10000101; + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $0C,%01100100 + !byte $0C,%10000101; + !byte $36,%11000101 + !byte $34,%11000101 + !byte $33,%11000101 + !byte $0B,%11000101 + !byte $3A,%00000110 + !byte $37,%00000110 + !byte $36,%00000110 + !byte $08,%00000110 + !byte $3A,%00100110 + !byte $38,%00100110 + !byte $3A,%01100110 + !byte $3A,%10000111; + !byte $04,%01100110 + !byte $04,%10000111; + !byte $00,%01100110 + !byte $00,%10000111; + !byte $3C,%10100111 + !byte $36,%10100101 + !byte $33,%10100101 + !byte $09,%10100101 + !byte $3A,%11100101 + !byte $04,%00000110 + !byte $3A,%01000110 + !byte $3C,%01100110 + !byte $3C,%10000111; + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $2F,%01000100 + !byte $0F,%01000100 + !byte $36,%01100100 + !byte $36,%10000101; + !byte $31,%01100100 + !byte $31,%10000101; + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $0B,%10100101 + !byte $08,%10100101 + !byte $0A,%11000101 + !byte $36,%11100101 + !byte $08,%11100101 + !byte $05,%11100101 + !byte $04,%11100101 + !byte $38,%00000110 + !byte $07,%00000110 + !byte $04,%01000110 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $3D,%10100111 + !byte $02,%10100111 + !byte $33,%01000100 + !byte $32,%01100100 + !byte $32,%10000101; + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $04,%11000101 + !byte $06,%00000110 + !byte $04,%00100110 + !byte $3F,%01000110 + !byte $02,%01000110 + !byte $02,%01100110 + !byte $02,%10000111; + !byte $01,%10100111 + !byte $31,%00100100 + !byte $2F,%00100100 + !byte $31,%01000100 + !byte $30,%01000100 + !byte $0D,%01000100 + !byte $0B,%01000100 + !byte $08,%01100100 + !byte $08,%10000101; + !byte $34,%10100101 + !byte $0A,%10100101 + !byte $3A,%11000101 + !byte $08,%11000101 + !byte $37,%11100101 + !byte $07,%11100101 + !byte $3B,%01000110 + !byte $03,%01000110 + !byte $30,%00100100 + !byte $0F,%00100100 + !byte $32,%01000100 + !byte $35,%10100101 + !byte $3B,%11100101 + !byte $38,%11100101 + !byte $3C,%01000110 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $0E,%00100100 + !byte $0B,%00100100 + !byte $0C,%01000100 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $34,%01100100 + !byte $34,%10000101; + !byte $0A,%01100100 + !byte $0A,%10000101; + !byte $3B,%11000101 + !byte $37,%11000101 + !byte $07,%11000101 + !byte $39,%11100101 + !byte $06,%11100101 + !byte $3D,%00100110 + !byte $3B,%00100110 + !byte $03,%00100110 + !byte $3D,%01000110 + !byte $3E,%01100110 + !byte $3E,%10000111; + !byte $01,%01100110 + !byte $01,%10000111; + !byte $34,%00100100 + !byte $3B,%10100101 + !byte $38,%11000101 + !byte $03,%11000101 + !byte $3B,%00000110 + !byte $3C,%00100110 + !byte $30,%00000100 + !byte $0F,%00000100 + !byte $0E,%00000100 + !byte $0D,%00000100 + !byte $32,%00100100 + !byte $0D,%00100100 + !byte $0C,%00100100 + !byte $37,%01000100 + !byte $34,%01000100 + !byte $0A,%01000100 + !byte $08,%01000100 + !byte $07,%01000100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $09,%01100100 + !byte $09,%10000101; + !byte $03,%01100100 + !byte $03,%10000101; + !byte $37,%10100101 + !byte $07,%10100101 + !byte $04,%10100101 + !byte $03,%10100101 + !byte $39,%11000101 + !byte $06,%11000101 + !byte $03,%00000110 + !byte $02,%00100110 + !byte $01,%00100110 + !byte $01,%01000110 + !byte $37,%00100100 + !byte $03,%11100101 + !byte $3E,%01000110 + !byte $0F,%11100011 + !byte $0E,%11100011 + !byte $34,%00000100 + !byte $32,%00000100 + !byte $31,%00000100 + !byte $0C,%00000100 + !byte $0A,%00000100 + !byte $33,%00100100 + !byte $07,%00100100 + !byte $35,%01000100 + !byte $09,%01000100 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $38,%10100101 + !byte $06,%10100101 + !byte $05,%11000101 + !byte $3C,%00000110 + !byte $02,%00000110 + !byte $00,%01000110 + !byte $34,%11100011 + !byte $30,%11100011 + !byte $3C,%01000100 + !byte $36,%01000100 + !byte $3C,%10100101 + !byte $39,%10100101 + !byte $3C,%11000101 + !byte $3E,%00000110 + !byte $3E,%00100110 + !byte $32,%11000011 + !byte $30,%11000011 + !byte $32,%11100011 + !byte $31,%11100011 + !byte $0D,%11100011 + !byte $0A,%11100011 + !byte $33,%00000100 + !byte $0B,%00000100 + !byte $07,%00000100 + !byte $35,%00100100 + !byte $0A,%00100100 + !byte $09,%00100100 + !byte $3C,%01100100 + !byte $3C,%10000101; + !byte $38,%01100100 + !byte $38,%10000101; + !byte $07,%01100100 + !byte $07,%10000101; + !byte $05,%10100101 + !byte $3C,%11100101 + !byte $02,%11100101 + !byte $3D,%00000110 + !byte $01,%00000110 + !byte $00,%00100110 + !byte $38,%00100100 + !byte $06,%01100100 + !byte $06,%10000101; + !byte $02,%01100100 + !byte $02,%10000101; + !byte $3A,%10100101 + !byte $02,%10100101 + !byte $3F,%00100110 + !byte $30,%10100011 + !byte $31,%11000011 + !byte $0E,%11000011 + !byte $0A,%11000011 + !byte $33,%11100011 + !byte $0C,%11100011 + !byte $0B,%11100011 + !byte $38,%00000100 + !byte $35,%00000100 + !byte $36,%00100100 + !byte $08,%00100100 + !byte $02,%00100100 + !byte $38,%01000100 + !byte $03,%01000100 + !byte $02,%01000100 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $05,%01100100 + !byte $05,%10000101; + !byte $3D,%11100101 + !byte $01,%11100101 + !byte $00,%11100101 + !byte $00,%00000110 + !byte $32,%10100011 + !byte $0D,%11000011 + !byte $0C,%11000011 + !byte $09,%00000100 + !byte $06,%00000100 + !byte $06,%01000100 + !byte $3A,%01100100 + !byte $3A,%10000101; + !byte $02,%11000101 + !byte $0E,%01100010 + !byte $0E,%10000011; + !byte $0E,%10100011 + !byte $0C,%10100011 + !byte $35,%11000011 + !byte $33,%11000011 + !byte $0B,%11000011 + !byte $38,%11100011 + !byte $36,%00000100 + !byte $08,%00000100 + !byte $3C,%00100100 + !byte $3D,%01000100 + !byte $39,%01000100 + !byte $05,%01000100 + !byte $04,%01100100 + !byte $04,%10000101; + !byte $3D,%11000101 + !byte $01,%11000101 + !byte $3E,%11100101 + !byte $3F,%00000110 + !byte $35,%10100011 + !byte $31,%10100011 + !byte $35,%11100011 + !byte $06,%11100011 + !byte $3D,%00000100 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $3F,%11000101 + !byte $3F,%11100101 + !byte $0C,%01100010 + !byte $0C,%10000011; + !byte $0D,%10100011 + !byte $34,%11000011 + !byte $06,%11000011 + !byte $36,%11100011 + !byte $09,%11100011 + !byte $37,%00000100 + !byte $3D,%00100100 + !byte $39,%00100100 + !byte $06,%00100100 + !byte $3A,%01000100 + !byte $04,%01000100 + !byte $3D,%10100101 + !byte $3E,%11000101 + !byte $09,%10100011 + !byte $09,%11000011 + !byte $08,%11100011 + !byte $05,%00100100 + !byte $01,%00100100 + !byte $01,%01000100 + !byte $00,%11000101 + !byte $35,%01100010 + !byte $35,%10000011; + !byte $31,%01100010 + !byte $31,%10000011; + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $09,%01100010 + !byte $09,%10000011; + !byte $34,%10100011 + !byte $33,%10100011 + !byte $0B,%10100011 + !byte $38,%11000011 + !byte $37,%11100011 + !byte $07,%11100011 + !byte $01,%11100011 + !byte $02,%00000100 + !byte $01,%00000100 + !byte $3A,%00100100 + !byte $04,%00100100 + !byte $3B,%01000100 + !byte $3E,%10100101 + !byte $01,%10100101 + !byte $00,%10100101 + !byte $32,%01100010 + !byte $32,%10000011; + !byte $0A,%10100011 + !byte $39,%11000011 + !byte $36,%11000011 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $31,%00100010 + !byte $33,%01000010 + !byte $31,%01000010 + !byte $0D,%01000010 + !byte $09,%01000010 + !byte $36,%01100010 + !byte $36,%10000011; + !byte $34,%01100010 + !byte $34,%10000011; + !byte $33,%01100010 + !byte $33,%10000011; + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $39,%10100011 + !byte $06,%10100011 + !byte $37,%11000011 + !byte $08,%11000011 + !byte $3E,%00000100 + !byte $3A,%00000100 + !byte $39,%00000100 + !byte $05,%00000100 + !byte $04,%00000100 + !byte $3E,%00100100 + !byte $3B,%00100100 + !byte $03,%00100100 + !byte $3E,%01100100 + !byte $3E,%10000101; + !byte $3F,%10100101 + !byte $3E,%11000011 + !byte $07,%11000011 + !byte $05,%11000011 + !byte $39,%11100011 + !byte $33,%00100010 + !byte $36,%01000010 + !byte $32,%01000010 + !byte $0C,%01000010 + !byte $0A,%01100010 + !byte $0A,%10000011; + !byte $37,%10100011 + !byte $36,%10100011 + !byte $08,%10100011 + !byte $05,%10100011 + !byte $3E,%11100011 + !byte $3D,%11100011 + !byte $3A,%11100011 + !byte $05,%11100011 + !byte $3B,%00000100 + !byte $03,%00000100 + !byte $3E,%01000100 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $00,%01100100 + !byte $00,%10000101; + !byte $0D,%00000010 + !byte $0D,%00100010 + !byte $0B,%00100010 + !byte $0B,%01000010 + !byte $08,%01000010 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $05,%01100010 + !byte $05,%10000011; + !byte $04,%11100011 + !byte $00,%11100011 + !byte $00,%00000100 + !byte $0B,%00000010 + !byte $36,%00100010 + !byte $32,%00100010 + !byte $0C,%00100010 + !byte $34,%01000010 + !byte $0A,%01000010 + !byte $08,%01100010 + !byte $08,%10000011; + !byte $38,%10100011 + !byte $07,%10100011 + !byte $00,%10100011 + !byte $00,%11000011 + !byte $3B,%11100011 + !byte $3C,%00000100 + !byte $3F,%01000100 + !byte $00,%01000100 + !byte $08,%00100010 + !byte $3A,%01100010 + !byte $3A,%10000011; + !byte $03,%11100011 + !byte $00,%00100100 + !byte $36,%00000010 + !byte $32,%00000010 + !byte $34,%00100010 + !byte $0A,%00100010 + !byte $3A,%01000010 + !byte $35,%01000010 + !byte $05,%01000010 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $07,%01100010 + !byte $07,%10000011; + !byte $3F,%11000011 + !byte $3A,%11000011 + !byte $04,%11000011 + !byte $01,%11000011 + !byte $3F,%11100011 + !byte $3C,%11100011 + !byte $0C,%00000010 + !byte $08,%00000010 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $38,%01100010 + !byte $38,%10000011; + !byte $3B,%11000011 + !byte $02,%11100011 + !byte $3F,%00100100 + !byte $34,%11100001 + !byte $37,%00000010 + !byte $34,%00000010 + !byte $33,%00000010 + !byte $3A,%00100010 + !byte $35,%00100010 + !byte $09,%00100010 + !byte $37,%01000010 + !byte $07,%01000010 + !byte $04,%01000010 + !byte $06,%01100010 + !byte $06,%10000011; + !byte $3F,%10100011 + !byte $3E,%10100011 + !byte $3B,%10100011 + !byte $3A,%10100011 + !byte $04,%10100011 + !byte $3C,%11000011 + !byte $03,%11000011 + !byte $02,%11000011 + !byte $04,%00100010 + !byte $3F,%00000100 + !byte $34,%11000001 + !byte $33,%11100001 + !byte $32,%11100001 + !byte $0C,%11100001 + !byte $0B,%11100001 + !byte $35,%00000010 + !byte $0A,%00000010 + !byte $09,%00000010 + !byte $37,%00100010 + !byte $07,%00100010 + !byte $38,%01000010 + !byte $06,%01000010 + !byte $04,%01100010 + !byte $04,%10000011; + !byte $3C,%10100011 + !byte $03,%10100011 + !byte $3D,%11000011 + !byte $0A,%11000001 + !byte $37,%11100001 + !byte $0A,%11100001 + !byte $02,%10100011 + !byte $37,%11000001 + !byte $33,%11000001 + !byte $0C,%11000001 + !byte $35,%11100001 + !byte $09,%11100001 + !byte $3B,%00000010 + !byte $3A,%00000010 + !byte $04,%00000010 + !byte $3B,%00100010 + !byte $38,%00100010 + !byte $06,%00100010 + !byte $39,%01000010 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $03,%01100010 + !byte $03,%10000011; + !byte $00,%01100010 + !byte $00,%10000011; + !byte $3D,%10100011 + !byte $07,%11100001 + !byte $39,%00100010 + !byte $33,%10100001 + !byte $0C,%10100001 + !byte $0A,%10100001 + !byte $07,%10100001 + !byte $0B,%11000001 + !byte $07,%11000001 + !byte $3B,%11100001 + !byte $36,%11100001 + !byte $08,%11100001 + !byte $38,%00000010 + !byte $07,%00000010 + !byte $06,%00000010 + !byte $03,%00000010 + !byte $05,%00100010 + !byte $3F,%01000010 + !byte $3B,%01000010 + !byte $03,%01000010 + !byte $3C,%01100010 + !byte $3C,%10000011; + !byte $02,%01100010 + !byte $02,%10000011; + !byte $01,%10100011 + !byte $3C,%01000010 + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $37,%10100001 + !byte $34,%10100001 + !byte $0B,%10100001 + !byte $36,%11000001 + !byte $35,%11000001 + !byte $09,%11000001 + !byte $08,%11000001 + !byte $03,%11100001 + !byte $39,%00000010 + !byte $05,%00000010 + !byte $3D,%01000010 + !byte $02,%01000010 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $35,%01100000 + !byte $35,%10000001; + !byte $38,%10100001 + !byte $35,%10100001 + !byte $03,%11000001 + !byte $38,%11100001 + !byte $3E,%01100010 + !byte $3E,%10000011; + !byte $33,%01100000 + !byte $33,%10000001; + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $07,%01100000 + !byte $07,%10000001; + !byte $36,%10100001 + !byte $09,%10100001 + !byte $3B,%11000001 + !byte $38,%11000001 + !byte $3C,%11100001 + !byte $39,%11100001 + !byte $06,%11100001 + !byte $3C,%00100010 + !byte $03,%00100010 + !byte $02,%00100010 + !byte $3E,%01000010 + !byte $01,%01000010 + !byte $35,%01000000 + !byte $38,%01100000 + !byte $38,%10000001; + !byte $3C,%11000001 + !byte $05,%11100001 + !byte $33,%01000000 + !byte $0B,%01000000 + !byte $09,%01000000 + !byte $34,%01100000 + !byte $34,%10000001; + !byte $0A,%01100000 + !byte $0A,%10000001; + !byte $09,%01100000 + !byte $09,%10000001; + !byte $06,%01100000 + !byte $06,%10000001; + !byte $08,%10100001 + !byte $06,%11000001 + !byte $02,%11000001 + !byte $3A,%11100001 + !byte $04,%11100001 + !byte $3D,%00100010 + !byte $01,%00100010 + !byte $00,%01000010 + !byte $38,%01000000 + !byte $08,%01100000 + !byte $08,%10000001; + !byte $3C,%10100001 + !byte $06,%10100001 + !byte $03,%10100001 + !byte $39,%11000001 + !byte $05,%11000001 + !byte $3C,%00000010 + !byte $02,%00000010 + !byte $35,%00100000 + !byte $09,%00100000 + !byte $34,%01000000 + !byte $0A,%01000000 + !byte $06,%01000000 + !byte $3C,%01100000 + !byte $3C,%10000001; + !byte $36,%01100000 + !byte $36,%10000001; + !byte $02,%10100001 + !byte $3A,%11000001 + !byte $04,%11000001 + !byte $3D,%00000010 + !byte $01,%00000010 + !byte $3E,%00100010 + !byte $00,%00100010 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $39,%10100001 + !byte $3F,%00100010 + !byte $09,%00000000 + !byte $34,%00100000 + !byte $0B,%00100000 + !byte $06,%00100000 + !byte $39,%01000000 + !byte $36,%01000000 + !byte $08,%01000000 + !byte $02,%01100000 + !byte $02,%10000001; + !byte $3A,%10100001 + !byte $05,%10100001 + !byte $3D,%11100001 + !byte $02,%11100001 + !byte $3F,%00000010 + !byte $3E,%00000010 + !byte $00,%00000010 + !byte $36,%00100000 + !byte $0A,%00100000 + !byte $37,%01000000 + !byte $3D,%10100001 + !byte $01,%11100001 + !byte $34,%00000000 + !byte $0A,%00000000 + !byte $39,%00100000 + !byte $05,%00100000 + !byte $07,%01000000 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $39,%01100000 + !byte $39,%10000001; + !byte $05,%01100000 + !byte $05,%10000001; + !byte $01,%01100000 + !byte $01,%10000001; + !byte $3B,%10100001 + !byte $04,%10100001 + !byte $3E,%11100001 + !byte $00,%11100001 + !byte $36,%00000000 + !byte $37,%00100000 + !byte $08,%00100000 + !byte $3C,%01000000 + !byte $04,%01100000 + !byte $04,%10000001; + !byte $39,%00000000 + !byte $35,%00000000 + !byte $05,%00000000 + !byte $3D,%00100000 + !byte $07,%00100000 + !byte $3D,%01000000 + !byte $05,%01000000 + !byte $02,%01000000 + !byte $01,%01000000 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $3A,%01100000 + !byte $3A,%10000001; + !byte $03,%01100000 + !byte $03,%10000001; + !byte $3E,%11000001 + !byte $3D,%11000001 + !byte $01,%11000001 + !byte $3F,%11100001 + !byte $38,%00100000 + !byte $3A,%01000000 + !byte $37,%00000000 + !byte $08,%00000000 + !byte $07,%00000000 + !byte $02,%00100000 + !byte $01,%00100000 + !byte $04,%01000000 + !byte $3E,%10100001 + !byte $01,%10100001 + !byte $3F,%11000001 + !byte $00,%11000001 + !byte $3B,%01000000 + !byte $00,%10100001 + !byte $38,%00000000 + !byte $06,%00000000 + !byte $3E,%00100000 + !byte $3A,%00100000 + !byte $04,%00100000 + !byte $03,%01000000 + !byte $3F,%10100001 + !byte $3B,%00100000 + !byte $00,%00100000 + !byte $3E,%00000000 + !byte $3A,%00000000 + !byte $01,%00000000 + !byte $3C,%00100000 + !byte $03,%00100000 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $3E,%01100000 + !byte $3E,%10000001; + !byte $00,%01100000 + !byte $00,%10000001; + !byte $04,%00000000 + !byte $00,%00000000 + !byte $3E,%01000000 + !byte $3B,%00000000 + !byte $03,%00000000 + !byte $3F,%01000000 + !byte $00,%01000000 + !byte $3C,%00000000 + !byte $02,%00000000 + !byte $3D,%00000000 + !byte $3F,%00100000 + !byte $3F,%00000000 diff --git a/src/fx/fx.hgr.mandelbrot.in.a b/src/fx/fx.hgr.mandelbrot.in.a new file mode 100644 index 0000000..c4d3284 --- /dev/null +++ b/src/fx/fx.hgr.mandelbrot.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MANDELBROT.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_REVERSE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/MANDELBROT.DATA" diff --git a/src/fx/fx.hgr.mandelbrot.ripple.a b/src/fx/fx.hgr.mandelbrot.ripple.a new file mode 100644 index 0000000..b034424 --- /dev/null +++ b/src/fx/fx.hgr.mandelbrot.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MANDELBROT.RIP",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.3bit.a" + + +FX_INITONCE_3BIT CoordinatesFile, Start + +FX_RIPPLE_3BIT +Start + +FX_PRECOMPUTED_3BIT Coordinates3Bit + +CoordinatesFile + !byte 18 + !text "FX/MANDELBROT.DATA" diff --git a/src/fx/fx.hgr.maple.a b/src/fx/fx.hgr.maple.a new file mode 100644 index 0000000..9524983 --- /dev/null +++ b/src/fx/fx.hgr.maple.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MAPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/MAPLE.DATA" diff --git a/src/fx/fx.hgr.maple.data.a b/src/fx/fx.hgr.maple.data.a new file mode 100644 index 0000000..05027bf --- /dev/null +++ b/src/fx/fx.hgr.maple.data.a @@ -0,0 +1,7683 @@ +!cpu 6502 +!to "build/FX/MAPLE.DATA",plain +*=$8100 + !byte $61,%11110011 + !byte $5F,%11010011 + !byte $61,%10110011 + !byte $5F,%10110011 + !byte $63,%11010011 + !byte $61,%11010011 + !byte $63,%11110011 + !byte $5F,%11110011 + !byte $5D,%11110011 + !byte $5F,%01110010 + !byte $5F,%10010011; + !byte $5D,%01110010 + !byte $5D,%10010011; + !byte $5D,%10110011 + !byte $5B,%11110011 + !byte $5F,%01010010 + !byte $5D,%01010010 + !byte $61,%01110010 + !byte $61,%10010011; + !byte $65,%10110011 + !byte $63,%10110011 + !byte $65,%11010011 + !byte $59,%11010011 + !byte $59,%11110011 + !byte $5F,%00110010 + !byte $5D,%00110010 + !byte $61,%01010010 + !byte $63,%01110010 + !byte $63,%10010011; + !byte $57,%11010011 + !byte $65,%11110011 + !byte $57,%11110011 + !byte $61,%00010010 + !byte $5F,%00010010 + !byte $5D,%00010010 + !byte $63,%00110010 + !byte $61,%00110010 + !byte $63,%01010010 + !byte $5B,%01010010 + !byte $67,%01110010 + !byte $67,%10010011; + !byte $65,%01110010 + !byte $65,%10010011; + !byte $67,%10110011 + !byte $67,%11010011 + !byte $5D,%11010011 + !byte $5B,%11010011 + !byte $67,%11110011 + !byte $55,%11110011 + !byte $61,%11110001 + !byte $5F,%11110001 + !byte $5D,%11110001 + !byte $5B,%11110001 + !byte $5B,%00010010 + !byte $5B,%00110010 + !byte $65,%01010010 + !byte $69,%01110010 + !byte $69,%10010011; + !byte $55,%10110011 + !byte $55,%11010011 + !byte $53,%11110011 + !byte $61,%11010001 + !byte $5F,%11010001 + !byte $5D,%11010001 + !byte $5B,%11010001 + !byte $63,%11110001 + !byte $63,%00010010 + !byte $65,%00110010 + !byte $69,%01010010 + !byte $67,%01010010 + !byte $69,%10110011 + !byte $5B,%10110011 + !byte $59,%10110011 + !byte $57,%10110011 + !byte $69,%11010011 + !byte $53,%11010011 + !byte $69,%11110011 + !byte $51,%11110011 + !byte $61,%10110001 + !byte $5F,%10110001 + !byte $5B,%10110001 + !byte $59,%10110001 + !byte $59,%11010001 + !byte $65,%00010010 + !byte $59,%00010010 + !byte $59,%00110010 + !byte $53,%10110011 + !byte $51,%11010011 + !byte $4F,%11110011 + !byte $61,%01110000 + !byte $61,%10010001; + !byte $5F,%01110000 + !byte $5F,%10010001; + !byte $5D,%01110000 + !byte $5D,%10010001; + !byte $5B,%01110000 + !byte $5B,%10010001; + !byte $59,%01110000 + !byte $59,%10010001; + !byte $63,%10110001 + !byte $5D,%10110001 + !byte $63,%11010001 + !byte $65,%11110001 + !byte $59,%11110001 + !byte $67,%00010010 + !byte $6B,%00110010 + !byte $69,%00110010 + !byte $67,%00110010 + !byte $6B,%01010010 + !byte $6B,%01110010 + !byte $6B,%10010011; + !byte $5B,%01110010 + !byte $5B,%10010011; + !byte $55,%01110010 + !byte $55,%10010011; + !byte $53,%01110010 + !byte $53,%10010011; + !byte $51,%01110010 + !byte $51,%10010011; + !byte $6B,%10110011 + !byte $51,%10110011 + !byte $6B,%11010011 + !byte $4F,%11010011 + !byte $6B,%11110011 + !byte $4D,%11110011 + !byte $61,%01010000 + !byte $5B,%01010000 + !byte $59,%01010000 + !byte $63,%01110000 + !byte $63,%10010001; + !byte $65,%11010001 + !byte $67,%11110001 + !byte $57,%11110001 + !byte $69,%00010010 + !byte $6D,%00110010 + !byte $6D,%01010010 + !byte $6D,%01110010 + !byte $6D,%10010011; + !byte $4F,%01110010 + !byte $4F,%10010011; + !byte $6D,%10110011 + !byte $4F,%10110011 + !byte $4B,%11110011 + !byte $57,%00010000 + !byte $61,%00110000 + !byte $5F,%00110000 + !byte $5D,%00110000 + !byte $5B,%00110000 + !byte $59,%00110000 + !byte $57,%00110000 + !byte $63,%01010000 + !byte $5F,%01010000 + !byte $5D,%01010000 + !byte $65,%01110000 + !byte $65,%10010001; + !byte $65,%10110001 + !byte $67,%11010001 + !byte $57,%11010001 + !byte $55,%11010001 + !byte $69,%11110001 + !byte $6D,%00010010 + !byte $6B,%00010010 + !byte $51,%01010010 + !byte $4F,%01010010 + !byte $4D,%01010010 + !byte $59,%01110010 + !byte $59,%10010011; + !byte $57,%01110010 + !byte $57,%10010011; + !byte $6D,%11010011 + !byte $4D,%11010011 + !byte $4B,%11010011 + !byte $6D,%11110011 + !byte $49,%11110011 + !byte $61,%00010000 + !byte $5B,%00010000 + !byte $59,%00010000 + !byte $63,%00110000 + !byte $65,%01010000 + !byte $57,%01010000 + !byte $67,%10110001 + !byte $57,%10110001 + !byte $69,%11010001 + !byte $6F,%00010010 + !byte $6F,%00110010 + !byte $6F,%01010010 + !byte $6F,%01110010 + !byte $6F,%10010011; + !byte $4D,%01110010 + !byte $4D,%10010011; + !byte $4D,%10110011 + !byte $47,%11110011 + !byte $55,%11001111 + !byte $61,%11101111 + !byte $5F,%11101111 + !byte $5B,%11101111 + !byte $59,%11101111 + !byte $57,%11101111 + !byte $55,%11101111 + !byte $63,%00010000 + !byte $5F,%00010000 + !byte $5D,%00010000 + !byte $65,%00110000 + !byte $67,%01110000 + !byte $67,%10010001; + !byte $57,%01110000 + !byte $57,%10010001; + !byte $69,%10110001 + !byte $55,%10110001 + !byte $53,%10110001 + !byte $6F,%11110001 + !byte $6D,%11110001 + !byte $6B,%11110001 + !byte $4B,%00110010 + !byte $49,%00110010 + !byte $59,%01010010 + !byte $55,%01010010 + !byte $53,%01010010 + !byte $4B,%01010010 + !byte $4B,%01110010 + !byte $4B,%10010011; + !byte $6F,%10110011 + !byte $4B,%10110011 + !byte $6F,%11010011 + !byte $49,%11010011 + !byte $47,%11010011 + !byte $6F,%11110011 + !byte $45,%11110011 + !byte $43,%11110011 + !byte $61,%11001111 + !byte $5F,%11001111 + !byte $59,%11001111 + !byte $57,%11001111 + !byte $63,%11101111 + !byte $5D,%11101111 + !byte $55,%00010000 + !byte $67,%01010000 + !byte $69,%01110000 + !byte $69,%10010001; + !byte $55,%01110000 + !byte $55,%10010001; + !byte $53,%01110000 + !byte $53,%10010001; + !byte $71,%11010001 + !byte $6B,%11010001 + !byte $71,%11110001 + !byte $71,%00010010 + !byte $71,%00110010 + !byte $49,%01010010 + !byte $49,%01110010 + !byte $49,%10010011; + !byte $49,%10110011 + !byte $61,%01101110 + !byte $61,%10001111; + !byte $53,%01101110 + !byte $53,%10001111; + !byte $61,%10101111 + !byte $5F,%10101111 + !byte $59,%10101111 + !byte $57,%10101111 + !byte $55,%10101111 + !byte $63,%11001111 + !byte $5D,%11001111 + !byte $5B,%11001111 + !byte $65,%11101111 + !byte $65,%00010000 + !byte $67,%00110000 + !byte $55,%00110000 + !byte $69,%01010000 + !byte $55,%01010000 + !byte $53,%01010000 + !byte $6B,%10110001 + !byte $6F,%11010001 + !byte $6D,%11010001 + !byte $47,%00010010 + !byte $51,%00110010 + !byte $4F,%00110010 + !byte $4D,%00110010 + !byte $47,%00110010 + !byte $71,%01010010 + !byte $57,%01010010 + !byte $71,%01110010 + !byte $71,%10010011; + !byte $71,%10110011 + !byte $47,%10110011 + !byte $71,%11010011 + !byte $45,%11010011 + !byte $43,%11010011 + !byte $83,%11110011 + !byte $81,%11110011 + !byte $71,%11110011 + !byte $41,%11110011 + !byte $61,%01001110 + !byte $57,%01101110 + !byte $57,%10001111; + !byte $55,%01101110 + !byte $55,%10001111; + !byte $63,%10101111 + !byte $5D,%10101111 + !byte $5B,%10101111 + !byte $65,%11001111 + !byte $67,%00010000 + !byte $69,%00110000 + !byte $6B,%01010000 + !byte $51,%01010000 + !byte $6B,%01110000 + !byte $6B,%10010001; + !byte $73,%10110001 + !byte $6D,%10110001 + !byte $73,%11010001 + !byte $73,%11110001 + !byte $73,%00010010 + !byte $45,%00010010 + !byte $73,%00110010 + !byte $73,%01010010 + !byte $47,%01010010 + !byte $73,%01110010 + !byte $73,%10010011; + !byte $47,%01110010 + !byte $47,%10010011; + !byte $73,%10110011 + !byte $45,%10110011 + !byte $3F,%11110011 + !byte $61,%00101110 + !byte $53,%00101110 + !byte $63,%01001110 + !byte $5F,%01001110 + !byte $59,%01001110 + !byte $57,%01001110 + !byte $55,%01001110 + !byte $53,%01001110 + !byte $63,%01101110 + !byte $63,%10001111; + !byte $5F,%01101110 + !byte $5F,%10001111; + !byte $5D,%01101110 + !byte $5D,%10001111; + !byte $5B,%01101110 + !byte $5B,%10001111; + !byte $59,%01101110 + !byte $59,%10001111; + !byte $65,%10101111 + !byte $67,%11001111 + !byte $67,%11101111 + !byte $69,%00010000 + !byte $6B,%00110000 + !byte $53,%00110000 + !byte $51,%00110000 + !byte $6D,%01010000 + !byte $75,%01110000 + !byte $75,%10010001; + !byte $6D,%01110000 + !byte $6D,%10010001; + !byte $75,%10110001 + !byte $71,%10110001 + !byte $6F,%10110001 + !byte $75,%11010001 + !byte $4D,%00010010 + !byte $4B,%00010010 + !byte $49,%00010010 + !byte $57,%00110010 + !byte $55,%00110010 + !byte $53,%00110010 + !byte $45,%00110010 + !byte $45,%01110010 + !byte $45,%10010011; + !byte $43,%10110011 + !byte $73,%11010011 + !byte $41,%11010011 + !byte $3F,%11010011 + !byte $87,%11110011 + !byte $85,%11110011 + !byte $73,%11110011 + !byte $3D,%11110011 + !byte $61,%00001110 + !byte $5F,%00101110 + !byte $57,%00101110 + !byte $55,%00101110 + !byte $5D,%01001110 + !byte $5B,%01001110 + !byte $65,%01101110 + !byte $65,%10001111; + !byte $67,%10101111 + !byte $53,%10101111 + !byte $53,%11001111 + !byte $69,%11101111 + !byte $6B,%00010000 + !byte $53,%00010000 + !byte $4F,%00110000 + !byte $6F,%01110000 + !byte $6F,%10010001; + !byte $75,%11110001 + !byte $43,%11110001 + !byte $75,%00010010 + !byte $43,%00010010 + !byte $75,%00110010 + !byte $75,%01010010 + !byte $45,%01010010 + !byte $75,%01110010 + !byte $75,%10010011; + !byte $41,%10110011 + !byte $89,%11110011 + !byte $3B,%11110011 + !byte $61,%11101101 + !byte $51,%11101101 + !byte $5F,%00001110 + !byte $57,%00001110 + !byte $55,%00001110 + !byte $53,%00001110 + !byte $51,%00001110 + !byte $63,%00101110 + !byte $5D,%00101110 + !byte $5B,%00101110 + !byte $59,%00101110 + !byte $51,%00101110 + !byte $65,%01001110 + !byte $51,%01001110 + !byte $67,%01101110 + !byte $67,%10001111; + !byte $69,%11001111 + !byte $6B,%11101111 + !byte $53,%11101111 + !byte $51,%00010000 + !byte $4F,%00010000 + !byte $4D,%00010000 + !byte $6D,%00110000 + !byte $77,%01010000 + !byte $6F,%01010000 + !byte $77,%01110000 + !byte $77,%10010001; + !byte $73,%01110000 + !byte $73,%10010001; + !byte $71,%01110000 + !byte $71,%10010001; + !byte $47,%11110001 + !byte $45,%11110001 + !byte $41,%11110001 + !byte $57,%00010010 + !byte $51,%00010010 + !byte $4F,%00010010 + !byte $43,%00110010 + !byte $43,%01010010 + !byte $43,%01110010 + !byte $43,%10010011; + !byte $41,%01110010 + !byte $41,%10010011; + !byte $75,%10110011 + !byte $3F,%10110011 + !byte $75,%11010011 + !byte $3D,%11010011 + !byte $3B,%11010011 + !byte $8B,%11110011 + !byte $75,%11110011 + !byte $39,%11110011 + !byte $37,%11110011 + !byte $61,%11001101 + !byte $5F,%11101101 + !byte $55,%11101101 + !byte $53,%11101101 + !byte $63,%00001110 + !byte $5D,%00001110 + !byte $5B,%00001110 + !byte $59,%00001110 + !byte $65,%00101110 + !byte $51,%01101110 + !byte $51,%10001111; + !byte $69,%10101111 + !byte $6B,%11001111 + !byte $51,%11101111 + !byte $4F,%11101111 + !byte $6D,%00010000 + !byte $6F,%00110000 + !byte $75,%01010000 + !byte $71,%01010000 + !byte $77,%10110001 + !byte $77,%11010001 + !byte $77,%11110001 + !byte $3F,%11110001 + !byte $77,%00010010 + !byte $55,%00010010 + !byte $41,%00010010 + !byte $77,%00110010 + !byte $41,%00110010 + !byte $41,%01010010 + !byte $3D,%10110011 + !byte $8D,%11110011 + !byte $61,%10101101 + !byte $5F,%10101101 + !byte $4F,%10101101 + !byte $63,%11001101 + !byte $5F,%11001101 + !byte $57,%11001101 + !byte $55,%11001101 + !byte $53,%11001101 + !byte $51,%11001101 + !byte $4F,%11001101 + !byte $63,%11101101 + !byte $5D,%11101101 + !byte $5B,%11101101 + !byte $59,%11101101 + !byte $57,%11101101 + !byte $65,%00001110 + !byte $67,%00101110 + !byte $67,%01001110 + !byte $69,%01101110 + !byte $69,%10001111; + !byte $6B,%10101111 + !byte $51,%10101111 + !byte $6D,%11001111 + !byte $51,%11001111 + !byte $4F,%11001111 + !byte $6D,%11101111 + !byte $4D,%11101111 + !byte $6F,%00010000 + !byte $79,%00110000 + !byte $77,%00110000 + !byte $71,%00110000 + !byte $79,%01010000 + !byte $73,%01010000 + !byte $43,%11010001 + !byte $41,%11010001 + !byte $3F,%11010001 + !byte $4D,%11110001 + !byte $4B,%11110001 + !byte $49,%11110001 + !byte $53,%00010010 + !byte $77,%01010010 + !byte $77,%01110010 + !byte $77,%10010011; + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $77,%10110011 + !byte $3B,%10110011 + !byte $77,%11010011 + !byte $39,%11010011 + !byte $37,%11010011 + !byte $8F,%11110011 + !byte $77,%11110011 + !byte $35,%11110011 + !byte $33,%11110011 + !byte $61,%01101100 + !byte $61,%10001101; + !byte $4F,%01101100 + !byte $4F,%10001101; + !byte $63,%10101101 + !byte $55,%10101101 + !byte $53,%10101101 + !byte $51,%10101101 + !byte $5D,%11001101 + !byte $5B,%11001101 + !byte $59,%11001101 + !byte $65,%11101101 + !byte $67,%00001110 + !byte $69,%00101110 + !byte $69,%01001110 + !byte $6B,%01101110 + !byte $6B,%10001111; + !byte $6D,%10101111 + !byte $4D,%11001111 + !byte $6F,%11101111 + !byte $71,%00010000 + !byte $7B,%00110000 + !byte $73,%00110000 + !byte $79,%01110000 + !byte $79,%10010001; + !byte $79,%10110001 + !byte $79,%11010001 + !byte $3D,%11010001 + !byte $79,%11110001 + !byte $79,%00010010 + !byte $3F,%00010010 + !byte $79,%00110010 + !byte $3F,%00110010 + !byte $79,%01010010 + !byte $3F,%01010010 + !byte $79,%01110010 + !byte $79,%10010011; + !byte $79,%10110011 + !byte $39,%10110011 + !byte $79,%11010011 + !byte $91,%11110011 + !byte $79,%11110011 + !byte $61,%00101100 + !byte $61,%01001100 + !byte $4F,%01001100 + !byte $63,%01101100 + !byte $63,%10001101; + !byte $5F,%01101100 + !byte $5F,%10001101; + !byte $55,%01101100 + !byte $55,%10001101; + !byte $53,%01101100 + !byte $53,%10001101; + !byte $51,%01101100 + !byte $51,%10001101; + !byte $65,%10101101 + !byte $5D,%10101101 + !byte $5B,%10101101 + !byte $59,%10101101 + !byte $57,%10101101 + !byte $65,%11001101 + !byte $67,%11101101 + !byte $4F,%11101101 + !byte $69,%00001110 + !byte $6B,%00101110 + !byte $6B,%01001110 + !byte $6D,%01101110 + !byte $6D,%10001111; + !byte $6F,%10101111 + !byte $4F,%10101111 + !byte $4D,%10101111 + !byte $4B,%10101111 + !byte $6F,%11001111 + !byte $4B,%11001111 + !byte $71,%11101111 + !byte $7B,%00010000 + !byte $79,%00010000 + !byte $73,%00010000 + !byte $75,%00110000 + !byte $7B,%01010000 + !byte $7B,%01110000 + !byte $7B,%10010001; + !byte $7B,%10110001 + !byte $3F,%10110001 + !byte $3D,%10110001 + !byte $3B,%10110001 + !byte $7B,%11010001 + !byte $47,%11010001 + !byte $45,%11010001 + !byte $7B,%11110001 + !byte $55,%11110001 + !byte $53,%11110001 + !byte $51,%11110001 + !byte $4F,%11110001 + !byte $3D,%11110001 + !byte $3D,%01010010 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $37,%10110011 + !byte $35,%11010011 + !byte $33,%11010011 + !byte $93,%11110011 + !byte $31,%11110011 + !byte $4D,%00101100 + !byte $63,%01001100 + !byte $5F,%01001100 + !byte $53,%01001100 + !byte $51,%01001100 + !byte $4D,%01001100 + !byte $65,%01101100 + !byte $65,%10001101; + !byte $59,%01101100 + !byte $59,%10001101; + !byte $57,%01101100 + !byte $57,%10001101; + !byte $67,%11001101 + !byte $69,%11101101 + !byte $4F,%00001110 + !byte $6D,%01001110 + !byte $6F,%01101110 + !byte $6F,%10001111; + !byte $4F,%01101110 + !byte $4F,%10001111; + !byte $49,%10101111 + !byte $71,%11001111 + !byte $7D,%11101111 + !byte $73,%11101111 + !byte $7D,%00010000 + !byte $77,%00010000 + !byte $75,%00010000 + !byte $49,%11010001 + !byte $3B,%11010001 + !byte $7B,%00010010 + !byte $3D,%00010010 + !byte $7B,%00110010 + !byte $3D,%00110010 + !byte $7B,%01010010 + !byte $3B,%01010010 + !byte $7B,%01110010 + !byte $7B,%10010011; + !byte $39,%01110010 + !byte $39,%10010011; + !byte $7B,%10110011 + !byte $35,%10110011 + !byte $95,%11110011 + !byte $7B,%11110011 + !byte $2F,%11110011 + !byte $61,%00001100 + !byte $5F,%00001100 + !byte $4D,%00001100 + !byte $63,%00101100 + !byte $5F,%00101100 + !byte $55,%00101100 + !byte $53,%00101100 + !byte $51,%00101100 + !byte $4F,%00101100 + !byte $65,%01001100 + !byte $5D,%01001100 + !byte $5B,%01001100 + !byte $59,%01001100 + !byte $57,%01001100 + !byte $55,%01001100 + !byte $5D,%01101100 + !byte $5D,%10001101; + !byte $5B,%01101100 + !byte $5B,%10001101; + !byte $4D,%01101100 + !byte $4D,%10001101; + !byte $67,%10101101 + !byte $4D,%10101101 + !byte $69,%11001101 + !byte $6B,%00001110 + !byte $6D,%00101110 + !byte $4F,%00101110 + !byte $6F,%01001110 + !byte $4F,%01001110 + !byte $4D,%01001110 + !byte $4D,%01101110 + !byte $4D,%10001111; + !byte $4B,%01101110 + !byte $4B,%10001111; + !byte $49,%01101110 + !byte $49,%10001111; + !byte $47,%01101110 + !byte $47,%10001111; + !byte $71,%10101111 + !byte $73,%11001111 + !byte $7B,%11101111 + !byte $75,%11101111 + !byte $7D,%00110000 + !byte $7D,%01010000 + !byte $7D,%01110000 + !byte $7D,%10010001; + !byte $39,%01110000 + !byte $39,%10010001; + !byte $37,%01110000 + !byte $37,%10010001; + !byte $7D,%10110001 + !byte $43,%10110001 + !byte $41,%10110001 + !byte $39,%10110001 + !byte $4D,%11010001 + !byte $4B,%11010001 + !byte $39,%11010001 + !byte $3B,%11110001 + !byte $3B,%00010010 + !byte $3B,%00110010 + !byte $39,%01010010 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $35,%01110010 + !byte $35,%10010011; + !byte $33,%10110011 + !byte $7B,%11010011 + !byte $31,%11010011 + !byte $2F,%11010011 + !byte $97,%11110011 + !byte $7F,%11110011 + !byte $7D,%11110011 + !byte $2D,%11110011 + !byte $2B,%11110011 + !byte $61,%11101011 + !byte $5F,%11101011 + !byte $4B,%11101011 + !byte $63,%00001100 + !byte $51,%00001100 + !byte $4F,%00001100 + !byte $4B,%00001100 + !byte $5D,%00101100 + !byte $59,%00101100 + !byte $57,%00101100 + !byte $67,%01101100 + !byte $67,%10001101; + !byte $69,%10101101 + !byte $4D,%11001101 + !byte $6B,%11101101 + !byte $6D,%00001110 + !byte $4B,%01001110 + !byte $71,%01101110 + !byte $71,%10001111; + !byte $73,%10101111 + !byte $7F,%11001111 + !byte $79,%11101111 + !byte $77,%11101111 + !byte $37,%10110001 + !byte $7D,%11010001 + !byte $53,%11010001 + !byte $7D,%11110001 + !byte $39,%11110001 + !byte $7D,%00010010 + !byte $39,%00010010 + !byte $7D,%00110010 + !byte $39,%00110010 + !byte $7D,%01010010 + !byte $37,%01010010 + !byte $31,%10110011 + !byte $2D,%11010011 + !byte $99,%11110011 + !byte $61,%10101011 + !byte $61,%11001011 + !byte $5F,%11001011 + !byte $4D,%11001011 + !byte $4B,%11001011 + !byte $63,%11101011 + !byte $53,%11101011 + !byte $51,%11101011 + !byte $4F,%11101011 + !byte $4D,%11101011 + !byte $65,%00001100 + !byte $5D,%00001100 + !byte $59,%00001100 + !byte $57,%00001100 + !byte $55,%00001100 + !byte $53,%00001100 + !byte $65,%00101100 + !byte $5B,%00101100 + !byte $67,%01001100 + !byte $69,%01101100 + !byte $69,%10001101; + !byte $6B,%10101101 + !byte $6B,%11001101 + !byte $6D,%11101101 + !byte $4D,%11101101 + !byte $6F,%00001110 + !byte $4D,%00001110 + !byte $6F,%00101110 + !byte $4D,%00101110 + !byte $4B,%00101110 + !byte $71,%01001110 + !byte $49,%01001110 + !byte $47,%01001110 + !byte $73,%01101110 + !byte $73,%10001111; + !byte $7D,%11001111 + !byte $7B,%11001111 + !byte $75,%11001111 + !byte $7F,%11101111 + !byte $7F,%00010000 + !byte $7F,%00110000 + !byte $7F,%01010000 + !byte $35,%01010000 + !byte $7F,%01110000 + !byte $7F,%10010001; + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $35,%01110000 + !byte $35,%10010001; + !byte $47,%10110001 + !byte $45,%10110001 + !byte $51,%11010001 + !byte $4F,%11010001 + !byte $37,%11010001 + !byte $37,%00110010 + !byte $35,%01010010 + !byte $7D,%01110010 + !byte $7D,%10010011; + !byte $33,%01110010 + !byte $33,%10010011; + !byte $31,%01110010 + !byte $31,%10010011; + !byte $7D,%10110011 + !byte $2F,%10110011 + !byte $7D,%11010011 + !byte $2B,%11010011 + !byte $9B,%11110011 + !byte $29,%11110011 + !byte $27,%11110011 + !byte $61,%01101010 + !byte $61,%10001011; + !byte $4B,%10101011 + !byte $63,%11001011 + !byte $51,%11001011 + !byte $4F,%11001011 + !byte $65,%11101011 + !byte $57,%11101011 + !byte $55,%11101011 + !byte $5B,%00001100 + !byte $67,%00101100 + !byte $69,%01001100 + !byte $6B,%01101100 + !byte $6B,%10001101; + !byte $6D,%11001101 + !byte $6F,%11101101 + !byte $71,%00101110 + !byte $49,%00101110 + !byte $47,%00101110 + !byte $73,%01001110 + !byte $75,%01101110 + !byte $75,%10001111; + !byte $81,%10101111 + !byte $75,%10101111 + !byte $81,%11001111 + !byte $79,%11001111 + !byte $77,%11001111 + !byte $81,%11101111 + !byte $81,%00010000 + !byte $81,%00110000 + !byte $33,%01010000 + !byte $7F,%10110001 + !byte $49,%10110001 + !byte $35,%10110001 + !byte $7F,%11010001 + !byte $7F,%11110001 + !byte $37,%11110001 + !byte $7F,%00010010 + !byte $37,%00010010 + !byte $7F,%00110010 + !byte $7F,%01010010 + !byte $33,%01010010 + !byte $7F,%01110010 + !byte $7F,%10010011; + !byte $7F,%10110011 + !byte $2D,%10110011 + !byte $7F,%11010011 + !byte $9D,%11110011 + !byte $61,%01001010 + !byte $63,%01101010 + !byte $63,%10001011; + !byte $4B,%01101010 + !byte $4B,%10001011; + !byte $49,%01101010 + !byte $49,%10001011; + !byte $63,%10101011 + !byte $5F,%10101011 + !byte $53,%10101011 + !byte $51,%10101011 + !byte $4F,%10101011 + !byte $4D,%10101011 + !byte $65,%11001011 + !byte $5D,%11001011 + !byte $59,%11001011 + !byte $57,%11001011 + !byte $55,%11001011 + !byte $53,%11001011 + !byte $67,%11101011 + !byte $5D,%11101011 + !byte $5B,%11101011 + !byte $59,%11101011 + !byte $67,%00001100 + !byte $69,%00101100 + !byte $4B,%00101100 + !byte $6B,%01001100 + !byte $6D,%01101100 + !byte $6D,%10001101; + !byte $6D,%10101101 + !byte $6F,%11001101 + !byte $71,%11101101 + !byte $71,%00001110 + !byte $4B,%00001110 + !byte $49,%00001110 + !byte $47,%00001110 + !byte $73,%00101110 + !byte $45,%00101110 + !byte $75,%01001110 + !byte $83,%01101110 + !byte $83,%10001111; + !byte $77,%01101110 + !byte $77,%10001111; + !byte $7F,%10101111 + !byte $7D,%10101111 + !byte $79,%10101111 + !byte $77,%10101111 + !byte $81,%01010000 + !byte $3B,%01010000 + !byte $39,%01010000 + !byte $37,%01010000 + !byte $81,%01110000 + !byte $81,%10010001; + !byte $43,%01110000 + !byte $43,%10010001; + !byte $41,%01110000 + !byte $41,%10010001; + !byte $33,%01110000 + !byte $33,%10010001; + !byte $81,%10110001 + !byte $51,%10110001 + !byte $4D,%10110001 + !byte $4B,%10110001 + !byte $81,%11010001 + !byte $35,%11010001 + !byte $81,%11110001 + !byte $35,%11110001 + !byte $35,%00010010 + !byte $35,%00110010 + !byte $31,%01010010 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $2B,%10110011 + !byte $9F,%11010011 + !byte $29,%11010011 + !byte $27,%11010011 + !byte $9F,%11110011 + !byte $25,%11110011 + !byte $61,%00101010 + !byte $5F,%01001010 + !byte $49,%01001010 + !byte $5F,%01101010 + !byte $5F,%10001011; + !byte $4F,%01101010 + !byte $4F,%10001011; + !byte $4D,%01101010 + !byte $4D,%10001011; + !byte $65,%10101011 + !byte $5D,%10101011 + !byte $57,%10101011 + !byte $55,%10101011 + !byte $49,%10101011 + !byte $5B,%11001011 + !byte $49,%11001011 + !byte $49,%11101011 + !byte $69,%00001100 + !byte $6B,%00101100 + !byte $4B,%01001100 + !byte $4B,%01101100 + !byte $4B,%10001101; + !byte $6F,%10101101 + !byte $4B,%10101101 + !byte $4B,%11001101 + !byte $4B,%11101101 + !byte $49,%11101101 + !byte $73,%00001110 + !byte $45,%00001110 + !byte $43,%00001110 + !byte $75,%00101110 + !byte $81,%01101110 + !byte $81,%10001111; + !byte $83,%10101111 + !byte $7B,%10101111 + !byte $83,%11001111 + !byte $83,%11101111 + !byte $31,%00110000 + !byte $2F,%00110000 + !byte $31,%01010000 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $4F,%10110001 + !byte $33,%10110001 + !byte $33,%11010001 + !byte $33,%11110001 + !byte $81,%00010010 + !byte $33,%00010010 + !byte $81,%00110010 + !byte $33,%00110010 + !byte $81,%01010010 + !byte $2F,%01010010 + !byte $81,%01110010 + !byte $81,%10010011; + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $29,%10110011 + !byte $25,%11010011 + !byte $A1,%11110011 + !byte $23,%11110011 + !byte $61,%00001010 + !byte $5F,%00101010 + !byte $4B,%00101010 + !byte $49,%00101010 + !byte $47,%00101010 + !byte $63,%01001010 + !byte $51,%01001010 + !byte $4F,%01001010 + !byte $4D,%01001010 + !byte $4B,%01001010 + !byte $65,%01101010 + !byte $65,%10001011; + !byte $5D,%01101010 + !byte $5D,%10001011; + !byte $57,%01101010 + !byte $57,%10001011; + !byte $55,%01101010 + !byte $55,%10001011; + !byte $53,%01101010 + !byte $53,%10001011; + !byte $51,%01101010 + !byte $51,%10001011; + !byte $67,%10101011 + !byte $5B,%10101011 + !byte $59,%10101011 + !byte $67,%11001011 + !byte $69,%11101011 + !byte $6B,%00001100 + !byte $6D,%01001100 + !byte $6F,%01101100 + !byte $6F,%10001101; + !byte $71,%10101101 + !byte $71,%11001101 + !byte $49,%11001101 + !byte $73,%11101101 + !byte $47,%11101101 + !byte $45,%11101101 + !byte $43,%11101101 + !byte $75,%00001110 + !byte $83,%01001110 + !byte $77,%01001110 + !byte $7F,%01101110 + !byte $7F,%10001111; + !byte $7D,%01101110 + !byte $7D,%10001111; + !byte $7B,%01101110 + !byte $7B,%10001111; + !byte $79,%01101110 + !byte $79,%10001111; + !byte $83,%00010000 + !byte $83,%00110000 + !byte $35,%00110000 + !byte $33,%00110000 + !byte $83,%01010000 + !byte $3F,%01010000 + !byte $3D,%01010000 + !byte $83,%01110000 + !byte $83,%10010001; + !byte $51,%01110000 + !byte $51,%10010001; + !byte $49,%01110000 + !byte $49,%10010001; + !byte $47,%01110000 + !byte $47,%10010001; + !byte $45,%01110000 + !byte $45,%10010001; + !byte $83,%10110001 + !byte $31,%10110001 + !byte $31,%00010010 + !byte $31,%00110010 + !byte $2F,%00110010 + !byte $2D,%01010010 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $29,%01110010 + !byte $29,%10010011; + !byte $81,%10110011 + !byte $27,%10110011 + !byte $25,%10110011 + !byte $A3,%11010011 + !byte $A1,%11010011 + !byte $81,%11010011 + !byte $23,%11010011 + !byte $A3,%11110011 + !byte $21,%11110011 + !byte $1F,%11110011 + !byte $61,%11101001 + !byte $5F,%00001010 + !byte $49,%00001010 + !byte $47,%00001010 + !byte $63,%00101010 + !byte $4F,%00101010 + !byte $4D,%00101010 + !byte $65,%01001010 + !byte $5D,%01001010 + !byte $55,%01001010 + !byte $53,%01001010 + !byte $47,%01001010 + !byte $5B,%01101010 + !byte $5B,%10001011; + !byte $59,%01101010 + !byte $59,%10001011; + !byte $69,%11001011 + !byte $6B,%11101011 + !byte $49,%00001100 + !byte $6D,%00101100 + !byte $6F,%01001100 + !byte $49,%10101101 + !byte $73,%11001101 + !byte $47,%11001101 + !byte $45,%11001101 + !byte $75,%11101101 + !byte $41,%11101101 + !byte $77,%00101110 + !byte $85,%01001110 + !byte $79,%01001110 + !byte $85,%01101110 + !byte $85,%10001111; + !byte $85,%10101111 + !byte $85,%11001111 + !byte $2D,%00010000 + !byte $2D,%00110000 + !byte $2F,%01010000 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $83,%11010001 + !byte $31,%11010001 + !byte $83,%11110001 + !byte $31,%11110001 + !byte $83,%00010010 + !byte $83,%00110010 + !byte $83,%01010010 + !byte $2B,%01010010 + !byte $A5,%11010011 + !byte $21,%11010011 + !byte $A5,%11110011 + !byte $61,%11001001 + !byte $63,%11101001 + !byte $5F,%11101001 + !byte $49,%11101001 + !byte $47,%11101001 + !byte $65,%00001010 + !byte $63,%00001010 + !byte $51,%00001010 + !byte $4F,%00001010 + !byte $4D,%00001010 + !byte $4B,%00001010 + !byte $65,%00101010 + !byte $5D,%00101010 + !byte $57,%00101010 + !byte $55,%00101010 + !byte $53,%00101010 + !byte $51,%00101010 + !byte $67,%01001010 + !byte $5B,%01001010 + !byte $59,%01001010 + !byte $57,%01001010 + !byte $69,%01101010 + !byte $69,%10001011; + !byte $67,%01101010 + !byte $67,%10001011; + !byte $69,%10101011 + !byte $6B,%11001011 + !byte $6D,%11101011 + !byte $6F,%00001100 + !byte $6D,%00001100 + !byte $6F,%00101100 + !byte $71,%01001100 + !byte $73,%01101100 + !byte $73,%10001101; + !byte $71,%01101100 + !byte $71,%10001101; + !byte $49,%01101100 + !byte $49,%10001101; + !byte $73,%10101101 + !byte $47,%10101101 + !byte $45,%10101101 + !byte $75,%11001101 + !byte $43,%11001101 + !byte $41,%11001101 + !byte $77,%11101101 + !byte $79,%00001110 + !byte $77,%00001110 + !byte $87,%00101110 + !byte $85,%00101110 + !byte $79,%00101110 + !byte $87,%01001110 + !byte $81,%01001110 + !byte $7F,%01001110 + !byte $7D,%01001110 + !byte $7B,%01001110 + !byte $87,%01101110 + !byte $87,%10001111; + !byte $85,%11101111 + !byte $85,%00010000 + !byte $31,%00010000 + !byte $2F,%00010000 + !byte $85,%00110000 + !byte $3B,%00110000 + !byte $39,%00110000 + !byte $37,%00110000 + !byte $85,%01010000 + !byte $45,%01010000 + !byte $43,%01010000 + !byte $41,%01010000 + !byte $85,%01110000 + !byte $85,%10010001; + !byte $4F,%01110000 + !byte $4F,%10010001; + !byte $4D,%01110000 + !byte $4D,%10010001; + !byte $4B,%01110000 + !byte $4B,%10010001; + !byte $85,%10110001 + !byte $2F,%10110001 + !byte $85,%11010001 + !byte $85,%11110001 + !byte $85,%00010010 + !byte $2F,%00010010 + !byte $2D,%00110010 + !byte $29,%01010010 + !byte $83,%01110010 + !byte $83,%10010011; + !byte $27,%01110010 + !byte $27,%10010011; + !byte $25,%01110010 + !byte $25,%10010011; + !byte $83,%10110011 + !byte $23,%10110011 + !byte $A7,%11010011 + !byte $83,%11010011 + !byte $1F,%11010011 + !byte $A7,%11110011 + !byte $1D,%11110011 + !byte $1B,%11110011 + !byte $61,%10101001 + !byte $63,%11001001 + !byte $47,%11001001 + !byte $4D,%11101001 + !byte $4B,%11101001 + !byte $55,%00001010 + !byte $53,%00001010 + !byte $67,%00101010 + !byte $5B,%00101010 + !byte $59,%00101010 + !byte $69,%01001010 + !byte $47,%01101010 + !byte $47,%10001011; + !byte $6B,%10101011 + !byte $6D,%11001011 + !byte $71,%00101100 + !byte $49,%00101100 + !byte $73,%01001100 + !byte $49,%01001100 + !byte $75,%10101101 + !byte $43,%10101101 + !byte $77,%11001101 + !byte $7B,%00101110 + !byte $87,%10101111 + !byte $87,%11001111 + !byte $87,%11101111 + !byte $87,%00010000 + !byte $2B,%00010000 + !byte $87,%00110000 + !byte $87,%01010000 + !byte $2D,%01010000 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $2F,%11010001 + !byte $2F,%11110001 + !byte $2D,%00010010 + !byte $85,%00110010 + !byte $2B,%00110010 + !byte $85,%01010010 + !byte $27,%01010010 + !byte $85,%01110010 + !byte $85,%10010011; + !byte $85,%10110011 + !byte $21,%10110011 + !byte $A9,%11010011 + !byte $85,%11010011 + !byte $1D,%11010011 + !byte $A9,%11110011 + !byte $61,%01001000 + !byte $61,%01101000 + !byte $61,%10001001; + !byte $63,%10101001 + !byte $5F,%10101001 + !byte $49,%10101001 + !byte $47,%10101001 + !byte $45,%10101001 + !byte $65,%11001001 + !byte $5F,%11001001 + !byte $4F,%11001001 + !byte $4D,%11001001 + !byte $4B,%11001001 + !byte $49,%11001001 + !byte $45,%11001001 + !byte $65,%11101001 + !byte $5D,%11101001 + !byte $55,%11101001 + !byte $53,%11101001 + !byte $51,%11101001 + !byte $4F,%11101001 + !byte $67,%00001010 + !byte $5D,%00001010 + !byte $5B,%00001010 + !byte $59,%00001010 + !byte $57,%00001010 + !byte $69,%00101010 + !byte $6B,%01001010 + !byte $6B,%01101010 + !byte $6B,%10001011; + !byte $6D,%10101011 + !byte $6F,%11001011 + !byte $6F,%11101011 + !byte $71,%00001100 + !byte $73,%00101100 + !byte $75,%01001100 + !byte $47,%01001100 + !byte $75,%01101100 + !byte $75,%10001101; + !byte $47,%01101100 + !byte $47,%10001101; + !byte $45,%01101100 + !byte $45,%10001101; + !byte $43,%01101100 + !byte $43,%10001101; + !byte $77,%10101101 + !byte $41,%10101101 + !byte $3F,%10101101 + !byte $79,%11001101 + !byte $79,%11101101 + !byte $89,%00001110 + !byte $87,%00001110 + !byte $7B,%00001110 + !byte $89,%00101110 + !byte $83,%00101110 + !byte $81,%00101110 + !byte $7F,%00101110 + !byte $7D,%00101110 + !byte $89,%01001110 + !byte $89,%01101110 + !byte $89,%10001111; + !byte $2D,%11101111 + !byte $2B,%11101111 + !byte $29,%11101111 + !byte $37,%00010000 + !byte $35,%00010000 + !byte $33,%00010000 + !byte $3F,%00110000 + !byte $3D,%00110000 + !byte $2B,%00110000 + !byte $4F,%01010000 + !byte $49,%01010000 + !byte $47,%01010000 + !byte $87,%01110000 + !byte $87,%10010001; + !byte $87,%10110001 + !byte $2D,%10110001 + !byte $87,%11010001 + !byte $2D,%11010001 + !byte $87,%11110001 + !byte $2D,%11110001 + !byte $2B,%00010010 + !byte $29,%00110010 + !byte $25,%01010010 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $21,%01110010 + !byte $21,%10010011; + !byte $1F,%10110011 + !byte $AB,%11010011 + !byte $1B,%11010011 + !byte $AB,%11110011 + !byte $19,%11110011 + !byte $63,%01101000 + !byte $63,%10001001; + !byte $5F,%01101000 + !byte $5F,%10001001; + !byte $45,%01101000 + !byte $45,%10001001; + !byte $4D,%10101001 + !byte $4B,%10101001 + !byte $5D,%11001001 + !byte $53,%11001001 + !byte $51,%11001001 + !byte $67,%11101001 + !byte $5B,%11101001 + !byte $59,%11101001 + !byte $57,%11101001 + !byte $45,%11101001 + !byte $45,%00001010 + !byte $45,%00101010 + !byte $6D,%01101010 + !byte $6D,%10001011; + !byte $47,%10101011 + !byte $47,%11001011 + !byte $71,%11101011 + !byte $47,%11101011 + !byte $47,%00001100 + !byte $47,%00101100 + !byte $45,%01001100 + !byte $77,%01101100 + !byte $77,%10001101; + !byte $41,%01101100 + !byte $41,%10001101; + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $7B,%11101101 + !byte $85,%00001110 + !byte $7D,%00001110 + !byte $89,%10101111 + !byte $89,%11001111 + !byte $89,%11101111 + !byte $27,%11101111 + !byte $89,%00010000 + !byte $29,%00010000 + !byte $29,%00110000 + !byte $4D,%01010000 + !byte $2B,%01010000 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $2B,%10110001 + !byte $2B,%11010001 + !byte $2B,%11110001 + !byte $87,%00010010 + !byte $29,%00010010 + !byte $87,%00110010 + !byte $27,%00110010 + !byte $87,%01010010 + !byte $23,%01010010 + !byte $87,%01110010 + !byte $87,%10010011; + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $1D,%10110011 + !byte $AD,%11010011 + !byte $87,%11010011 + !byte $19,%11010011 + !byte $AD,%11110011 + !byte $17,%11110011 + !byte $15,%11110011 + !byte $61,%00101000 + !byte $63,%01001000 + !byte $5F,%01001000 + !byte $47,%01001000 + !byte $45,%01001000 + !byte $43,%01001000 + !byte $65,%01101000 + !byte $65,%10001001; + !byte $4D,%01101000 + !byte $4D,%10001001; + !byte $4B,%01101000 + !byte $4B,%10001001; + !byte $49,%01101000 + !byte $49,%10001001; + !byte $47,%01101000 + !byte $47,%10001001; + !byte $43,%01101000 + !byte $43,%10001001; + !byte $65,%10101001 + !byte $5D,%10101001 + !byte $53,%10101001 + !byte $51,%10101001 + !byte $4F,%10101001 + !byte $67,%11001001 + !byte $5B,%11001001 + !byte $59,%11001001 + !byte $57,%11001001 + !byte $55,%11001001 + !byte $69,%11101001 + !byte $69,%00001010 + !byte $6B,%00101010 + !byte $6D,%01001010 + !byte $6F,%01101010 + !byte $6F,%10001011; + !byte $6F,%10101011 + !byte $71,%11001011 + !byte $73,%11101011 + !byte $73,%00001100 + !byte $75,%00101100 + !byte $45,%00101100 + !byte $77,%01001100 + !byte $43,%01001100 + !byte $41,%01001100 + !byte $3F,%01001100 + !byte $79,%01101100 + !byte $79,%10001101; + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $79,%10101101 + !byte $7B,%11001101 + !byte $8B,%11101101 + !byte $89,%11101101 + !byte $87,%11101101 + !byte $7D,%11101101 + !byte $8B,%00001110 + !byte $83,%00001110 + !byte $81,%00001110 + !byte $7F,%00001110 + !byte $8B,%00101110 + !byte $27,%11001111 + !byte $25,%11001111 + !byte $31,%11101111 + !byte $2F,%11101111 + !byte $3B,%00010000 + !byte $39,%00010000 + !byte $27,%00010000 + !byte $89,%00110000 + !byte $45,%00110000 + !byte $43,%00110000 + !byte $41,%00110000 + !byte $89,%01010000 + !byte $4B,%01010000 + !byte $29,%01010000 + !byte $89,%01110000 + !byte $89,%10010001; + !byte $89,%10110001 + !byte $29,%11110001 + !byte $27,%00010010 + !byte $25,%00110010 + !byte $23,%00110010 + !byte $21,%01010010 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $87,%10110011 + !byte $1B,%10110011 + !byte $19,%10110011 + !byte $AF,%11010011 + !byte $9D,%11010011 + !byte $17,%11010011 + !byte $AF,%11110011 + !byte $13,%11110011 + !byte $61,%00001000 + !byte $63,%00101000 + !byte $5F,%00101000 + !byte $45,%00101000 + !byte $43,%00101000 + !byte $4B,%01001000 + !byte $49,%01001000 + !byte $5D,%01101000 + !byte $5D,%10001001; + !byte $51,%01101000 + !byte $51,%10001001; + !byte $4F,%01101000 + !byte $4F,%10001001; + !byte $67,%10101001 + !byte $5B,%10101001 + !byte $59,%10101001 + !byte $57,%10101001 + !byte $55,%10101001 + !byte $43,%10101001 + !byte $69,%11001001 + !byte $6B,%00001010 + !byte $6D,%00101010 + !byte $45,%01001010 + !byte $45,%01101010 + !byte $45,%10001011; + !byte $71,%10101011 + !byte $73,%11001011 + !byte $75,%00001100 + !byte $45,%00001100 + !byte $77,%00101100 + !byte $43,%00101100 + !byte $41,%00101100 + !byte $3D,%01001100 + !byte $3B,%01001100 + !byte $7B,%10101101 + !byte $7D,%11001101 + !byte $8B,%01001110 + !byte $8B,%01101110 + !byte $8B,%10001111; + !byte $8B,%10101111 + !byte $8B,%11001111 + !byte $8B,%11101111 + !byte $25,%11101111 + !byte $27,%00110000 + !byte $27,%01010000 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $29,%10110001 + !byte $89,%11010001 + !byte $29,%11010001 + !byte $89,%11110001 + !byte $89,%00010010 + !byte $25,%00010010 + !byte $89,%00110010 + !byte $89,%01010010 + !byte $1F,%01010010 + !byte $B1,%11010011 + !byte $89,%11010011 + !byte $15,%11010011 + !byte $B1,%11110011 + !byte $61,%11000111 + !byte $61,%11100111 + !byte $63,%00001000 + !byte $5F,%00001000 + !byte $47,%00001000 + !byte $45,%00001000 + !byte $43,%00001000 + !byte $65,%00101000 + !byte $4D,%00101000 + !byte $4B,%00101000 + !byte $49,%00101000 + !byte $47,%00101000 + !byte $67,%01001000 + !byte $65,%01001000 + !byte $5D,%01001000 + !byte $53,%01001000 + !byte $51,%01001000 + !byte $4F,%01001000 + !byte $4D,%01001000 + !byte $67,%01101000 + !byte $67,%10001001; + !byte $5B,%01101000 + !byte $5B,%10001001; + !byte $59,%01101000 + !byte $59,%10001001; + !byte $57,%01101000 + !byte $57,%10001001; + !byte $55,%01101000 + !byte $55,%10001001; + !byte $53,%01101000 + !byte $53,%10001001; + !byte $69,%10101001 + !byte $6B,%11001001 + !byte $6B,%11101001 + !byte $6D,%00001010 + !byte $6F,%00101010 + !byte $71,%01001010 + !byte $6F,%01001010 + !byte $71,%01101010 + !byte $71,%10001011; + !byte $73,%10101011 + !byte $75,%11001011 + !byte $75,%11101011 + !byte $45,%11101011 + !byte $77,%00001100 + !byte $43,%00001100 + !byte $41,%00001100 + !byte $79,%00101100 + !byte $3F,%00101100 + !byte $3D,%00101100 + !byte $3B,%00101100 + !byte $7B,%01001100 + !byte $79,%01001100 + !byte $7B,%01101100 + !byte $7B,%10001101; + !byte $7D,%10101101 + !byte $8D,%11001101 + !byte $8B,%11001101 + !byte $89,%11001101 + !byte $7F,%11001101 + !byte $8D,%11101101 + !byte $85,%11101101 + !byte $83,%11101101 + !byte $81,%11101101 + !byte $7F,%11101101 + !byte $8D,%00001110 + !byte $8D,%00101110 + !byte $8D,%01001110 + !byte $8D,%01101110 + !byte $8D,%10001111; + !byte $8D,%10101111 + !byte $23,%10101111 + !byte $2D,%11001111 + !byte $2B,%11001111 + !byte $29,%11001111 + !byte $23,%11001111 + !byte $37,%11101111 + !byte $35,%11101111 + !byte $33,%11101111 + !byte $8B,%00010000 + !byte $3F,%00010000 + !byte $3D,%00010000 + !byte $25,%00010000 + !byte $8B,%00110000 + !byte $4D,%00110000 + !byte $4B,%00110000 + !byte $49,%00110000 + !byte $47,%00110000 + !byte $8B,%01010000 + !byte $8B,%01110000 + !byte $8B,%10010001; + !byte $8B,%10110001 + !byte $8B,%11010001 + !byte $27,%11010001 + !byte $8B,%11110001 + !byte $27,%11110001 + !byte $8B,%00010010 + !byte $23,%00010010 + !byte $21,%00110010 + !byte $1F,%00110010 + !byte $1D,%01010010 + !byte $89,%01110010 + !byte $89,%10010011; + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $19,%01110010 + !byte $19,%10010011; + !byte $89,%10110011 + !byte $17,%10110011 + !byte $B3,%11010011 + !byte $8B,%11010011 + !byte $13,%11010011 + !byte $B3,%11110011 + !byte $11,%11110011 + !byte $0F,%11110011 + !byte $61,%10100111 + !byte $63,%11100111 + !byte $5F,%11100111 + !byte $45,%11100111 + !byte $43,%11100111 + !byte $41,%11100111 + !byte $65,%00001000 + !byte $4B,%00001000 + !byte $49,%00001000 + !byte $41,%00001000 + !byte $67,%00101000 + !byte $5D,%00101000 + !byte $51,%00101000 + !byte $4F,%00101000 + !byte $57,%01001000 + !byte $55,%01001000 + !byte $69,%01101000 + !byte $69,%10001001; + !byte $6B,%10101001 + !byte $43,%11001001 + !byte $6D,%11101001 + !byte $6F,%00001010 + !byte $71,%00101010 + !byte $73,%01101010 + !byte $73,%10001011; + !byte $75,%10101011 + !byte $45,%10101011 + !byte $45,%11001011 + !byte $77,%11101011 + !byte $43,%11101011 + !byte $79,%00001100 + !byte $3F,%00001100 + !byte $7B,%00101100 + !byte $7D,%01101100 + !byte $7D,%10001101; + !byte $8F,%10101101 + !byte $7F,%10101101 + !byte $8F,%11001101 + !byte $81,%11001101 + !byte $21,%10101111 + !byte $8D,%11001111 + !byte $8D,%11101111 + !byte $23,%11101111 + !byte $8D,%00010000 + !byte $8D,%00110000 + !byte $25,%00110000 + !byte $8D,%01010000 + !byte $27,%01110000 + !byte $27,%10010001; + !byte $27,%10110001 + !byte $25,%11110001 + !byte $8B,%00110010 + !byte $8B,%01010010 + !byte $1B,%01010010 + !byte $8B,%01110010 + !byte $8B,%10010011; + !byte $8B,%10110011 + !byte $15,%10110011 + !byte $B5,%11010011 + !byte $11,%11010011 + !byte $B5,%11110011 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $63,%10100111 + !byte $63,%11000111 + !byte $5F,%11000111 + !byte $45,%11000111 + !byte $43,%11000111 + !byte $41,%11000111 + !byte $65,%11100111 + !byte $4B,%11100111 + !byte $49,%11100111 + !byte $47,%11100111 + !byte $67,%00001000 + !byte $5D,%00001000 + !byte $51,%00001000 + !byte $4F,%00001000 + !byte $4D,%00001000 + !byte $5B,%00101000 + !byte $59,%00101000 + !byte $57,%00101000 + !byte $55,%00101000 + !byte $53,%00101000 + !byte $69,%01001000 + !byte $5B,%01001000 + !byte $59,%01001000 + !byte $6B,%01101000 + !byte $6B,%10001001; + !byte $6D,%10101001 + !byte $6D,%11001001 + !byte $6F,%11101001 + !byte $43,%11101001 + !byte $71,%00001010 + !byte $73,%01001010 + !byte $75,%01101010 + !byte $75,%10001011; + !byte $77,%10101011 + !byte $77,%11001011 + !byte $43,%11001011 + !byte $79,%11101011 + !byte $41,%11101011 + !byte $3F,%11101011 + !byte $7B,%00001100 + !byte $3D,%00001100 + !byte $3B,%00001100 + !byte $39,%00001100 + !byte $7D,%01001100 + !byte $7F,%01101100 + !byte $7F,%10001101; + !byte $8D,%10101101 + !byte $8B,%10101101 + !byte $81,%10101101 + !byte $87,%11001101 + !byte $85,%11001101 + !byte $83,%11001101 + !byte $8F,%11101101 + !byte $8F,%00001110 + !byte $8F,%00101110 + !byte $8F,%01001110 + !byte $8F,%01101110 + !byte $8F,%10001111; + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $29,%10101111 + !byte $27,%10101111 + !byte $25,%10101111 + !byte $31,%11001111 + !byte $2F,%11001111 + !byte $21,%11001111 + !byte $3B,%11101111 + !byte $39,%11101111 + !byte $45,%00010000 + !byte $43,%00010000 + !byte $41,%00010000 + !byte $23,%00010000 + !byte $25,%01010000 + !byte $8D,%01110000 + !byte $8D,%10010001; + !byte $25,%01110000 + !byte $25,%10010001; + !byte $8D,%10110001 + !byte $25,%10110001 + !byte $8D,%11010001 + !byte $25,%11010001 + !byte $8D,%11110001 + !byte $23,%11110001 + !byte $8D,%00010010 + !byte $21,%00010010 + !byte $1F,%00010010 + !byte $1D,%00110010 + !byte $19,%01010010 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $15,%01110010 + !byte $15,%10010011; + !byte $13,%10110011 + !byte $B7,%11010011 + !byte $9B,%11010011 + !byte $8D,%11010011 + !byte $0F,%11010011 + !byte $B7,%11110011 + !byte $0D,%11110011 + !byte $0B,%11110011 + !byte $61,%01000110 + !byte $5F,%10100111 + !byte $43,%10100111 + !byte $41,%10100111 + !byte $3F,%10100111 + !byte $65,%11000111 + !byte $49,%11000111 + !byte $47,%11000111 + !byte $3F,%11000111 + !byte $5D,%11100111 + !byte $4F,%11100111 + !byte $4D,%11100111 + !byte $5B,%00001000 + !byte $55,%00001000 + !byte $53,%00001000 + !byte $69,%00101000 + !byte $41,%00101000 + !byte $6B,%01001000 + !byte $41,%01001000 + !byte $41,%01101000 + !byte $41,%10001001; + !byte $6F,%11001001 + !byte $43,%00001010 + !byte $73,%00101010 + !byte $43,%00101010 + !byte $75,%01001010 + !byte $43,%01001010 + !byte $43,%01101010 + !byte $43,%10001011; + !byte $43,%10101011 + !byte $79,%11001011 + !byte $41,%11001011 + !byte $3F,%11001011 + !byte $3D,%11101011 + !byte $3B,%11101011 + !byte $39,%11101011 + !byte $7D,%00101100 + !byte $7F,%01001100 + !byte $91,%01101100 + !byte $91,%10001101; + !byte $8F,%01101100 + !byte $8F,%10001101; + !byte $89,%10101101 + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $8F,%10101111 + !byte $1F,%10101111 + !byte $8F,%11001111 + !byte $1F,%11001111 + !byte $8F,%11101111 + !byte $21,%11101111 + !byte $8F,%00010000 + !byte $4B,%00010000 + !byte $21,%00010000 + !byte $23,%00110000 + !byte $23,%01010000 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $23,%10110001 + !byte $23,%11010001 + !byte $21,%11110001 + !byte $1D,%00010010 + !byte $8D,%00110010 + !byte $1B,%00110010 + !byte $8D,%01010010 + !byte $17,%01010010 + !byte $8D,%01110010 + !byte $8D,%10010011; + !byte $13,%01110010 + !byte $13,%10010011; + !byte $8D,%10110011 + !byte $11,%10110011 + !byte $B9,%11010011 + !byte $0D,%11010011 + !byte $B9,%11110011 + !byte $09,%11110011 + !byte $61,%00100110 + !byte $5F,%01000110 + !byte $63,%01100110 + !byte $63,%10000111; + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $43,%01100110 + !byte $43,%10000111; + !byte $41,%01100110 + !byte $41,%10000111; + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $65,%10100111 + !byte $5D,%10100111 + !byte $49,%10100111 + !byte $47,%10100111 + !byte $45,%10100111 + !byte $67,%11000111 + !byte $5D,%11000111 + !byte $51,%11000111 + !byte $4F,%11000111 + !byte $4D,%11000111 + !byte $4B,%11000111 + !byte $67,%11100111 + !byte $5B,%11100111 + !byte $57,%11100111 + !byte $55,%11100111 + !byte $53,%11100111 + !byte $51,%11100111 + !byte $3F,%11100111 + !byte $69,%00001000 + !byte $59,%00001000 + !byte $57,%00001000 + !byte $6B,%00101000 + !byte $6D,%01101000 + !byte $6D,%10001001; + !byte $6F,%10101001 + !byte $41,%10101001 + !byte $71,%11001001 + !byte $71,%11101001 + !byte $73,%00001010 + !byte $75,%00101010 + !byte $77,%01101010 + !byte $77,%10001011; + !byte $79,%10101011 + !byte $41,%10101011 + !byte $3F,%10101011 + !byte $7B,%11001011 + !byte $3D,%11001011 + !byte $3B,%11001011 + !byte $39,%11001011 + !byte $7B,%11101011 + !byte $37,%11101011 + !byte $7D,%00001100 + !byte $7F,%00101100 + !byte $91,%01001100 + !byte $8D,%01101100 + !byte $8D,%10001101; + !byte $8B,%01101100 + !byte $8B,%10001101; + !byte $81,%01101100 + !byte $81,%10001101; + !byte $91,%10101101 + !byte $87,%10101101 + !byte $85,%10101101 + !byte $83,%10101101 + !byte $91,%11001101 + !byte $91,%11101101 + !byte $91,%00001110 + !byte $91,%00101110 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $21,%01101110 + !byte $21,%10001111; + !byte $2D,%10101111 + !byte $2B,%10101111 + !byte $1D,%10101111 + !byte $37,%11001111 + !byte $35,%11001111 + !byte $33,%11001111 + !byte $3F,%11101111 + !byte $3D,%11101111 + !byte $1F,%11101111 + !byte $49,%00010000 + !byte $47,%00010000 + !byte $8F,%00110000 + !byte $21,%00110000 + !byte $8F,%01010000 + !byte $8F,%01110000 + !byte $8F,%10010001; + !byte $8F,%10110001 + !byte $21,%10110001 + !byte $8F,%11010001 + !byte $21,%11010001 + !byte $1F,%11110001 + !byte $1B,%00010010 + !byte $19,%00110010 + !byte $17,%00110010 + !byte $15,%01010010 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $BB,%10110011 + !byte $0F,%10110011 + !byte $0D,%10110011 + !byte $BB,%11010011 + !byte $8F,%11010011 + !byte $0B,%11010011 + !byte $BB,%11110011 + !byte $07,%11110011 + !byte $61,%00000110 + !byte $5F,%00100110 + !byte $63,%01000110 + !byte $41,%01000110 + !byte $3F,%01000110 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $47,%01100110 + !byte $47,%10000111; + !byte $45,%01100110 + !byte $45,%10000111; + !byte $4F,%10100111 + !byte $4D,%10100111 + !byte $4B,%10100111 + !byte $55,%11000111 + !byte $53,%11000111 + !byte $69,%11100111 + !byte $59,%11100111 + !byte $6B,%00001000 + !byte $3F,%00001000 + !byte $6D,%01001000 + !byte $6F,%01101000 + !byte $6F,%10001001; + !byte $41,%11001001 + !byte $73,%11101001 + !byte $75,%00001010 + !byte $77,%01001010 + !byte $79,%01101010 + !byte $79,%10001011; + !byte $41,%01101010 + !byte $41,%10001011; + !byte $3D,%10101011 + !byte $37,%11001011 + !byte $7D,%11101011 + !byte $7F,%00001100 + !byte $93,%01001100 + !byte $81,%01001100 + !byte $93,%01101100 + !byte $93,%10001101; + !byte $83,%01101100 + !byte $83,%10001101; + !byte $91,%01001110 + !byte $1B,%01001110 + !byte $91,%01101110 + !byte $91,%10001111; + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $91,%10101111 + !byte $91,%11001111 + !byte $1D,%11001111 + !byte $91,%11101111 + !byte $4B,%11101111 + !byte $1F,%00010000 + !byte $21,%01010000 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $1F,%11010001 + !byte $8F,%11110001 + !byte $1D,%11110001 + !byte $8F,%00010010 + !byte $19,%00010010 + !byte $8F,%00110010 + !byte $8F,%01010010 + !byte $13,%01010010 + !byte $8F,%01110010 + !byte $8F,%10010011; + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $8F,%10110011 + !byte $BD,%11010011 + !byte $09,%11010011 + !byte $BD,%11110011 + !byte $61,%11100101 + !byte $63,%00000110 + !byte $3D,%00000110 + !byte $65,%00100110 + !byte $63,%00100110 + !byte $43,%00100110 + !byte $41,%00100110 + !byte $3F,%00100110 + !byte $3D,%00100110 + !byte $65,%01000110 + !byte $49,%01000110 + !byte $47,%01000110 + !byte $45,%01000110 + !byte $43,%01000110 + !byte $67,%01100110 + !byte $67,%10000111; + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $49,%01100110 + !byte $49,%10000111; + !byte $69,%10100111 + !byte $67,%10100111 + !byte $5B,%10100111 + !byte $57,%10100111 + !byte $55,%10100111 + !byte $53,%10100111 + !byte $51,%10100111 + !byte $69,%11000111 + !byte $5B,%11000111 + !byte $59,%11000111 + !byte $57,%11000111 + !byte $6B,%11100111 + !byte $6D,%00001000 + !byte $6F,%00101000 + !byte $6D,%00101000 + !byte $6F,%01001000 + !byte $71,%01101000 + !byte $71,%10001001; + !byte $73,%10101001 + !byte $71,%10101001 + !byte $73,%11001001 + !byte $75,%11101001 + !byte $77,%00001010 + !byte $79,%00101010 + !byte $77,%00101010 + !byte $79,%01001010 + !byte $41,%01001010 + !byte $7B,%01101010 + !byte $7B,%10001011; + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $7D,%10101011 + !byte $7B,%10101011 + !byte $3B,%10101011 + !byte $39,%10101011 + !byte $37,%10101011 + !byte $7D,%11001011 + !byte $7F,%11101011 + !byte $81,%00001100 + !byte $95,%00101100 + !byte $93,%00101100 + !byte $83,%00101100 + !byte $81,%00101100 + !byte $8F,%01001100 + !byte $8D,%01001100 + !byte $83,%01001100 + !byte $89,%01101100 + !byte $89,%10001101; + !byte $87,%01101100 + !byte $87,%10001101; + !byte $85,%01101100 + !byte $85,%10001101; + !byte $93,%10101101 + !byte $93,%11001101 + !byte $93,%11101101 + !byte $93,%00001110 + !byte $93,%00101110 + !byte $93,%01001110 + !byte $1F,%01001110 + !byte $1D,%01001110 + !byte $93,%01101110 + !byte $93,%10001111; + !byte $29,%01101110 + !byte $29,%10001111; + !byte $27,%01101110 + !byte $27,%10001111; + !byte $25,%01101110 + !byte $25,%10001111; + !byte $93,%10101111 + !byte $33,%10101111 + !byte $31,%10101111 + !byte $2F,%10101111 + !byte $3B,%11001111 + !byte $39,%11001111 + !byte $49,%11101111 + !byte $47,%11101111 + !byte $45,%11101111 + !byte $43,%11101111 + !byte $41,%11101111 + !byte $1D,%11101111 + !byte $91,%00010000 + !byte $91,%00110000 + !byte $1F,%00110000 + !byte $91,%01010000 + !byte $1F,%01010000 + !byte $91,%01110000 + !byte $91,%10010001; + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $91,%10110001 + !byte $1F,%10110001 + !byte $91,%11010001 + !byte $1D,%11010001 + !byte $91,%11110001 + !byte $1B,%11110001 + !byte $91,%00010010 + !byte $17,%00010010 + !byte $91,%00110010 + !byte $15,%00110010 + !byte $13,%00110010 + !byte $11,%01010010 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $BF,%10110011 + !byte $BD,%10110011 + !byte $0B,%10110011 + !byte $BF,%11010011 + !byte $91,%11010011 + !byte $07,%11010011 + !byte $BF,%11110011 + !byte $05,%11110011 + !byte $03,%11110011 + !byte $61,%11000101 + !byte $63,%11100101 + !byte $5F,%00000110 + !byte $41,%00000110 + !byte $3F,%00000110 + !byte $47,%00100110 + !byte $45,%00100110 + !byte $67,%01000110 + !byte $5D,%01000110 + !byte $4D,%01000110 + !byte $4B,%01000110 + !byte $3D,%01000110 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $53,%01100110 + !byte $53,%10000111; + !byte $51,%01100110 + !byte $51,%10000111; + !byte $59,%10100111 + !byte $6B,%11000111 + !byte $6D,%11100111 + !byte $71,%01001000 + !byte $73,%01101000 + !byte $73,%10001001; + !byte $75,%11001001 + !byte $77,%11101001 + !byte $41,%11101001 + !byte $41,%00001010 + !byte $41,%00101010 + !byte $7B,%01001010 + !byte $3F,%01001010 + !byte $7D,%01101010 + !byte $7D,%10001011; + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $39,%01101010 + !byte $39,%10001011; + !byte $35,%10101011 + !byte $7F,%11001011 + !byte $81,%11101011 + !byte $95,%01001100 + !byte $85,%01001100 + !byte $95,%01101100 + !byte $95,%10001101; + !byte $95,%10101101 + !byte $95,%11001101 + !byte $95,%11101101 + !byte $19,%01001110 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $1B,%10101111 + !byte $93,%11001111 + !byte $1B,%11001111 + !byte $93,%11101111 + !byte $93,%00010000 + !byte $1D,%00010000 + !byte $93,%00110000 + !byte $93,%01010000 + !byte $1D,%10110001 + !byte $19,%11110001 + !byte $91,%01010010 + !byte $0F,%01010010 + !byte $91,%01110010 + !byte $91,%10010011; + !byte $91,%10110011 + !byte $09,%10110011 + !byte $05,%11010011 + !byte $61,%01100100 + !byte $61,%10000101; + !byte $61,%10100101 + !byte $63,%11000101 + !byte $65,%11100101 + !byte $5F,%11100101 + !byte $41,%11100101 + !byte $3F,%11100101 + !byte $3D,%11100101 + !byte $65,%00000110 + !byte $49,%00000110 + !byte $47,%00000110 + !byte $45,%00000110 + !byte $43,%00000110 + !byte $67,%00100110 + !byte $5D,%00100110 + !byte $4F,%00100110 + !byte $4D,%00100110 + !byte $4B,%00100110 + !byte $49,%00100110 + !byte $69,%01000110 + !byte $5B,%01000110 + !byte $55,%01000110 + !byte $53,%01000110 + !byte $51,%01000110 + !byte $4F,%01000110 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $59,%01100110 + !byte $59,%10000111; + !byte $57,%01100110 + !byte $57,%10000111; + !byte $55,%01100110 + !byte $55,%10000111; + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $6B,%10100111 + !byte $6D,%11000111 + !byte $6F,%11100111 + !byte $6F,%00001000 + !byte $71,%00101000 + !byte $3F,%00101000 + !byte $73,%01001000 + !byte $75,%01101000 + !byte $75,%10001001; + !byte $75,%10101001 + !byte $77,%11001001 + !byte $79,%11101001 + !byte $79,%00001010 + !byte $7B,%00101010 + !byte $3F,%00101010 + !byte $7D,%01001010 + !byte $3D,%01001010 + !byte $3B,%01001010 + !byte $39,%01001010 + !byte $7F,%01101010 + !byte $7F,%10001011; + !byte $37,%01101010 + !byte $37,%10001011; + !byte $35,%01101010 + !byte $35,%10001011; + !byte $33,%01101010 + !byte $33,%10001011; + !byte $7F,%10101011 + !byte $81,%11001011 + !byte $83,%11101011 + !byte $97,%00001100 + !byte $95,%00001100 + !byte $83,%00001100 + !byte $91,%00101100 + !byte $8F,%00101100 + !byte $85,%00101100 + !byte $8B,%01001100 + !byte $89,%01001100 + !byte $87,%01001100 + !byte $95,%00001110 + !byte $95,%00101110 + !byte $1B,%00101110 + !byte $19,%00101110 + !byte $17,%00101110 + !byte $95,%01001110 + !byte $25,%01001110 + !byte $23,%01001110 + !byte $21,%01001110 + !byte $95,%01101110 + !byte $95,%10001111; + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $37,%10101111 + !byte $35,%10101111 + !byte $41,%11001111 + !byte $3F,%11001111 + !byte $3D,%11001111 + !byte $1B,%11101111 + !byte $1D,%00110000 + !byte $1D,%01010000 + !byte $93,%01110000 + !byte $93,%10010001; + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $93,%10110001 + !byte $93,%11010001 + !byte $1B,%11010001 + !byte $19,%11010001 + !byte $93,%11110001 + !byte $17,%11110001 + !byte $93,%00010010 + !byte $15,%00010010 + !byte $13,%00010010 + !byte $11,%00110010 + !byte $0D,%01010010 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $09,%01110010 + !byte $09,%10010011; + !byte $07,%10110011 + !byte $93,%11010011 + !byte $03,%11010011 + !byte $01,%11110011 + !byte $63,%10100101 + !byte $5F,%10100101 + !byte $5F,%11000101 + !byte $3F,%11000101 + !byte $3D,%11000101 + !byte $3B,%11000101 + !byte $45,%11100101 + !byte $43,%11100101 + !byte $3B,%11100101 + !byte $67,%00000110 + !byte $5D,%00000110 + !byte $4B,%00000110 + !byte $3B,%00000110 + !byte $53,%00100110 + !byte $51,%00100110 + !byte $59,%01000110 + !byte $57,%01000110 + !byte $6D,%10100111 + !byte $3D,%10100111 + !byte $3D,%11000111 + !byte $3D,%11100111 + !byte $71,%00001000 + !byte $3F,%01001000 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $77,%10101001 + !byte $3F,%10101001 + !byte $3F,%11101001 + !byte $7B,%00001010 + !byte $3F,%00001010 + !byte $3D,%00101010 + !byte $3B,%00101010 + !byte $37,%01001010 + !byte $35,%01001010 + !byte $81,%10101011 + !byte $93,%00001100 + !byte $85,%00001100 + !byte $97,%00101100 + !byte $8D,%00101100 + !byte $87,%00101100 + !byte $97,%01001100 + !byte $97,%01101100 + !byte $97,%10001101; + !byte $97,%10101101 + !byte $15,%00101110 + !byte $17,%01001110 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $95,%10101111 + !byte $19,%10101111 + !byte $17,%10101111 + !byte $95,%11001111 + !byte $49,%11001111 + !byte $19,%11001111 + !byte $95,%11101111 + !byte $19,%11101111 + !byte $95,%00010000 + !byte $1B,%00010000 + !byte $1B,%00110000 + !byte $1B,%01010000 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $1B,%10110001 + !byte $17,%11010001 + !byte $15,%11110001 + !byte $11,%00010010 + !byte $93,%00110010 + !byte $0F,%00110010 + !byte $93,%01010010 + !byte $0B,%01010010 + !byte $93,%01110010 + !byte $93,%10010011; + !byte $07,%01110010 + !byte $07,%10010011; + !byte $93,%10110011 + !byte $05,%10110011 + !byte $01,%11010011 + !byte $61,%01000100 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $65,%10100101 + !byte $41,%10100101 + !byte $3F,%10100101 + !byte $3D,%10100101 + !byte $3B,%10100101 + !byte $65,%11000101 + !byte $5D,%11000101 + !byte $47,%11000101 + !byte $45,%11000101 + !byte $43,%11000101 + !byte $41,%11000101 + !byte $67,%11100101 + !byte $5D,%11100101 + !byte $4D,%11100101 + !byte $4B,%11100101 + !byte $49,%11100101 + !byte $47,%11100101 + !byte $69,%00000110 + !byte $5B,%00000110 + !byte $53,%00000110 + !byte $51,%00000110 + !byte $4F,%00000110 + !byte $4D,%00000110 + !byte $69,%00100110 + !byte $5B,%00100110 + !byte $59,%00100110 + !byte $57,%00100110 + !byte $55,%00100110 + !byte $3B,%00100110 + !byte $6B,%01000110 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $6F,%10100111 + !byte $6F,%11000111 + !byte $71,%11100111 + !byte $73,%00001000 + !byte $73,%00101000 + !byte $75,%01001000 + !byte $77,%01101000 + !byte $77,%10001001; + !byte $79,%10101001 + !byte $79,%11001001 + !byte $3F,%11001001 + !byte $7B,%11101001 + !byte $7D,%00001010 + !byte $3D,%00001010 + !byte $3B,%00001010 + !byte $7D,%00101010 + !byte $39,%00101010 + !byte $37,%00101010 + !byte $35,%00101010 + !byte $7F,%01001010 + !byte $33,%01001010 + !byte $81,%01101010 + !byte $81,%10001011; + !byte $83,%10101011 + !byte $83,%11001011 + !byte $97,%11101011 + !byte $95,%11101011 + !byte $85,%11101011 + !byte $91,%00001100 + !byte $87,%00001100 + !byte $8B,%00101100 + !byte $89,%00101100 + !byte $97,%11001101 + !byte $97,%11101101 + !byte $97,%00001110 + !byte $17,%00001110 + !byte $15,%00001110 + !byte $13,%00001110 + !byte $97,%00101110 + !byte $1F,%00101110 + !byte $1D,%00101110 + !byte $29,%01001110 + !byte $27,%01001110 + !byte $15,%01001110 + !byte $33,%01101110 + !byte $33,%10001111; + !byte $31,%01101110 + !byte $31,%10001111; + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $3B,%10101111 + !byte $39,%10101111 + !byte $47,%11001111 + !byte $45,%11001111 + !byte $43,%11001111 + !byte $17,%11001111 + !byte $19,%00010000 + !byte $95,%00110000 + !byte $95,%01010000 + !byte $95,%01110000 + !byte $95,%10010001; + !byte $19,%01110000 + !byte $19,%10010001; + !byte $95,%10110001 + !byte $19,%10110001 + !byte $95,%11010001 + !byte $15,%11010001 + !byte $13,%11110001 + !byte $0F,%00010010 + !byte $0D,%00110010 + !byte $0B,%00110010 + !byte $09,%01010010 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $03,%10110011 + !byte $01,%10110011 + !byte $95,%11010011 + !byte $61,%00100100 + !byte $63,%01000100 + !byte $5F,%01000100 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $39,%01100100 + !byte $39,%10000101; + !byte $5D,%10100101 + !byte $45,%10100101 + !byte $43,%10100101 + !byte $39,%10100101 + !byte $67,%11000101 + !byte $4B,%11000101 + !byte $49,%11000101 + !byte $69,%11100101 + !byte $51,%11100101 + !byte $4F,%11100101 + !byte $59,%00000110 + !byte $57,%00000110 + !byte $55,%00000110 + !byte $6B,%00100110 + !byte $6D,%01000110 + !byte $3B,%01000110 + !byte $71,%11000111 + !byte $73,%11100111 + !byte $3D,%00001000 + !byte $75,%00101000 + !byte $77,%01001000 + !byte $7B,%11001001 + !byte $7D,%11101001 + !byte $3D,%11101001 + !byte $39,%00001010 + !byte $37,%00001010 + !byte $7F,%00101010 + !byte $33,%00101010 + !byte $81,%01001010 + !byte $31,%01001010 + !byte $85,%11001011 + !byte $99,%11101011 + !byte $87,%11101011 + !byte $99,%00001100 + !byte $8F,%00001100 + !byte $89,%00001100 + !byte $99,%00101100 + !byte $99,%01001100 + !byte $99,%01101100 + !byte $99,%10001101; + !byte $13,%00101110 + !byte $97,%01001110 + !byte $97,%01101110 + !byte $97,%10001111; + !byte $15,%01101110 + !byte $15,%10001111; + !byte $97,%10101111 + !byte $15,%10101111 + !byte $97,%11001111 + !byte $97,%11101111 + !byte $17,%11101111 + !byte $19,%00110000 + !byte $19,%01010000 + !byte $17,%10110001 + !byte $95,%11110001 + !byte $11,%11110001 + !byte $95,%00010010 + !byte $0D,%00010010 + !byte $95,%00110010 + !byte $95,%01010010 + !byte $07,%01010010 + !byte $95,%01110010 + !byte $95,%10010011; + !byte $03,%01110010 + !byte $03,%10010011; + !byte $95,%10110011 + !byte $61,%11100011 + !byte $61,%00000100 + !byte $63,%00100100 + !byte $5F,%00100100 + !byte $39,%00100100 + !byte $65,%01000100 + !byte $3F,%01000100 + !byte $3D,%01000100 + !byte $3B,%01000100 + !byte $39,%01000100 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $65,%01100100 + !byte $65,%10000101; + !byte $45,%01100100 + !byte $45,%10000101; + !byte $43,%01100100 + !byte $43,%10000101; + !byte $41,%01100100 + !byte $41,%10000101; + !byte $67,%10100101 + !byte $4D,%10100101 + !byte $4B,%10100101 + !byte $49,%10100101 + !byte $47,%10100101 + !byte $69,%11000101 + !byte $53,%11000101 + !byte $51,%11000101 + !byte $4F,%11000101 + !byte $4D,%11000101 + !byte $6B,%11100101 + !byte $5B,%11100101 + !byte $59,%11100101 + !byte $57,%11100101 + !byte $55,%11100101 + !byte $53,%11100101 + !byte $6B,%00000110 + !byte $6D,%00100110 + !byte $6F,%01000110 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $71,%10100111 + !byte $73,%11000111 + !byte $75,%11100111 + !byte $75,%00001000 + !byte $77,%00101000 + !byte $79,%01001000 + !byte $7B,%01101000 + !byte $7B,%10001001; + !byte $79,%01101000 + !byte $79,%10001001; + !byte $7B,%10101001 + !byte $7D,%11001001 + !byte $3D,%11001001 + !byte $7F,%11101001 + !byte $3B,%11101001 + !byte $39,%11101001 + !byte $37,%11101001 + !byte $7F,%00001010 + !byte $35,%00001010 + !byte $33,%00001010 + !byte $31,%00001010 + !byte $81,%00101010 + !byte $31,%00101010 + !byte $83,%01001010 + !byte $85,%01101010 + !byte $85,%10001011; + !byte $83,%01101010 + !byte $83,%10001011; + !byte $85,%10101011 + !byte $9B,%11001011 + !byte $99,%11001011 + !byte $97,%11001011 + !byte $87,%11001011 + !byte $9B,%11101011 + !byte $93,%11101011 + !byte $91,%11101011 + !byte $89,%11101011 + !byte $9B,%00001100 + !byte $8D,%00001100 + !byte $8B,%00001100 + !byte $9B,%00101100 + !byte $99,%10101101 + !byte $99,%11001101 + !byte $99,%11101101 + !byte $11,%11101101 + !byte $99,%00001110 + !byte $1B,%00001110 + !byte $19,%00001110 + !byte $11,%00001110 + !byte $99,%00101110 + !byte $25,%00101110 + !byte $23,%00101110 + !byte $21,%00101110 + !byte $99,%01001110 + !byte $2D,%01001110 + !byte $2B,%01001110 + !byte $13,%01001110 + !byte $99,%01101110 + !byte $99,%10001111; + !byte $37,%01101110 + !byte $37,%10001111; + !byte $35,%01101110 + !byte $35,%10001111; + !byte $99,%10101111 + !byte $47,%10101111 + !byte $41,%10101111 + !byte $3F,%10101111 + !byte $3D,%10101111 + !byte $99,%11001111 + !byte $97,%00010000 + !byte $17,%00010000 + !byte $97,%00110000 + !byte $17,%00110000 + !byte $97,%01010000 + !byte $17,%01010000 + !byte $97,%01110000 + !byte $97,%10010001; + !byte $17,%01110000 + !byte $17,%10010001; + !byte $97,%10110001 + !byte $15,%10110001 + !byte $97,%11010001 + !byte $13,%11010001 + !byte $11,%11010001 + !byte $97,%11110001 + !byte $0F,%11110001 + !byte $97,%00010010 + !byte $0B,%00010010 + !byte $97,%00110010 + !byte $09,%00110010 + !byte $07,%00110010 + !byte $05,%01010010 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $B9,%10110011 + !byte $97,%10110011 + !byte $99,%11010011 + !byte $97,%11010011 + !byte $61,%11000011 + !byte $63,%00000100 + !byte $65,%00100100 + !byte $3D,%00100100 + !byte $3B,%00100100 + !byte $67,%01000100 + !byte $43,%01000100 + !byte $41,%01000100 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $49,%01100100 + !byte $49,%10000101; + !byte $47,%01100100 + !byte $47,%10000101; + !byte $69,%10100101 + !byte $51,%10100101 + !byte $4F,%10100101 + !byte $6B,%11000101 + !byte $5B,%11000101 + !byte $59,%11000101 + !byte $57,%11000101 + !byte $55,%11000101 + !byte $6D,%00000110 + !byte $6F,%00100110 + !byte $71,%01000110 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $73,%10100111 + !byte $75,%11000111 + !byte $77,%00001000 + !byte $79,%00101000 + !byte $3D,%00101000 + !byte $7B,%01001000 + !byte $3D,%01001000 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $7D,%10101001 + !byte $3D,%10101001 + !byte $7F,%11001001 + !byte $3B,%11001001 + !byte $35,%11101001 + !byte $81,%00001010 + !byte $2F,%00001010 + !byte $83,%00101010 + !byte $85,%01001010 + !byte $87,%10101011 + !byte $89,%11001011 + !byte $8B,%11101011 + !byte $9B,%01001100 + !byte $9B,%01101100 + !byte $9B,%10001101; + !byte $9B,%10101101 + !byte $9B,%11001101 + !byte $9B,%11101101 + !byte $13,%11101101 + !byte $0F,%11101101 + !byte $11,%00101110 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $45,%10101111 + !byte $13,%10101111 + !byte $15,%11001111 + !byte $99,%11101111 + !byte $15,%11101111 + !byte $99,%00010000 + !byte $99,%00110000 + !byte $99,%01010000 + !byte $99,%01110000 + !byte $99,%10010001; + !byte $15,%01110000 + !byte $15,%10010001; + !byte $13,%10110001 + !byte $0D,%11110001 + !byte $97,%01010010 + !byte $03,%01010010 + !byte $97,%01110010 + !byte $97,%10010011; + !byte $61,%10100011 + !byte $63,%11100011 + !byte $5F,%11100011 + !byte $37,%11100011 + !byte $65,%00000100 + !byte $5F,%00000100 + !byte $3D,%00000100 + !byte $3B,%00000100 + !byte $39,%00000100 + !byte $37,%00000100 + !byte $5D,%00100100 + !byte $45,%00100100 + !byte $43,%00100100 + !byte $41,%00100100 + !byte $3F,%00100100 + !byte $37,%00100100 + !byte $5D,%01000100 + !byte $4B,%01000100 + !byte $49,%01000100 + !byte $47,%01000100 + !byte $45,%01000100 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $51,%01100100 + !byte $51,%10000101; + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $6B,%10100101 + !byte $5B,%10100101 + !byte $59,%10100101 + !byte $57,%10100101 + !byte $55,%10100101 + !byte $53,%10100101 + !byte $39,%11000101 + !byte $6D,%11100101 + !byte $39,%11100101 + !byte $6F,%00000110 + !byte $39,%00000110 + !byte $71,%00100110 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $75,%10100111 + !byte $3B,%10100111 + !byte $3B,%11000111 + !byte $77,%11100111 + !byte $79,%00001000 + !byte $7B,%00101000 + !byte $7D,%01101000 + !byte $7D,%10001001; + !byte $7F,%10101001 + !byte $3B,%10101001 + !byte $39,%10101001 + !byte $39,%11001001 + !byte $37,%11001001 + !byte $35,%11001001 + !byte $33,%11001001 + !byte $81,%11101001 + !byte $33,%11101001 + !byte $31,%11101001 + !byte $2F,%11101001 + !byte $2D,%11101001 + !byte $83,%00001010 + !byte $85,%00101010 + !byte $87,%01101010 + !byte $87,%10001011; + !byte $9D,%10101011 + !byte $9B,%10101011 + !byte $99,%10101011 + !byte $89,%10101011 + !byte $9D,%11001011 + !byte $95,%11001011 + !byte $93,%11001011 + !byte $8B,%11001011 + !byte $9D,%11101011 + !byte $8F,%11101011 + !byte $8D,%11101011 + !byte $0D,%11001101 + !byte $15,%11101101 + !byte $9B,%00001110 + !byte $1F,%00001110 + !byte $1D,%00001110 + !byte $0F,%00001110 + !byte $9B,%00101110 + !byte $29,%00101110 + !byte $27,%00101110 + !byte $0F,%00101110 + !byte $9B,%01001110 + !byte $33,%01001110 + !byte $31,%01001110 + !byte $2F,%01001110 + !byte $11,%01001110 + !byte $9B,%01101110 + !byte $9B,%10001111; + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $39,%01101110 + !byte $39,%10001111; + !byte $11,%01101110 + !byte $11,%10001111; + !byte $43,%10101111 + !byte $13,%11001111 + !byte $15,%00010000 + !byte $15,%00110000 + !byte $15,%01010000 + !byte $13,%01010000 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $99,%10110001 + !byte $11,%10110001 + !byte $99,%11010001 + !byte $0F,%11010001 + !byte $0D,%11010001 + !byte $99,%11110001 + !byte $0B,%11110001 + !byte $09,%11110001 + !byte $09,%00010010 + !byte $07,%00010010 + !byte $05,%00110010 + !byte $03,%00110010 + !byte $01,%01010010 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $63,%11000011 + !byte $5F,%11000011 + !byte $65,%11100011 + !byte $3B,%11100011 + !byte $39,%11100011 + !byte $5D,%00000100 + !byte $43,%00000100 + !byte $41,%00000100 + !byte $3F,%00000100 + !byte $67,%00100100 + !byte $49,%00100100 + !byte $47,%00100100 + !byte $69,%01000100 + !byte $5B,%01000100 + !byte $4F,%01000100 + !byte $4D,%01000100 + !byte $37,%01000100 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $59,%01100100 + !byte $59,%10000101; + !byte $57,%01100100 + !byte $57,%10000101; + !byte $55,%01100100 + !byte $55,%10000101; + !byte $53,%01100100 + !byte $53,%10000101; + !byte $37,%01100100 + !byte $37,%10000101; + !byte $6D,%11000101 + !byte $6F,%11100101 + !byte $39,%00100110 + !byte $73,%01000110 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $77,%11000111 + !byte $79,%11100111 + !byte $3B,%11100111 + !byte $7D,%01001000 + !byte $3B,%01001000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $37,%10101001 + !byte $81,%11001001 + !byte $31,%11001001 + !byte $83,%11101001 + !byte $87,%01001010 + !byte $9D,%01101010 + !byte $9D,%10001011; + !byte $89,%01101010 + !byte $89,%10001011; + !byte $97,%10101011 + !byte $91,%11001011 + !byte $8F,%11001011 + !byte $8D,%11001011 + !byte $9D,%00001100 + !byte $9D,%00101100 + !byte $9D,%01001100 + !byte $9D,%01101100 + !byte $9D,%10001101; + !byte $9D,%10101101 + !byte $0B,%11001101 + !byte $17,%11101101 + !byte $0D,%11101101 + !byte $0D,%00001110 + !byte $0F,%01001110 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $9B,%10101111 + !byte $11,%10101111 + !byte $9B,%11001111 + !byte $11,%11001111 + !byte $9B,%11101111 + !byte $13,%11101111 + !byte $9B,%00010000 + !byte $13,%00010000 + !byte $9B,%00110000 + !byte $13,%00110000 + !byte $11,%01110000 + !byte $11,%10010001; + !byte $0F,%10110001 + !byte $0B,%11010001 + !byte $99,%00010010 + !byte $05,%00010010 + !byte $99,%00110010 + !byte $01,%00110010 + !byte $99,%01010010 + !byte $99,%01110010 + !byte $99,%10010011; + !byte $99,%10110011 + !byte $61,%01000010 + !byte $63,%10100011 + !byte $5F,%10100011 + !byte $37,%10100011 + !byte $35,%10100011 + !byte $65,%11000011 + !byte $3D,%11000011 + !byte $3B,%11000011 + !byte $39,%11000011 + !byte $37,%11000011 + !byte $35,%11000011 + !byte $67,%11100011 + !byte $5D,%11100011 + !byte $43,%11100011 + !byte $41,%11100011 + !byte $3F,%11100011 + !byte $3D,%11100011 + !byte $67,%00000100 + !byte $49,%00000100 + !byte $47,%00000100 + !byte $45,%00000100 + !byte $69,%00100100 + !byte $5B,%00100100 + !byte $4F,%00100100 + !byte $4D,%00100100 + !byte $4B,%00100100 + !byte $6B,%01000100 + !byte $59,%01000100 + !byte $57,%01000100 + !byte $55,%01000100 + !byte $53,%01000100 + !byte $51,%01000100 + !byte $6D,%10100101 + !byte $6F,%11000101 + !byte $71,%11100101 + !byte $71,%00000110 + !byte $73,%00100110 + !byte $75,%01000110 + !byte $77,%10100111 + !byte $79,%11000111 + !byte $7B,%11100111 + !byte $7B,%00001000 + !byte $3B,%00001000 + !byte $7D,%00101000 + !byte $3B,%00101000 + !byte $7F,%01001000 + !byte $7F,%01101000 + !byte $7F,%10001001; + !byte $39,%01101000 + !byte $39,%10001001; + !byte $37,%01101000 + !byte $37,%10001001; + !byte $81,%10101001 + !byte $35,%10101001 + !byte $33,%10101001 + !byte $31,%10101001 + !byte $83,%11001001 + !byte $2F,%11001001 + !byte $2D,%11001001 + !byte $85,%11101001 + !byte $85,%00001010 + !byte $87,%00101010 + !byte $9F,%01001010 + !byte $89,%01001010 + !byte $9F,%01101010 + !byte $9F,%10001011; + !byte $9B,%01101010 + !byte $9B,%10001011; + !byte $99,%01101010 + !byte $99,%10001011; + !byte $9F,%10101011 + !byte $95,%10101011 + !byte $93,%10101011 + !byte $8D,%10101011 + !byte $8B,%10101011 + !byte $9F,%11001011 + !byte $9D,%11001101 + !byte $11,%11001101 + !byte $0F,%11001101 + !byte $9D,%11101101 + !byte $1B,%11101101 + !byte $19,%11101101 + !byte $0B,%11101101 + !byte $9D,%00001110 + !byte $25,%00001110 + !byte $23,%00001110 + !byte $21,%00001110 + !byte $9D,%00101110 + !byte $2D,%00101110 + !byte $2B,%00101110 + !byte $0D,%00101110 + !byte $9D,%01001110 + !byte $37,%01001110 + !byte $35,%01001110 + !byte $45,%01101110 + !byte $45,%10001111; + !byte $43,%01101110 + !byte $43,%10001111; + !byte $41,%01101110 + !byte $41,%10001111; + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $11,%11101111 + !byte $11,%00010000 + !byte $11,%00110000 + !byte $9B,%01010000 + !byte $11,%01010000 + !byte $9B,%01110000 + !byte $9B,%10010001; + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $9B,%10110001 + !byte $0D,%10110001 + !byte $9B,%11010001 + !byte $09,%11010001 + !byte $07,%11110001 + !byte $05,%11110001 + !byte $03,%00010010 + !byte $9B,%10110011 + !byte $61,%00100010 + !byte $63,%01000010 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $35,%01100010 + !byte $35,%10000011; + !byte $65,%10100011 + !byte $3B,%10100011 + !byte $39,%10100011 + !byte $67,%11000011 + !byte $41,%11000011 + !byte $3F,%11000011 + !byte $47,%11100011 + !byte $45,%11100011 + !byte $69,%00000100 + !byte $4F,%00000100 + !byte $4D,%00000100 + !byte $4B,%00000100 + !byte $6B,%00100100 + !byte $59,%00100100 + !byte $55,%00100100 + !byte $53,%00100100 + !byte $51,%00100100 + !byte $6D,%01000100 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $6F,%10100101 + !byte $71,%11000101 + !byte $73,%00000110 + !byte $75,%00100110 + !byte $77,%01000110 + !byte $39,%01000110 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $79,%10100111 + !byte $7B,%11000111 + !byte $7D,%00001000 + !byte $7F,%00101000 + !byte $81,%01001000 + !byte $39,%01001000 + !byte $81,%01101000 + !byte $81,%10001001; + !byte $35,%01101000 + !byte $35,%10001001; + !byte $33,%01101000 + !byte $33,%10001001; + !byte $83,%10101001 + !byte $2F,%10101001 + !byte $2D,%10101001 + !byte $85,%11001001 + !byte $87,%00001010 + !byte $89,%00101010 + !byte $A1,%01001010 + !byte $8B,%01001010 + !byte $A1,%01101010 + !byte $A1,%10001011; + !byte $8B,%01101010 + !byte $8B,%10001011; + !byte $A1,%10101011 + !byte $91,%10101011 + !byte $8F,%10101011 + !byte $9F,%11101011 + !byte $9F,%00001100 + !byte $9F,%00101100 + !byte $9F,%01001100 + !byte $9F,%01101100 + !byte $9F,%10001101; + !byte $9F,%10101101 + !byte $09,%10101101 + !byte $9F,%11001101 + !byte $13,%11001101 + !byte $9F,%11101101 + !byte $9F,%00001110 + !byte $0B,%00001110 + !byte $2F,%00101110 + !byte $0D,%01001110 + !byte $9D,%01101110 + !byte $9D,%10001111; + !byte $9D,%10101111 + !byte $0F,%10101111 + !byte $9D,%11001111 + !byte $9D,%11101111 + !byte $9D,%00010000 + !byte $9D,%00110000 + !byte $9D,%01010000 + !byte $0F,%01010000 + !byte $9D,%01110000 + !byte $9D,%10010001; + !byte $9D,%10110001 + !byte $0B,%10110001 + !byte $9B,%11110001 + !byte $9B,%00010010 + !byte $01,%00010010 + !byte $9B,%00110010 + !byte $9B,%01010010 + !byte $9B,%01110010 + !byte $9B,%10010011; + !byte $61,%00000010 + !byte $63,%00100010 + !byte $65,%01000010 + !byte $5F,%01000010 + !byte $35,%01000010 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $39,%01100010 + !byte $39,%10000011; + !byte $37,%01100010 + !byte $37,%10000011; + !byte $67,%10100011 + !byte $5D,%10100011 + !byte $43,%10100011 + !byte $41,%10100011 + !byte $3F,%10100011 + !byte $3D,%10100011 + !byte $69,%11000011 + !byte $5D,%11000011 + !byte $49,%11000011 + !byte $47,%11000011 + !byte $45,%11000011 + !byte $43,%11000011 + !byte $69,%11100011 + !byte $4F,%11100011 + !byte $4D,%11100011 + !byte $4B,%11100011 + !byte $49,%11100011 + !byte $35,%11100011 + !byte $6B,%00000100 + !byte $5B,%00000100 + !byte $59,%00000100 + !byte $57,%00000100 + !byte $55,%00000100 + !byte $53,%00000100 + !byte $51,%00000100 + !byte $6D,%00100100 + !byte $57,%00100100 + !byte $6F,%01000100 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $71,%10100101 + !byte $37,%10100101 + !byte $73,%11000101 + !byte $73,%11100101 + !byte $75,%00000110 + !byte $77,%00100110 + !byte $79,%01000110 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $7B,%10100111 + !byte $7D,%11000111 + !byte $7D,%11100111 + !byte $7F,%00001000 + !byte $81,%00101000 + !byte $39,%00101000 + !byte $83,%01001000 + !byte $37,%01001000 + !byte $35,%01001000 + !byte $33,%01001000 + !byte $83,%01101000 + !byte $83,%10001001; + !byte $31,%01101000 + !byte $31,%10001001; + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $85,%10101001 + !byte $2B,%10101001 + !byte $87,%11001001 + !byte $87,%11101001 + !byte $89,%00001010 + !byte $A1,%00101010 + !byte $8B,%00101010 + !byte $9D,%01001010 + !byte $9B,%01001010 + !byte $8D,%01001010 + !byte $97,%01101010 + !byte $97,%10001011; + !byte $95,%01101010 + !byte $95,%10001011; + !byte $8F,%01101010 + !byte $8F,%10001011; + !byte $8D,%01101010 + !byte $8D,%10001011; + !byte $A1,%11001011 + !byte $A1,%11101011 + !byte $A1,%00001100 + !byte $A1,%00101100 + !byte $0D,%10101101 + !byte $0B,%10101101 + !byte $17,%11001101 + !byte $15,%11001101 + !byte $09,%11001101 + !byte $21,%11101101 + !byte $1F,%11101101 + !byte $1D,%11101101 + !byte $29,%00001110 + !byte $27,%00001110 + !byte $9F,%00101110 + !byte $33,%00101110 + !byte $31,%00101110 + !byte $0B,%00101110 + !byte $9F,%01001110 + !byte $45,%01001110 + !byte $43,%01001110 + !byte $3D,%01001110 + !byte $3B,%01001110 + !byte $39,%01001110 + !byte $9F,%01101110 + !byte $9F,%10001111; + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $9F,%10101111 + !byte $9F,%11001111 + !byte $0F,%11001111 + !byte $0F,%11101111 + !byte $0F,%00010000 + !byte $0F,%00110000 + !byte $0D,%01010000 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $09,%10110001 + !byte $9D,%11010001 + !byte $07,%11010001 + !byte $05,%11010001 + !byte $9D,%11110001 + !byte $03,%11110001 + !byte $9D,%00010010 + !byte $9D,%00110010 + !byte $9D,%01010010 + !byte $9D,%01110010 + !byte $9D,%10010011; + !byte $9D,%10110011 + !byte $61,%11100001 + !byte $63,%00000010 + !byte $5F,%00100010 + !byte $33,%00100010 + !byte $3B,%01000010 + !byte $39,%01000010 + !byte $37,%01000010 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $41,%01100010 + !byte $41,%10000011; + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $69,%10100011 + !byte $47,%10100011 + !byte $45,%10100011 + !byte $4D,%11000011 + !byte $4B,%11000011 + !byte $6B,%11100011 + !byte $5B,%11100011 + !byte $53,%11100011 + !byte $51,%11100011 + !byte $6D,%00000100 + !byte $35,%00000100 + !byte $71,%01100100 + !byte $71,%10000101; + !byte $73,%10100101 + !byte $37,%11000101 + !byte $75,%11100101 + !byte $77,%00000110 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $39,%01100110 + !byte $39,%10000111; + !byte $7D,%10100111 + !byte $7F,%11100111 + !byte $39,%11100111 + !byte $81,%00001000 + !byte $39,%00001000 + !byte $37,%00101000 + !byte $31,%01001000 + !byte $85,%01101000 + !byte $85,%10001001; + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $87,%10101001 + !byte $89,%11101001 + !byte $8B,%00001010 + !byte $A3,%00101010 + !byte $A3,%01001010 + !byte $A3,%01101010 + !byte $A3,%10001011; + !byte $93,%01101010 + !byte $93,%10001011; + !byte $91,%01101010 + !byte $91,%10001011; + !byte $A1,%01001100 + !byte $A1,%01101100 + !byte $A1,%10001101; + !byte $A1,%10101101 + !byte $07,%10101101 + !byte $A1,%11001101 + !byte $07,%11001101 + !byte $A1,%11101101 + !byte $09,%11101101 + !byte $A1,%00001110 + !byte $09,%00001110 + !byte $0B,%01001110 + !byte $0D,%10101111 + !byte $0D,%11001111 + !byte $9F,%11101111 + !byte $9F,%00010000 + !byte $9F,%00110000 + !byte $0D,%00110000 + !byte $9F,%01010000 + !byte $9F,%01110000 + !byte $9F,%10010001; + !byte $07,%10110001 + !byte $01,%11110001 + !byte $61,%11000001 + !byte $63,%11100001 + !byte $5F,%11100001 + !byte $5F,%00000010 + !byte $35,%00000010 + !byte $33,%00000010 + !byte $65,%00100010 + !byte $3B,%00100010 + !byte $39,%00100010 + !byte $37,%00100010 + !byte $35,%00100010 + !byte $67,%01000010 + !byte $5D,%01000010 + !byte $41,%01000010 + !byte $3F,%01000010 + !byte $3D,%01000010 + !byte $33,%01000010 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $47,%01100010 + !byte $47,%10000011; + !byte $45,%01100010 + !byte $45,%10000011; + !byte $43,%01100010 + !byte $43,%10000011; + !byte $33,%01100010 + !byte $33,%10000011; + !byte $5B,%10100011 + !byte $4D,%10100011 + !byte $4B,%10100011 + !byte $49,%10100011 + !byte $33,%10100011 + !byte $6B,%11000011 + !byte $5B,%11000011 + !byte $59,%11000011 + !byte $57,%11000011 + !byte $55,%11000011 + !byte $53,%11000011 + !byte $51,%11000011 + !byte $4F,%11000011 + !byte $6D,%11100011 + !byte $59,%11100011 + !byte $57,%11100011 + !byte $55,%11100011 + !byte $6F,%00100100 + !byte $35,%00100100 + !byte $71,%01000100 + !byte $35,%01000100 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $75,%11000101 + !byte $77,%11100101 + !byte $37,%11100101 + !byte $37,%00000110 + !byte $79,%00100110 + !byte $7B,%01000110 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $39,%10100111 + !byte $7F,%11000111 + !byte $39,%11000111 + !byte $81,%11100111 + !byte $37,%11100111 + !byte $37,%00001000 + !byte $35,%00001000 + !byte $83,%00101000 + !byte $35,%00101000 + !byte $33,%00101000 + !byte $31,%00101000 + !byte $2F,%00101000 + !byte $85,%01001000 + !byte $2F,%01001000 + !byte $2D,%01001000 + !byte $2B,%01001000 + !byte $29,%01001000 + !byte $87,%01101000 + !byte $87,%10001001; + !byte $29,%01101000 + !byte $29,%10001001; + !byte $89,%11001001 + !byte $8B,%11101001 + !byte $A3,%00001010 + !byte $9F,%00101010 + !byte $9D,%00101010 + !byte $8D,%00101010 + !byte $99,%01001010 + !byte $97,%01001010 + !byte $91,%01001010 + !byte $8F,%01001010 + !byte $A3,%10101011 + !byte $A3,%11001011 + !byte $A3,%11101011 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $07,%01101100 + !byte $07,%10001101; + !byte $05,%01101100 + !byte $05,%10001101; + !byte $11,%10101101 + !byte $0F,%10101101 + !byte $05,%10101101 + !byte $1B,%11001101 + !byte $19,%11001101 + !byte $25,%11101101 + !byte $23,%11101101 + !byte $07,%11101101 + !byte $2F,%00001110 + !byte $2D,%00001110 + !byte $2B,%00001110 + !byte $A1,%00101110 + !byte $37,%00101110 + !byte $35,%00101110 + !byte $09,%00101110 + !byte $A1,%01001110 + !byte $41,%01001110 + !byte $3F,%01001110 + !byte $09,%01001110 + !byte $A1,%01101110 + !byte $A1,%10001111; + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $0B,%10101111 + !byte $0D,%11101111 + !byte $0D,%00010000 + !byte $0B,%00110000 + !byte $0B,%01010000 + !byte $09,%01010000 + !byte $09,%01110000 + !byte $09,%10010001; + !byte $07,%01110000 + !byte $07,%10010001; + !byte $9F,%10110001 + !byte $05,%10110001 + !byte $03,%10110001 + !byte $9F,%11010001 + !byte $03,%11010001 + !byte $01,%11010001 + !byte $9F,%11110001 + !byte $9F,%10110011 + !byte $61,%10100001 + !byte $63,%11000001 + !byte $33,%11100001 + !byte $31,%11100001 + !byte $65,%00000010 + !byte $39,%00000010 + !byte $37,%00000010 + !byte $67,%00100010 + !byte $5D,%00100010 + !byte $3F,%00100010 + !byte $3D,%00100010 + !byte $45,%01000010 + !byte $43,%01000010 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $49,%01100010 + !byte $49,%10000011; + !byte $6B,%10100011 + !byte $59,%10100011 + !byte $51,%10100011 + !byte $4F,%10100011 + !byte $6D,%11000011 + !byte $33,%11000011 + !byte $6F,%00000100 + !byte $71,%00100100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $75,%10100101 + !byte $77,%11000101 + !byte $79,%00000110 + !byte $7B,%00100110 + !byte $37,%00100110 + !byte $37,%01000110 + !byte $7F,%10100111 + !byte $81,%11000111 + !byte $37,%11000111 + !byte $83,%00001000 + !byte $33,%00001000 + !byte $31,%00001000 + !byte $85,%00101000 + !byte $2D,%00101000 + !byte $27,%01001000 + !byte $89,%10101001 + !byte $8B,%11001001 + !byte $A5,%00001010 + !byte $A1,%00001010 + !byte $8D,%00001010 + !byte $A5,%00101010 + !byte $9B,%00101010 + !byte $8F,%00101010 + !byte $95,%01001010 + !byte $93,%01001010 + !byte $A3,%00001100 + !byte $A3,%00101100 + !byte $A3,%01001100 + !byte $A3,%01101100 + !byte $A3,%10001101; + !byte $03,%01101100 + !byte $03,%10001101; + !byte $A3,%10101101 + !byte $05,%11001101 + !byte $05,%11101101 + !byte $07,%00001110 + !byte $43,%00101110 + !byte $07,%00101110 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $A1,%10101111 + !byte $A1,%11001111 + !byte $0B,%11001111 + !byte $A1,%11101111 + !byte $0B,%11101111 + !byte $A1,%00010000 + !byte $0B,%00010000 + !byte $A1,%00110000 + !byte $9F,%00010010 + !byte $9F,%00110010 + !byte $9F,%01010010 + !byte $9F,%01110010 + !byte $9F,%10010011; + !byte $61,%01100000 + !byte $61,%10000001; + !byte $63,%10100001 + !byte $5F,%10100001 + !byte $65,%11000001 + !byte $5F,%11000001 + !byte $33,%11000001 + !byte $31,%11000001 + !byte $65,%11100001 + !byte $5D,%11100001 + !byte $39,%11100001 + !byte $37,%11100001 + !byte $35,%11100001 + !byte $67,%00000010 + !byte $5D,%00000010 + !byte $3F,%00000010 + !byte $3D,%00000010 + !byte $3B,%00000010 + !byte $31,%00000010 + !byte $69,%00100010 + !byte $47,%00100010 + !byte $45,%00100010 + !byte $43,%00100010 + !byte $41,%00100010 + !byte $69,%01000010 + !byte $5B,%01000010 + !byte $4D,%01000010 + !byte $4B,%01000010 + !byte $49,%01000010 + !byte $47,%01000010 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $59,%01100010 + !byte $59,%10000011; + !byte $53,%01100010 + !byte $53,%10000011; + !byte $51,%01100010 + !byte $51,%10000011; + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $6D,%10100011 + !byte $57,%10100011 + !byte $55,%10100011 + !byte $53,%10100011 + !byte $6F,%11000011 + !byte $6F,%11100011 + !byte $71,%00000100 + !byte $73,%00100100 + !byte $73,%01000100 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $77,%10100101 + !byte $35,%10100101 + !byte $79,%11000101 + !byte $79,%11100101 + !byte $7B,%00000110 + !byte $7D,%00100110 + !byte $7D,%01000110 + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $37,%01100110 + !byte $37,%10000111; + !byte $81,%10100111 + !byte $37,%10100111 + !byte $83,%11000111 + !byte $83,%11100111 + !byte $35,%11100111 + !byte $33,%11100111 + !byte $31,%11100111 + !byte $85,%00001000 + !byte $2F,%00001000 + !byte $2D,%00001000 + !byte $87,%00101000 + !byte $2B,%00101000 + !byte $29,%00101000 + !byte $27,%00101000 + !byte $87,%01001000 + !byte $89,%01101000 + !byte $89,%10001001; + !byte $8B,%10101001 + !byte $8D,%11001001 + !byte $A5,%11101001 + !byte $A3,%11101001 + !byte $8D,%11101001 + !byte $9F,%00001010 + !byte $9D,%00001010 + !byte $8F,%00001010 + !byte $99,%00101010 + !byte $97,%00101010 + !byte $95,%00101010 + !byte $93,%00101010 + !byte $91,%00101010 + !byte $A5,%01001010 + !byte $A5,%01101010 + !byte $A5,%10001011; + !byte $A5,%10101011 + !byte $A5,%11001011 + !byte $03,%01001100 + !byte $01,%01001100 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $17,%10101101 + !byte $15,%10101101 + !byte $13,%10101101 + !byte $03,%10101101 + !byte $A3,%11001101 + !byte $21,%11001101 + !byte $1F,%11001101 + !byte $1D,%11001101 + !byte $A3,%11101101 + !byte $29,%11101101 + !byte $27,%11101101 + !byte $A3,%00001110 + !byte $33,%00001110 + !byte $31,%00001110 + !byte $05,%00001110 + !byte $A3,%00101110 + !byte $41,%00101110 + !byte $3F,%00101110 + !byte $3D,%00101110 + !byte $3B,%00101110 + !byte $39,%00101110 + !byte $A3,%01001110 + !byte $07,%01001110 + !byte $09,%10101111 + !byte $09,%11001111 + !byte $09,%11101111 + !byte $09,%00010000 + !byte $09,%00110000 + !byte $A1,%01010000 + !byte $07,%01010000 + !byte $A1,%01110000 + !byte $A1,%10010001; + !byte $05,%01110000 + !byte $05,%10010001; + !byte $03,%01110000 + !byte $03,%10010001; + !byte $A1,%10110001 + !byte $01,%10110001 + !byte $A1,%11010001 + !byte $A1,%10110011 + !byte $61,%01000000 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $65,%10100001 + !byte $31,%10100001 + !byte $37,%11000001 + !byte $35,%11000001 + !byte $67,%11100001 + !byte $3F,%11100001 + !byte $3D,%11100001 + !byte $3B,%11100001 + !byte $69,%00000010 + !byte $45,%00000010 + !byte $43,%00000010 + !byte $41,%00000010 + !byte $6B,%00100010 + !byte $4B,%00100010 + !byte $49,%00100010 + !byte $6B,%01000010 + !byte $51,%01000010 + !byte $4F,%01000010 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $57,%01100010 + !byte $57,%10000011; + !byte $55,%01100010 + !byte $55,%10000011; + !byte $6F,%10100011 + !byte $71,%11100011 + !byte $33,%11100011 + !byte $73,%00000100 + !byte $75,%00100100 + !byte $75,%01000100 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $79,%10100101 + !byte $7B,%11100101 + !byte $7D,%00000110 + !byte $7F,%00100110 + !byte $7F,%01000110 + !byte $81,%01100110 + !byte $81,%10000111; + !byte $83,%10100111 + !byte $35,%11000111 + !byte $85,%11100111 + !byte $2F,%11100111 + !byte $87,%00001000 + !byte $2B,%00001000 + !byte $29,%00001000 + !byte $89,%00101000 + !byte $89,%01001000 + !byte $8B,%01101000 + !byte $8B,%10001001; + !byte $8D,%10101001 + !byte $A7,%11101001 + !byte $8F,%11101001 + !byte $A7,%00001010 + !byte $91,%00001010 + !byte $A7,%00101010 + !byte $A7,%01001010 + !byte $A7,%01101010 + !byte $A7,%10001011; + !byte $A7,%10101011 + !byte $A5,%11101011 + !byte $A5,%00001100 + !byte $A5,%00101100 + !byte $A5,%01001100 + !byte $05,%01001100 + !byte $A5,%01101100 + !byte $A5,%10001101; + !byte $01,%01101100 + !byte $01,%10001101; + !byte $A5,%10101101 + !byte $A5,%11001101 + !byte $03,%11001101 + !byte $A5,%11101101 + !byte $2B,%11101101 + !byte $A5,%00001110 + !byte $05,%00101110 + !byte $A3,%01101110 + !byte $A3,%10001111; + !byte $07,%01101110 + !byte $07,%10001111; + !byte $A3,%10101111 + !byte $A3,%11001111 + !byte $A3,%11101111 + !byte $A3,%00010000 + !byte $A3,%00110000 + !byte $07,%00110000 + !byte $A3,%01010000 + !byte $05,%01010000 + !byte $A3,%01110000 + !byte $A3,%10010001; + !byte $A3,%10110001 + !byte $A1,%11110001 + !byte $A1,%00010010 + !byte $A1,%00110010 + !byte $A1,%01010010 + !byte $A1,%01110010 + !byte $A1,%10010011; + !byte $A3,%10110011 + !byte $61,%00000000 + !byte $61,%00100000 + !byte $63,%01000000 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $33,%01100000 + !byte $33,%10000001; + !byte $31,%01100000 + !byte $31,%10000001; + !byte $67,%10100001 + !byte $39,%10100001 + !byte $37,%10100001 + !byte $35,%10100001 + !byte $33,%10100001 + !byte $67,%11000001 + !byte $5D,%11000001 + !byte $3F,%11000001 + !byte $3D,%11000001 + !byte $3B,%11000001 + !byte $39,%11000001 + !byte $69,%11100001 + !byte $45,%11100001 + !byte $43,%11100001 + !byte $41,%11100001 + !byte $6B,%00000010 + !byte $5B,%00000010 + !byte $4B,%00000010 + !byte $49,%00000010 + !byte $47,%00000010 + !byte $5B,%00100010 + !byte $59,%00100010 + !byte $53,%00100010 + !byte $51,%00100010 + !byte $4F,%00100010 + !byte $4D,%00100010 + !byte $31,%00100010 + !byte $6D,%01000010 + !byte $59,%01000010 + !byte $57,%01000010 + !byte $55,%01000010 + !byte $53,%01000010 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $71,%10100011 + !byte $71,%11000011 + !byte $73,%11100011 + !byte $75,%00000100 + !byte $77,%01000100 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $7B,%10100101 + !byte $7B,%11000101 + !byte $7D,%11100101 + !byte $7F,%00000110 + !byte $81,%01000110 + !byte $83,%01100110 + !byte $83,%10000111; + !byte $35,%01100110 + !byte $35,%10000111; + !byte $85,%10100111 + !byte $35,%10100111 + !byte $85,%11000111 + !byte $33,%11000111 + !byte $31,%11000111 + !byte $2F,%11000111 + !byte $87,%11100111 + !byte $2D,%11100111 + !byte $2B,%11100111 + !byte $29,%11100111 + !byte $89,%00001000 + !byte $27,%00001000 + !byte $25,%00001000 + !byte $8B,%00101000 + !byte $8B,%01001000 + !byte $8D,%01101000 + !byte $8D,%10001001; + !byte $8F,%10101001 + !byte $A9,%11001001 + !byte $A7,%11001001 + !byte $A5,%11001001 + !byte $8F,%11001001 + !byte $A1,%11101001 + !byte $9F,%11101001 + !byte $91,%11101001 + !byte $9B,%00001010 + !byte $99,%00001010 + !byte $97,%00001010 + !byte $95,%00001010 + !byte $93,%00001010 + !byte $A7,%11001011 + !byte $A7,%11101011 + !byte $A7,%00001100 + !byte $A7,%00101100 + !byte $09,%01001100 + !byte $07,%01001100 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $11,%01101100 + !byte $11,%10001101; + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $1B,%10101101 + !byte $19,%10101101 + !byte $01,%10101101 + !byte $25,%11001101 + !byte $23,%11001101 + !byte $2F,%11101101 + !byte $2D,%11101101 + !byte $03,%11101101 + !byte $41,%00001110 + !byte $39,%00001110 + !byte $37,%00001110 + !byte $35,%00001110 + !byte $A5,%00101110 + !byte $A5,%01001110 + !byte $05,%01001110 + !byte $A5,%01101110 + !byte $A5,%10001111; + !byte $A5,%10101111 + !byte $07,%10101111 + !byte $A5,%11001111 + !byte $07,%11001111 + !byte $07,%11101111 + !byte $07,%00010000 + !byte $05,%00110000 + !byte $03,%01010000 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $A3,%11010001 + !byte $A3,%11110001 + !byte $A3,%00010010 + !byte $A3,%00110010 + !byte $A3,%01010010 + !byte $A3,%01110010 + !byte $A3,%10010011; + !byte $63,%00100000 + !byte $65,%01000000 + !byte $5F,%01000000 + !byte $31,%01000000 + !byte $2F,%01000000 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $37,%01100000 + !byte $37,%10000001; + !byte $35,%01100000 + !byte $35,%10000001; + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $5D,%10100001 + !byte $3D,%10100001 + !byte $3B,%10100001 + !byte $2F,%10100001 + !byte $69,%11000001 + !byte $43,%11000001 + !byte $41,%11000001 + !byte $6B,%11100001 + !byte $5B,%11100001 + !byte $49,%11100001 + !byte $47,%11100001 + !byte $4F,%00000010 + !byte $4D,%00000010 + !byte $6D,%00100010 + !byte $57,%00100010 + !byte $55,%00100010 + !byte $6F,%01000010 + !byte $31,%01000010 + !byte $71,%01100010 + !byte $71,%10000011; + !byte $73,%11000011 + !byte $75,%11100011 + !byte $33,%00000100 + !byte $77,%00100100 + !byte $79,%01000100 + !byte $7D,%11000101 + !byte $35,%11000101 + !byte $7F,%11100101 + !byte $35,%11100101 + !byte $81,%00100110 + !byte $83,%01000110 + !byte $35,%01000110 + !byte $33,%10100111 + !byte $31,%10100111 + !byte $87,%11000111 + !byte $2D,%11000111 + !byte $2B,%11000111 + !byte $89,%11100111 + !byte $27,%11100111 + !byte $25,%11100111 + !byte $8D,%01001000 + !byte $91,%11001001 + !byte $A9,%11101001 + !byte $93,%11101001 + !byte $A9,%00001010 + !byte $A9,%00101010 + !byte $A9,%01001010 + !byte $A9,%01101010 + !byte $A9,%10001011; + !byte $01,%00101100 + !byte $A7,%01001100 + !byte $A7,%01101100 + !byte $A7,%10001101; + !byte $A7,%10101101 + !byte $1D,%10101101 + !byte $A7,%11001101 + !byte $01,%11001101 + !byte $A7,%11101101 + !byte $01,%11101101 + !byte $A7,%00001110 + !byte $03,%00001110 + !byte $03,%00101110 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $05,%10101111 + !byte $A5,%11101111 + !byte $A5,%00010000 + !byte $05,%00010000 + !byte $A5,%00110000 + !byte $A5,%01010000 + !byte $A5,%01110000 + !byte $A5,%10010001; + !byte $A5,%10110011 + !byte $63,%00000000 + !byte $5F,%00000000 + !byte $65,%00100000 + !byte $5F,%00100000 + !byte $31,%00100000 + !byte $2F,%00100000 + !byte $5D,%01000000 + !byte $37,%01000000 + !byte $35,%01000000 + !byte $33,%01000000 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $39,%01100000 + !byte $39,%10000001; + !byte $69,%10100001 + !byte $43,%10100001 + !byte $41,%10100001 + !byte $3F,%10100001 + !byte $6B,%11000001 + !byte $5B,%11000001 + !byte $4B,%11000001 + !byte $49,%11000001 + !byte $47,%11000001 + !byte $45,%11000001 + !byte $2F,%11000001 + !byte $59,%11100001 + !byte $51,%11100001 + !byte $4F,%11100001 + !byte $4D,%11100001 + !byte $4B,%11100001 + !byte $2F,%11100001 + !byte $6D,%00000010 + !byte $59,%00000010 + !byte $57,%00000010 + !byte $55,%00000010 + !byte $53,%00000010 + !byte $51,%00000010 + !byte $6F,%00100010 + !byte $71,%01000010 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $73,%10100011 + !byte $31,%10100011 + !byte $75,%11000011 + !byte $77,%00000100 + !byte $79,%00100100 + !byte $33,%00100100 + !byte $33,%01000100 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $33,%01100100 + !byte $33,%10000101; + !byte $7D,%10100101 + !byte $7F,%11000101 + !byte $81,%00000110 + !byte $35,%00000110 + !byte $83,%00100110 + !byte $35,%00100110 + !byte $33,%01000110 + !byte $85,%01100110 + !byte $85,%10000111; + !byte $33,%01100110 + !byte $33,%10000111; + !byte $31,%01100110 + !byte $31,%10000111; + !byte $87,%10100111 + !byte $2F,%10100111 + !byte $2D,%10100111 + !byte $2B,%10100111 + !byte $89,%11000111 + !byte $29,%11000111 + !byte $27,%11000111 + !byte $25,%11000111 + !byte $23,%11100111 + !byte $8B,%00001000 + !byte $8D,%00101000 + !byte $8F,%01001000 + !byte $8F,%01101000 + !byte $8F,%10001001; + !byte $A9,%10101001 + !byte $A7,%10101001 + !byte $91,%10101001 + !byte $A3,%11001001 + !byte $A1,%11001001 + !byte $93,%11001001 + !byte $9D,%11101001 + !byte $9B,%11101001 + !byte $99,%11101001 + !byte $97,%11101001 + !byte $95,%11101001 + !byte $A9,%10101011 + !byte $A9,%11001011 + !byte $A9,%11101011 + !byte $A9,%00001100 + !byte $05,%00101100 + !byte $03,%00101100 + !byte $0D,%01001100 + !byte $0B,%01001100 + !byte $17,%01101100 + !byte $17,%10001101; + !byte $15,%01101100 + !byte $15,%10001101; + !byte $21,%10101101 + !byte $1F,%10101101 + !byte $29,%11001101 + !byte $27,%11001101 + !byte $33,%11101101 + !byte $31,%11101101 + !byte $3F,%00001110 + !byte $3D,%00001110 + !byte $3B,%00001110 + !byte $01,%00001110 + !byte $A7,%00101110 + !byte $A7,%01001110 + !byte $03,%01001110 + !byte $A7,%01101110 + !byte $A7,%10001111; + !byte $03,%01101110 + !byte $03,%10001111; + !byte $05,%11001111 + !byte $05,%11101111 + !byte $03,%11101111 + !byte $03,%00010000 + !byte $03,%00110000 + !byte $01,%00110000 + !byte $01,%01010000 + !byte $A5,%10110001 + !byte $A5,%11010001 + !byte $A5,%11110001 + !byte $A5,%01110010 + !byte $A5,%10010011; + !byte $65,%00000000 + !byte $2F,%00000000 + !byte $2D,%00000000 + !byte $5D,%00100000 + !byte $35,%00100000 + !byte $33,%00100000 + !byte $2D,%00100000 + !byte $67,%01000000 + !byte $3B,%01000000 + !byte $39,%01000000 + !byte $2D,%01000000 + !byte $69,%01100000 + !byte $69,%10000001; + !byte $41,%01100000 + !byte $41,%10000001; + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $6B,%10100001 + !byte $5B,%10100001 + !byte $49,%10100001 + !byte $47,%10100001 + !byte $45,%10100001 + !byte $4F,%11000001 + !byte $4D,%11000001 + !byte $6D,%11100001 + !byte $57,%11100001 + !byte $55,%11100001 + !byte $53,%11100001 + !byte $6F,%00000010 + !byte $2F,%00000010 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $75,%10100011 + !byte $31,%11000011 + !byte $77,%11100011 + !byte $31,%11100011 + !byte $79,%00000100 + !byte $7B,%01000100 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $7F,%10100101 + !byte $33,%10100101 + !byte $81,%11100101 + !byte $83,%00000110 + !byte $33,%00100110 + !byte $85,%01000110 + !byte $87,%01100110 + !byte $87,%10000111; + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $29,%10100111 + !byte $27,%10100111 + !byte $23,%11000111 + !byte $21,%11000111 + !byte $8B,%11100111 + !byte $8D,%00001000 + !byte $AB,%01101000 + !byte $AB,%10001001; + !byte $91,%01101000 + !byte $91,%10001001; + !byte $AB,%10101001 + !byte $A5,%10101001 + !byte $93,%10101001 + !byte $AB,%11001001 + !byte $9F,%11001001 + !byte $95,%11001001 + !byte $AB,%11101001 + !byte $AB,%00001010 + !byte $AB,%00101010 + !byte $A9,%00101100 + !byte $A9,%01001100 + !byte $A9,%01101100 + !byte $A9,%10001101; + !byte $A9,%10101101 + !byte $01,%00101110 + !byte $01,%01001110 + !byte $A7,%10101111 + !byte $03,%10101111 + !byte $A7,%11001111 + !byte $03,%11001111 + !byte $A7,%11101111 + !byte $A7,%00010000 + !byte $01,%00010000 + !byte $A7,%00110000 + !byte $A5,%00010010 + !byte $A5,%00110010 + !byte $A5,%01010010 + !byte $67,%00000000 + !byte $5D,%00000000 + !byte $37,%00000000 + !byte $35,%00000000 + !byte $33,%00000000 + !byte $31,%00000000 + !byte $67,%00100000 + !byte $3D,%00100000 + !byte $3B,%00100000 + !byte $39,%00100000 + !byte $37,%00100000 + !byte $69,%01000000 + !byte $5B,%01000000 + !byte $43,%01000000 + !byte $41,%01000000 + !byte $3F,%01000000 + !byte $3D,%01000000 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $49,%01100000 + !byte $49,%10000001; + !byte $47,%01100000 + !byte $47,%10000001; + !byte $45,%01100000 + !byte $45,%10000001; + !byte $43,%01100000 + !byte $43,%10000001; + !byte $59,%10100001 + !byte $4F,%10100001 + !byte $4D,%10100001 + !byte $4B,%10100001 + !byte $6D,%11000001 + !byte $59,%11000001 + !byte $57,%11000001 + !byte $55,%11000001 + !byte $53,%11000001 + !byte $51,%11000001 + !byte $6F,%11100001 + !byte $71,%00000010 + !byte $71,%00100010 + !byte $2F,%00100010 + !byte $73,%01000010 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $77,%11000011 + !byte $79,%11100011 + !byte $7B,%00000100 + !byte $7B,%00100100 + !byte $7D,%01000100 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $81,%11000101 + !byte $33,%11000101 + !byte $83,%11100101 + !byte $33,%11100101 + !byte $85,%00000110 + !byte $33,%00000110 + !byte $85,%00100110 + !byte $31,%00100110 + !byte $87,%01000110 + !byte $31,%01000110 + !byte $2F,%01000110 + !byte $2D,%01000110 + !byte $89,%01100110 + !byte $89,%10000111; + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $29,%01100110 + !byte $29,%10000111; + !byte $27,%01100110 + !byte $27,%10000111; + !byte $89,%10100111 + !byte $25,%10100111 + !byte $23,%10100111 + !byte $21,%10100111 + !byte $8B,%11000111 + !byte $8D,%11100111 + !byte $8F,%00001000 + !byte $8F,%00101000 + !byte $AD,%01001000 + !byte $91,%01001000 + !byte $AD,%01101000 + !byte $AD,%10001001; + !byte $A9,%01101000 + !byte $A9,%10001001; + !byte $A7,%01101000 + !byte $A7,%10001001; + !byte $93,%01101000 + !byte $93,%10001001; + !byte $A3,%10101001 + !byte $A1,%10101001 + !byte $95,%10101001 + !byte $9D,%11001001 + !byte $9B,%11001001 + !byte $99,%11001001 + !byte $97,%11001001 + !byte $AB,%01001010 + !byte $AB,%01101010 + !byte $AB,%10001011; + !byte $AB,%10101011 + !byte $AB,%11001011 + !byte $AB,%11101011 + !byte $09,%00101100 + !byte $07,%00101100 + !byte $13,%01001100 + !byte $11,%01001100 + !byte $0F,%01001100 + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $19,%01101100 + !byte $19,%10001101; + !byte $25,%10101101 + !byte $23,%10101101 + !byte $A9,%11001101 + !byte $2F,%11001101 + !byte $2D,%11001101 + !byte $2B,%11001101 + !byte $A9,%11101101 + !byte $3F,%11101101 + !byte $3D,%11101101 + !byte $39,%11101101 + !byte $37,%11101101 + !byte $35,%11101101 + !byte $A9,%00001110 + !byte $A9,%00101110 + !byte $A9,%01001110 + !byte $A9,%01101110 + !byte $A9,%10001111; + !byte $01,%01101110 + !byte $01,%10001111; + !byte $01,%10101111 + !byte $01,%11001111 + !byte $01,%11101111 + !byte $A7,%01010000 + !byte $A7,%01110000 + !byte $A7,%10010001; + !byte $A7,%10110001 + !byte $A7,%11010001 + !byte $A7,%11110001 + !byte $A7,%01110010 + !byte $A7,%10010011; + !byte $B7,%10110011 + !byte $B5,%10110011 + !byte $A7,%10110011 + !byte $3B,%00000000 + !byte $39,%00000000 + !byte $69,%00100000 + !byte $41,%00100000 + !byte $3F,%00100000 + !byte $6B,%01000000 + !byte $47,%01000000 + !byte $45,%01000000 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $6D,%10100001 + !byte $57,%10100001 + !byte $55,%10100001 + !byte $53,%10100001 + !byte $51,%10100001 + !byte $6F,%11000001 + !byte $71,%11100001 + !byte $73,%00100010 + !byte $75,%01000010 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $77,%10100011 + !byte $79,%11000011 + !byte $7B,%11100011 + !byte $7D,%00100100 + !byte $7F,%01000100 + !byte $81,%01100100 + !byte $81,%10000101; + !byte $81,%10100101 + !byte $83,%11000101 + !byte $85,%11100101 + !byte $87,%00100110 + !byte $2F,%00100110 + !byte $89,%01000110 + !byte $2B,%01000110 + !byte $8B,%01100110 + !byte $8B,%10000111; + !byte $25,%01100110 + !byte $25,%10000111; + !byte $8B,%10100111 + !byte $8D,%11000111 + !byte $8F,%11100111 + !byte $91,%00101000 + !byte $93,%01001000 + !byte $95,%01101000 + !byte $95,%10001001; + !byte $AD,%10101001 + !byte $97,%10101001 + !byte $AD,%11001001 + !byte $AD,%11101001 + !byte $AD,%00001010 + !byte $AD,%00101010 + !byte $AD,%01001010 + !byte $AD,%01101010 + !byte $AD,%10001011; + !byte $AD,%10101011 + !byte $AB,%00001100 + !byte $01,%00001100 + !byte $AB,%00101100 + !byte $AB,%01001100 + !byte $AB,%01101100 + !byte $AB,%10001101; + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $AB,%10101101 + !byte $AB,%11001101 + !byte $AB,%11101101 + !byte $3B,%11101101 + !byte $AB,%00001110 + !byte $A9,%10101111 + !byte $A9,%11001111 + !byte $A9,%11101111 + !byte $A9,%00010000 + !byte $A9,%00110000 + !byte $A9,%01010000 + !byte $A9,%01110000 + !byte $A9,%10010001; + !byte $A9,%10110001 + !byte $A7,%00010010 + !byte $A7,%00110010 + !byte $A7,%01010010 + !byte $A9,%10110011 + !byte $69,%00000000 + !byte $43,%00000000 + !byte $41,%00000000 + !byte $3F,%00000000 + !byte $3D,%00000000 + !byte $6B,%00100000 + !byte $5B,%00100000 + !byte $49,%00100000 + !byte $47,%00100000 + !byte $45,%00100000 + !byte $43,%00100000 + !byte $6D,%01000000 + !byte $4F,%01000000 + !byte $4D,%01000000 + !byte $4B,%01000000 + !byte $49,%01000000 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $59,%01100000 + !byte $59,%10000001; + !byte $57,%01100000 + !byte $57,%10000001; + !byte $55,%01100000 + !byte $55,%10000001; + !byte $53,%01100000 + !byte $53,%10000001; + !byte $51,%01100000 + !byte $51,%10000001; + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $6F,%10100001 + !byte $71,%11000001 + !byte $73,%11100001 + !byte $73,%00000010 + !byte $75,%00100010 + !byte $77,%01000010 + !byte $2F,%01000010 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $79,%10100011 + !byte $7B,%11000011 + !byte $7D,%11100011 + !byte $7D,%00000100 + !byte $31,%00000100 + !byte $7F,%00100100 + !byte $81,%01000100 + !byte $83,%01100100 + !byte $83,%10000101; + !byte $83,%10100101 + !byte $85,%11000101 + !byte $87,%11100101 + !byte $31,%11100101 + !byte $87,%00000110 + !byte $31,%00000110 + !byte $2F,%00000110 + !byte $89,%00100110 + !byte $2D,%00100110 + !byte $2B,%00100110 + !byte $8B,%01000110 + !byte $29,%01000110 + !byte $27,%01000110 + !byte $25,%01000110 + !byte $8D,%01100110 + !byte $8D,%10000111; + !byte $23,%01100110 + !byte $23,%10000111; + !byte $21,%01100110 + !byte $21,%10000111; + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $8D,%10100111 + !byte $8F,%11000111 + !byte $91,%11100111 + !byte $91,%00001000 + !byte $AF,%00101000 + !byte $93,%00101000 + !byte $AF,%01001000 + !byte $AB,%01001000 + !byte $A9,%01001000 + !byte $95,%01001000 + !byte $AF,%01101000 + !byte $AF,%10001001; + !byte $A5,%01101000 + !byte $A5,%10001001; + !byte $A3,%01101000 + !byte $A3,%10001001; + !byte $97,%01101000 + !byte $97,%10001001; + !byte $AF,%10101001 + !byte $9F,%10101001 + !byte $9D,%10101001 + !byte $9B,%10101001 + !byte $99,%10101001 + !byte $AF,%11001001 + !byte $AF,%11101001 + !byte $AD,%11001011 + !byte $AD,%11101011 + !byte $AD,%00001100 + !byte $05,%00001100 + !byte $03,%00001100 + !byte $AD,%00101100 + !byte $0F,%00101100 + !byte $0D,%00101100 + !byte $0B,%00101100 + !byte $AD,%01001100 + !byte $17,%01001100 + !byte $15,%01001100 + !byte $21,%01101100 + !byte $21,%10001101; + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $2B,%10101101 + !byte $29,%10101101 + !byte $27,%10101101 + !byte $3F,%11001101 + !byte $35,%11001101 + !byte $33,%11001101 + !byte $31,%11001101 + !byte $AB,%00101110 + !byte $AB,%01001110 + !byte $AB,%01101110 + !byte $AB,%10001111; + !byte $AB,%10101111 + !byte $AB,%11001111 + !byte $A9,%11010001 + !byte $A9,%11110001 + !byte $A9,%00010010 + !byte $A9,%00110010 + !byte $A9,%01010010 + !byte $A9,%01110010 + !byte $A9,%10010011; + !byte $AB,%10110011 + !byte $6B,%00000000 + !byte $5B,%00000000 + !byte $47,%00000000 + !byte $45,%00000000 + !byte $6D,%00100000 + !byte $4D,%00100000 + !byte $4B,%00100000 + !byte $59,%01000000 + !byte $57,%01000000 + !byte $55,%01000000 + !byte $53,%01000000 + !byte $51,%01000000 + !byte $71,%10100001 + !byte $2D,%10100001 + !byte $73,%11000001 + !byte $75,%00000010 + !byte $77,%00100010 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $7B,%10100011 + !byte $7D,%11000011 + !byte $7F,%00000100 + !byte $81,%00100100 + !byte $31,%00100100 + !byte $85,%10100101 + !byte $87,%11000101 + !byte $31,%11000101 + !byte $89,%00000110 + !byte $2D,%00000110 + !byte $8B,%00100110 + !byte $29,%00100110 + !byte $27,%00100110 + !byte $23,%01000110 + !byte $21,%01000110 + !byte $8F,%10100111 + !byte $91,%11000111 + !byte $93,%00001000 + !byte $95,%00101000 + !byte $99,%01101000 + !byte $99,%10001001; + !byte $AF,%00001010 + !byte $AF,%00101010 + !byte $AF,%01001010 + !byte $AF,%01101010 + !byte $AF,%10001011; + !byte $19,%01001100 + !byte $AD,%01101100 + !byte $AD,%10001101; + !byte $AD,%10101101 + !byte $AD,%11001101 + !byte $AD,%11101101 + !byte $AD,%00001110 + !byte $AB,%11101111 + !byte $AB,%00010000 + !byte $AB,%00110000 + !byte $AB,%01010000 + !byte $AB,%01110000 + !byte $AB,%10010001; + !byte $AB,%10110001 + !byte $6D,%00000000 + !byte $59,%00000000 + !byte $4D,%00000000 + !byte $4B,%00000000 + !byte $49,%00000000 + !byte $2B,%00000000 + !byte $59,%00100000 + !byte $57,%00100000 + !byte $55,%00100000 + !byte $53,%00100000 + !byte $51,%00100000 + !byte $4F,%00100000 + !byte $2B,%00100000 + !byte $6F,%01000000 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $73,%10100001 + !byte $2D,%11000001 + !byte $75,%11100001 + !byte $2D,%11100001 + !byte $77,%00000010 + !byte $2D,%00000010 + !byte $79,%01000010 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $7D,%10100011 + !byte $2F,%10100011 + !byte $2F,%11000011 + !byte $7F,%11100011 + !byte $81,%00000100 + !byte $83,%01000100 + !byte $31,%01000100 + !byte $85,%01100100 + !byte $85,%10000101; + !byte $31,%01100100 + !byte $31,%10000101; + !byte $87,%10100101 + !byte $31,%10100101 + !byte $2F,%11000101 + !byte $89,%11100101 + !byte $2F,%11100101 + !byte $2D,%11100101 + !byte $2B,%11100101 + !byte $8B,%00000110 + !byte $2B,%00000110 + !byte $29,%00000110 + !byte $27,%00000110 + !byte $25,%00000110 + !byte $25,%00100110 + !byte $23,%00100110 + !byte $21,%00100110 + !byte $1F,%00100110 + !byte $8D,%01000110 + !byte $1F,%01000110 + !byte $1D,%01000110 + !byte $8F,%01100110 + !byte $8F,%10000111; + !byte $91,%10100111 + !byte $93,%11100111 + !byte $B1,%00001000 + !byte $95,%00001000 + !byte $B1,%00101000 + !byte $AD,%00101000 + !byte $AB,%00101000 + !byte $B1,%01001000 + !byte $A7,%01001000 + !byte $A5,%01001000 + !byte $99,%01001000 + !byte $97,%01001000 + !byte $B1,%01101000 + !byte $B1,%10001001; + !byte $A1,%01101000 + !byte $A1,%10001001; + !byte $9F,%01101000 + !byte $9F,%10001001; + !byte $9D,%01101000 + !byte $9D,%10001001; + !byte $9B,%01101000 + !byte $9B,%10001001; + !byte $AF,%10101011 + !byte $AF,%11001011 + !byte $AF,%11101011 + !byte $AF,%00001100 + !byte $09,%00001100 + !byte $07,%00001100 + !byte $13,%00101100 + !byte $11,%00101100 + !byte $1B,%01001100 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $23,%01101100 + !byte $23,%10001101; + !byte $2F,%10101101 + !byte $2D,%10101101 + !byte $3D,%11001101 + !byte $3B,%11001101 + !byte $39,%11001101 + !byte $37,%11001101 + !byte $AD,%00101110 + !byte $AD,%01001110 + !byte $AD,%01101110 + !byte $AD,%10001111; + !byte $AD,%10101111 + !byte $AB,%11010001 + !byte $AB,%11110001 + !byte $AB,%00010010 + !byte $AB,%01010010 + !byte $AB,%01110010 + !byte $AB,%10010011; + !byte $AD,%10110011 + !byte $57,%00000000 + !byte $51,%00000000 + !byte $4F,%00000000 + !byte $6F,%00100000 + !byte $71,%01000000 + !byte $2B,%01000000 + !byte $75,%11000001 + !byte $77,%11100001 + !byte $79,%00100010 + !byte $2D,%00100010 + !byte $7B,%01000010 + !byte $7F,%11000011 + !byte $81,%11100011 + !byte $2F,%11100011 + !byte $83,%00100100 + !byte $85,%01000100 + !byte $2F,%10100101 + !byte $89,%11000101 + !byte $2D,%11000101 + !byte $8B,%11100101 + !byte $29,%11100101 + !byte $23,%00000110 + !byte $8D,%00100110 + !byte $1D,%00100110 + !byte $8F,%01000110 + !byte $93,%11000111 + !byte $95,%11100111 + !byte $AF,%00001000 + !byte $A9,%00101000 + !byte $97,%00101000 + !byte $A3,%01001000 + !byte $B1,%10101001 + !byte $B1,%11001001 + !byte $B1,%11101001 + !byte $B1,%00001010 + !byte $B1,%00101010 + !byte $AF,%00101100 + !byte $AF,%01001100 + !byte $1D,%01001100 + !byte $AF,%01101100 + !byte $AF,%10001101; + !byte $AF,%10101101 + !byte $AD,%11001111 + !byte $AD,%11101111 + !byte $AD,%00010000 + !byte $AD,%00110000 + !byte $AB,%00110010 + !byte $6F,%00000000 + !byte $55,%00000000 + !byte $53,%00000000 + !byte $71,%00100000 + !byte $73,%01000000 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $73,%01100000 + !byte $73,%10000001; + !byte $75,%10100001 + !byte $77,%11000001 + !byte $79,%11100001 + !byte $79,%00000010 + !byte $7B,%00100010 + !byte $7D,%01000010 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $7F,%10100011 + !byte $81,%11000011 + !byte $83,%11100011 + !byte $85,%00000100 + !byte $83,%00000100 + !byte $85,%00100100 + !byte $87,%01000100 + !byte $89,%01100100 + !byte $89,%10000101; + !byte $87,%01100100 + !byte $87,%10000101; + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $89,%10100101 + !byte $2D,%10100101 + !byte $8B,%11000101 + !byte $2B,%11000101 + !byte $29,%11000101 + !byte $8D,%11100101 + !byte $27,%11100101 + !byte $25,%11100101 + !byte $23,%11100101 + !byte $8F,%00000110 + !byte $8D,%00000110 + !byte $21,%00000110 + !byte $1F,%00000110 + !byte $1D,%00000110 + !byte $8F,%00100110 + !byte $91,%01000110 + !byte $93,%01100110 + !byte $93,%10000111; + !byte $91,%01100110 + !byte $91,%10000111; + !byte $93,%10100111 + !byte $95,%11000111 + !byte $B3,%11100111 + !byte $97,%11100111 + !byte $B3,%00001000 + !byte $AD,%00001000 + !byte $99,%00001000 + !byte $97,%00001000 + !byte $B3,%00101000 + !byte $A7,%00101000 + !byte $9B,%00101000 + !byte $99,%00101000 + !byte $B3,%01001000 + !byte $A1,%01001000 + !byte $9F,%01001000 + !byte $9D,%01001000 + !byte $9B,%01001000 + !byte $B3,%01101000 + !byte $B3,%10001001; + !byte $B3,%10101001 + !byte $B3,%11001001 + !byte $B3,%11101001 + !byte $B1,%01001010 + !byte $B1,%01101010 + !byte $B1,%10001011; + !byte $B1,%10101011 + !byte $B1,%11001011 + !byte $B1,%11101011 + !byte $05,%11101011 + !byte $03,%11101011 + !byte $01,%11101011 + !byte $B1,%00001100 + !byte $0F,%00001100 + !byte $0D,%00001100 + !byte $0B,%00001100 + !byte $B1,%00101100 + !byte $19,%00101100 + !byte $17,%00101100 + !byte $15,%00101100 + !byte $B1,%01001100 + !byte $21,%01001100 + !byte $1F,%01001100 + !byte $B1,%01101100 + !byte $B1,%10001101; + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $29,%01101100 + !byte $29,%10001101; + !byte $27,%01101100 + !byte $27,%10001101; + !byte $3D,%10101101 + !byte $3B,%10101101 + !byte $35,%10101101 + !byte $33,%10101101 + !byte $31,%10101101 + !byte $AF,%11001101 + !byte $AF,%11101101 + !byte $AF,%00001110 + !byte $AF,%00101110 + !byte $AF,%01001110 + !byte $AF,%01101110 + !byte $AF,%10001111; + !byte $AF,%10101111 + !byte $AF,%11001111 + !byte $AF,%11101111 + !byte $AD,%01010000 + !byte $AD,%01110000 + !byte $AD,%10010001; + !byte $AD,%10110001 + !byte $AD,%11010001 + !byte $AD,%11110001 + !byte $AD,%00010010 + !byte $AD,%00110010 + !byte $AD,%01010010 + !byte $AD,%01110010 + !byte $AD,%10010011; + !byte $AF,%10110011 + !byte $71,%00000000 + !byte $73,%00100000 + !byte $75,%01000000 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $77,%10100001 + !byte $79,%11000001 + !byte $7B,%00000010 + !byte $7D,%00100010 + !byte $7F,%01000010 + !byte $2D,%01000010 + !byte $81,%10100011 + !byte $83,%11000011 + !byte $2F,%00000100 + !byte $87,%00100100 + !byte $2F,%00100100 + !byte $89,%01000100 + !byte $2F,%01000100 + !byte $8B,%10100101 + !byte $2B,%10100101 + !byte $8D,%11000101 + !byte $27,%11000101 + !byte $25,%11000101 + !byte $21,%11100101 + !byte $1F,%11100101 + !byte $1B,%00000110 + !byte $91,%00100110 + !byte $93,%01000110 + !byte $95,%10100111 + !byte $97,%11000111 + !byte $B5,%11100111 + !byte $B1,%11100111 + !byte $B5,%00001000 + !byte $AB,%00001000 + !byte $B5,%00101000 + !byte $A5,%00101000 + !byte $9D,%00101000 + !byte $B3,%00001010 + !byte $B3,%00101010 + !byte $B3,%01001010 + !byte $B3,%01101010 + !byte $B3,%10001011; + !byte $B3,%10101011 + !byte $B1,%10101101 + !byte $B1,%11001101 + !byte $B1,%11101101 + !byte $B1,%00001110 + !byte $B1,%00101110 + !byte $AF,%00010000 + !byte $AF,%00110000 + !byte $AF,%01010000 + !byte $AF,%01110000 + !byte $AF,%10010001; + !byte $AF,%10110001 + !byte $AF,%11010001 + !byte $AF,%01110010 + !byte $AF,%10010011; + !byte $73,%00000000 + !byte $75,%00100000 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $79,%10100001 + !byte $2B,%10100001 + !byte $7B,%11000001 + !byte $7B,%11100001 + !byte $7D,%00000010 + !byte $7F,%00100010 + !byte $81,%01100010 + !byte $81,%10000011; + !byte $83,%10100011 + !byte $85,%11000011 + !byte $85,%11100011 + !byte $87,%00000100 + !byte $89,%00100100 + !byte $2D,%01000100 + !byte $8B,%01100100 + !byte $8B,%10000101; + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $8D,%10100101 + !byte $29,%10100101 + !byte $27,%10100101 + !byte $25,%10100101 + !byte $8F,%11000101 + !byte $23,%11000101 + !byte $21,%11000101 + !byte $1F,%11000101 + !byte $8F,%11100101 + !byte $1D,%11100101 + !byte $1B,%11100101 + !byte $19,%11100101 + !byte $91,%00000110 + !byte $93,%00100110 + !byte $95,%01100110 + !byte $95,%10000111; + !byte $97,%10100111 + !byte $B5,%11000111 + !byte $B3,%11000111 + !byte $99,%11000111 + !byte $AF,%11100111 + !byte $AD,%11100111 + !byte $99,%11100111 + !byte $A9,%00001000 + !byte $A7,%00001000 + !byte $9B,%00001000 + !byte $A3,%00101000 + !byte $A1,%00101000 + !byte $9F,%00101000 + !byte $B5,%01001000 + !byte $B5,%01101000 + !byte $B5,%10001001; + !byte $B5,%10101001 + !byte $B5,%11001001 + !byte $B3,%11001011 + !byte $01,%11001011 + !byte $B3,%11101011 + !byte $0B,%11101011 + !byte $09,%11101011 + !byte $07,%11101011 + !byte $B3,%00001100 + !byte $13,%00001100 + !byte $11,%00001100 + !byte $B3,%00101100 + !byte $1D,%00101100 + !byte $1B,%00101100 + !byte $B3,%01001100 + !byte $27,%01001100 + !byte $25,%01001100 + !byte $23,%01001100 + !byte $B3,%01101100 + !byte $B3,%10001101; + !byte $31,%01101100 + !byte $31,%10001101; + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $39,%10101101 + !byte $37,%10101101 + !byte $B1,%01001110 + !byte $B1,%01101110 + !byte $B1,%10001111; + !byte $B1,%10101111 + !byte $B1,%11001111 + !byte $B1,%11101111 + !byte $AF,%11110001 + !byte $AF,%00010010 + !byte $AF,%00110010 + !byte $AF,%01010010 + !byte $B1,%10110011 + !byte $29,%00000000 + !byte $29,%00100000 + !byte $77,%01000000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $2B,%11000001 + !byte $7D,%11100001 + !byte $2B,%11100001 + !byte $2B,%00000010 + !byte $81,%01000010 + !byte $83,%01100010 + !byte $83,%10000011; + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $2D,%10100011 + !byte $2D,%11000011 + !byte $87,%11100011 + !byte $2D,%11100011 + !byte $2D,%00000100 + !byte $2D,%00100100 + !byte $8B,%01000100 + !byte $2B,%01000100 + !byte $8D,%01100100 + !byte $8D,%10000101; + !byte $29,%01100100 + !byte $29,%10000101; + !byte $27,%01100100 + !byte $27,%10000101; + !byte $23,%10100101 + !byte $21,%10100101 + !byte $1D,%11000101 + !byte $1B,%11000101 + !byte $91,%11100101 + !byte $95,%01000110 + !byte $97,%01100110 + !byte $97,%10000111; + !byte $B7,%11000111 + !byte $9B,%11100111 + !byte $9D,%00001000 + !byte $B5,%11101001 + !byte $B5,%00001010 + !byte $B5,%00101010 + !byte $B5,%01001010 + !byte $B5,%01101010 + !byte $B5,%10001011; + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $B3,%10101101 + !byte $B3,%11001101 + !byte $B1,%00010000 + !byte $B1,%00110000 + !byte $B1,%01010000 + !byte $B1,%01110000 + !byte $B1,%10010001; + !byte $75,%00000000 + !byte $77,%00100000 + !byte $79,%01000000 + !byte $29,%01000000 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $7B,%10100001 + !byte $7D,%11000001 + !byte $7F,%11100001 + !byte $7F,%00000010 + !byte $81,%00100010 + !byte $83,%01000010 + !byte $85,%01100010 + !byte $85,%10000011; + !byte $85,%10100011 + !byte $87,%11000011 + !byte $89,%11100011 + !byte $89,%00000100 + !byte $8B,%00100100 + !byte $2B,%00100100 + !byte $8D,%01000100 + !byte $29,%01000100 + !byte $27,%01000100 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $23,%01100100 + !byte $23,%10000101; + !byte $21,%01100100 + !byte $21,%10000101; + !byte $8F,%10100101 + !byte $1F,%10100101 + !byte $1D,%10100101 + !byte $1B,%10100101 + !byte $91,%11000101 + !byte $19,%11000101 + !byte $17,%11000101 + !byte $93,%11100101 + !byte $93,%00000110 + !byte $95,%00100110 + !byte $97,%01000110 + !byte $B7,%10100111 + !byte $B5,%10100111 + !byte $99,%10100111 + !byte $B1,%11000111 + !byte $AF,%11000111 + !byte $9B,%11000111 + !byte $B7,%11100111 + !byte $AB,%11100111 + !byte $A9,%11100111 + !byte $9D,%11100111 + !byte $B7,%00001000 + !byte $A5,%00001000 + !byte $A3,%00001000 + !byte $A1,%00001000 + !byte $9F,%00001000 + !byte $B7,%00101000 + !byte $B7,%01001000 + !byte $B7,%01101000 + !byte $B7,%10001001; + !byte $B5,%10101011 + !byte $B5,%11001011 + !byte $05,%11001011 + !byte $03,%11001011 + !byte $B5,%11101011 + !byte $0F,%11101011 + !byte $0D,%11101011 + !byte $B5,%00001100 + !byte $17,%00001100 + !byte $15,%00001100 + !byte $21,%00101100 + !byte $1F,%00101100 + !byte $2B,%01001100 + !byte $29,%01001100 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $37,%01101100 + !byte $37,%10001101; + !byte $35,%01101100 + !byte $35,%10001101; + !byte $33,%01101100 + !byte $33,%10001101; + !byte $B3,%11101101 + !byte $B3,%00001110 + !byte $B3,%00101110 + !byte $B3,%01001110 + !byte $B3,%01101110 + !byte $B3,%10001111; + !byte $B1,%10110001 + !byte $B1,%11010001 + !byte $B1,%11110001 + !byte $B1,%00010010 + !byte $B1,%00110010 + !byte $B1,%01010010 + !byte $B1,%01110010 + !byte $B1,%10010011; + !byte $B3,%10110011 + !byte $77,%00000000 + !byte $79,%00100000 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $7D,%10100001 + !byte $7F,%11000001 + !byte $81,%00000010 + !byte $83,%00100010 + !byte $2B,%00100010 + !byte $87,%10100011 + !byte $8B,%00000100 + !byte $2B,%00000100 + !byte $8D,%00100100 + !byte $29,%00100100 + !byte $25,%01000100 + !byte $8F,%01100100 + !byte $8F,%10000101; + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $91,%10100101 + !byte $19,%10100101 + !byte $95,%00000110 + !byte $97,%00100110 + !byte $B9,%01100110 + !byte $B9,%10000111; + !byte $99,%01100110 + !byte $99,%10000111; + !byte $B9,%10100111 + !byte $B3,%10100111 + !byte $9B,%10100111 + !byte $B9,%11000111 + !byte $AD,%11000111 + !byte $9D,%11000111 + !byte $A7,%11100111 + !byte $9F,%11100111 + !byte $B7,%10101001 + !byte $B7,%11001001 + !byte $B7,%11101001 + !byte $B7,%00001010 + !byte $B7,%00101010 + !byte $B7,%01001010 + !byte $B5,%00101100 + !byte $B5,%01001100 + !byte $B5,%01101100 + !byte $B5,%10001101; + !byte $B5,%10101101 + !byte $B5,%11001101 + !byte $B3,%10101111 + !byte $B3,%11001111 + !byte $B3,%11101111 + !byte $B3,%00010000 + !byte $B3,%00110000 + !byte $B3,%01010000 + !byte $79,%00000000 + !byte $7B,%00100000 + !byte $7D,%01000000 + !byte $7B,%01000000 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $7F,%10100001 + !byte $81,%11000001 + !byte $81,%11100001 + !byte $83,%00000010 + !byte $85,%00100010 + !byte $87,%01000010 + !byte $85,%01000010 + !byte $87,%01100010 + !byte $87,%10000011; + !byte $89,%10100011 + !byte $8B,%11000011 + !byte $89,%11000011 + !byte $8B,%11100011 + !byte $2B,%11100011 + !byte $8D,%00000100 + !byte $29,%00000100 + !byte $8F,%00100100 + !byte $27,%00100100 + !byte $25,%00100100 + !byte $91,%01000100 + !byte $8F,%01000100 + !byte $23,%01000100 + !byte $21,%01000100 + !byte $1F,%01000100 + !byte $91,%01100100 + !byte $91,%10000101; + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $19,%01100100 + !byte $19,%10000101; + !byte $93,%10100101 + !byte $17,%10100101 + !byte $95,%11000101 + !byte $93,%11000101 + !byte $95,%11100101 + !byte $97,%00000110 + !byte $99,%00100110 + !byte $9B,%01000110 + !byte $99,%01000110 + !byte $BB,%01100110 + !byte $BB,%10000111; + !byte $B7,%01100110 + !byte $B7,%10000111; + !byte $9B,%01100110 + !byte $9B,%10000111; + !byte $B1,%10100111 + !byte $9D,%10100111 + !byte $AB,%11000111 + !byte $9F,%11000111 + !byte $B9,%11100111 + !byte $A5,%11100111 + !byte $A3,%11100111 + !byte $A1,%11100111 + !byte $B9,%00001000 + !byte $B9,%00101000 + !byte $B9,%01001000 + !byte $B9,%01101000 + !byte $B9,%10001001; + !byte $B9,%10101001 + !byte $B9,%11001001 + !byte $B9,%11101001 + !byte $B7,%01101010 + !byte $B7,%10001011; + !byte $B7,%10101011 + !byte $01,%10101011 + !byte $B7,%11001011 + !byte $0B,%11001011 + !byte $09,%11001011 + !byte $07,%11001011 + !byte $B7,%11101011 + !byte $13,%11101011 + !byte $11,%11101011 + !byte $B7,%00001100 + !byte $1D,%00001100 + !byte $1B,%00001100 + !byte $19,%00001100 + !byte $B7,%00101100 + !byte $27,%00101100 + !byte $25,%00101100 + !byte $23,%00101100 + !byte $B7,%01001100 + !byte $39,%01001100 + !byte $31,%01001100 + !byte $2F,%01001100 + !byte $2D,%01001100 + !byte $B7,%01101100 + !byte $B7,%10001101; + !byte $B5,%11101101 + !byte $B5,%00001110 + !byte $B5,%00101110 + !byte $B5,%01001110 + !byte $B5,%01101110 + !byte $B5,%10001111; + !byte $B5,%10101111 + !byte $B5,%11001111 + !byte $B5,%11101111 + !byte $B5,%00010000 + !byte $B3,%01110000 + !byte $B3,%10010001; + !byte $B3,%10110001 + !byte $B3,%11010001 + !byte $B3,%11110001 + !byte $B3,%00010010 + !byte $B3,%00110010 + !byte $B3,%01010010 + !byte $B3,%01110010 + !byte $B3,%10010011; + !byte $7B,%00000000 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $81,%10100001 + !byte $29,%10100001 + !byte $83,%11100001 + !byte $85,%00000010 + !byte $2B,%01000010 + !byte $89,%01100010 + !byte $89,%10000011; + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $8B,%10100011 + !byte $2B,%10100011 + !byte $2B,%11000011 + !byte $8D,%11100011 + !byte $8F,%00000100 + !byte $27,%00000100 + !byte $23,%00100100 + !byte $21,%00100100 + !byte $1D,%01000100 + !byte $1B,%01000100 + !byte $93,%01100100 + !byte $93,%10000101; + !byte $17,%01100100 + !byte $17,%10000101; + !byte $15,%01100100 + !byte $15,%10000101; + !byte $95,%10100101 + !byte $97,%11100101 + !byte $99,%00000110 + !byte $BB,%01000110 + !byte $B5,%01100110 + !byte $B5,%10000111; + !byte $9D,%01100110 + !byte $9D,%10000111; + !byte $BB,%10100111 + !byte $AF,%10100111 + !byte $9F,%10100111 + !byte $BB,%11000111 + !byte $A9,%11000111 + !byte $A3,%11000111 + !byte $A1,%11000111 + !byte $BB,%11100111 + !byte $BB,%00001000 + !byte $BB,%00101000 + !byte $B9,%00001010 + !byte $B9,%00101010 + !byte $B9,%01001010 + !byte $B9,%01101010 + !byte $B9,%10001011; + !byte $B9,%10101011 + !byte $B9,%11001011 + !byte $B7,%10101101 + !byte $B7,%11001101 + !byte $B7,%11101101 + !byte $B7,%00001110 + !byte $B7,%00101110 + !byte $B5,%00110000 + !byte $B5,%01010000 + !byte $B5,%01110000 + !byte $B5,%10010001; + !byte $B5,%10110001 + !byte $B5,%11010001 + !byte $B5,%01110010 + !byte $B5,%10010011; + !byte $7D,%00000000 + !byte $7D,%00100000 + !byte $7F,%01000000 + !byte $81,%01100000 + !byte $81,%10000001; + !byte $83,%10100001 + !byte $83,%11000001 + !byte $85,%11100001 + !byte $87,%00000010 + !byte $87,%00100010 + !byte $89,%01000010 + !byte $8B,%01100010 + !byte $8B,%10000011; + !byte $8D,%10100011 + !byte $8D,%11000011 + !byte $29,%11000011 + !byte $8F,%11100011 + !byte $29,%11100011 + !byte $27,%11100011 + !byte $91,%00000100 + !byte $25,%00000100 + !byte $23,%00000100 + !byte $21,%00000100 + !byte $91,%00100100 + !byte $1F,%00100100 + !byte $1D,%00100100 + !byte $1B,%00100100 + !byte $93,%01000100 + !byte $19,%01000100 + !byte $17,%01000100 + !byte $15,%01000100 + !byte $95,%01100100 + !byte $95,%10000101; + !byte $97,%10100101 + !byte $97,%11000101 + !byte $99,%11100101 + !byte $9B,%00000110 + !byte $BD,%00100110 + !byte $9B,%00100110 + !byte $BD,%01000110 + !byte $B9,%01000110 + !byte $B7,%01000110 + !byte $9D,%01000110 + !byte $B3,%01100110 + !byte $B3,%10000111; + !byte $B1,%01100110 + !byte $B1,%10000111; + !byte $9F,%01100110 + !byte $9F,%10000111; + !byte $AD,%10100111 + !byte $AB,%10100111 + !byte $A1,%10100111 + !byte $A7,%11000111 + !byte $A5,%11000111 + !byte $BB,%01001000 + !byte $BB,%01101000 + !byte $BB,%10001001; + !byte $BB,%10101001 + !byte $BB,%11001001 + !byte $05,%10101011 + !byte $03,%10101011 + !byte $0F,%11001011 + !byte $0D,%11001011 + !byte $B9,%11101011 + !byte $19,%11101011 + !byte $17,%11101011 + !byte $15,%11101011 + !byte $B9,%00001100 + !byte $23,%00001100 + !byte $21,%00001100 + !byte $1F,%00001100 + !byte $B9,%00101100 + !byte $2B,%00101100 + !byte $29,%00101100 + !byte $B9,%01001100 + !byte $37,%01001100 + !byte $35,%01001100 + !byte $33,%01001100 + !byte $B7,%01001110 + !byte $B7,%01101110 + !byte $B7,%10001111; + !byte $B7,%10101111 + !byte $B7,%11001111 + !byte $B7,%11101111 + !byte $B5,%11110001 + !byte $B5,%00010010 + !byte $B5,%00110010 + !byte $B5,%01010010 + !byte $27,%00000000 + !byte $7F,%00100000 + !byte $27,%00100000 + !byte $27,%01000000 + !byte $85,%11000001 + !byte $29,%11000001 + !byte $29,%11100001 + !byte $29,%00000010 + !byte $89,%00100010 + !byte $29,%00100010 + !byte $29,%01000010 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $29,%10100011 + !byte $8F,%11000011 + !byte $27,%11000011 + !byte $25,%11100011 + !byte $23,%11100011 + !byte $1F,%00000100 + !byte $1D,%00000100 + !byte $93,%00100100 + !byte $19,%00100100 + !byte $17,%00100100 + !byte $13,%01000100 + !byte $99,%11000101 + !byte $BB,%00100110 + !byte $9D,%00100110 + !byte $BD,%01100110 + !byte $BD,%10000111; + !byte $BD,%10100111 + !byte $A9,%10100111 + !byte $A5,%10100111 + !byte $A3,%10100111 + !byte $BD,%11000111 + !byte $BD,%11100111 + !byte $BB,%11101001 + !byte $BB,%00001010 + !byte $BB,%00101010 + !byte $BB,%01001010 + !byte $BB,%01101010 + !byte $BB,%10001011; + !byte $39,%00101100 + !byte $B9,%01101100 + !byte $B9,%10001101; + !byte $B9,%10101101 + !byte $B9,%11001101 + !byte $B9,%11101101 + !byte $B7,%00010000 + !byte $B7,%00110000 + !byte $B7,%01010000 + !byte $B7,%01110010 + !byte $B7,%10010011; + !byte $7F,%00000000 + !byte $81,%00100000 + !byte $81,%01000000 + !byte $83,%01100000 + !byte $83,%10000001; + !byte $85,%10100001 + !byte $87,%11000001 + !byte $87,%11100001 + !byte $89,%00000010 + !byte $8B,%00100010 + !byte $8B,%01000010 + !byte $8D,%01100010 + !byte $8D,%10000011; + !byte $8F,%10100011 + !byte $27,%10100011 + !byte $91,%11000011 + !byte $25,%11000011 + !byte $23,%11000011 + !byte $91,%11100011 + !byte $21,%11100011 + !byte $1F,%11100011 + !byte $1D,%11100011 + !byte $93,%00000100 + !byte $1B,%00000100 + !byte $19,%00000100 + !byte $17,%00000100 + !byte $95,%00100100 + !byte $15,%00100100 + !byte $13,%00100100 + !byte $11,%00100100 + !byte $95,%01000100 + !byte $97,%01100100 + !byte $97,%10000101; + !byte $99,%10100101 + !byte $9B,%11000101 + !byte $9B,%11100101 + !byte $BF,%00000110 + !byte $9D,%00000110 + !byte $BF,%00100110 + !byte $B9,%00100110 + !byte $9F,%00100110 + !byte $B5,%01000110 + !byte $B3,%01000110 + !byte $A1,%01000110 + !byte $9F,%01000110 + !byte $AF,%01100110 + !byte $AF,%10000111; + !byte $AD,%01100110 + !byte $AD,%10000111; + !byte $A3,%01100110 + !byte $A3,%10000111; + !byte $A1,%01100110 + !byte $A1,%10000111; + !byte $A7,%10100111 + !byte $BD,%00001000 + !byte $BD,%00101000 + !byte $BD,%01001000 + !byte $BD,%01101000 + !byte $BD,%10001001; + !byte $BD,%10101001 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $BB,%10101011 + !byte $09,%10101011 + !byte $07,%10101011 + !byte $BB,%11001011 + !byte $13,%11001011 + !byte $11,%11001011 + !byte $BB,%11101011 + !byte $1D,%11101011 + !byte $1B,%11101011 + !byte $BB,%00001100 + !byte $27,%00001100 + !byte $25,%00001100 + !byte $37,%00101100 + !byte $35,%00101100 + !byte $33,%00101100 + !byte $31,%00101100 + !byte $2F,%00101100 + !byte $2D,%00101100 + !byte $B9,%00001110 + !byte $B9,%00101110 + !byte $B9,%01001110 + !byte $B9,%01101110 + !byte $B9,%10001111; + !byte $B9,%10101111 + !byte $B7,%01110000 + !byte $B7,%10010001; + !byte $B7,%10110001 + !byte $B7,%11010001 + !byte $B7,%11110001 + !byte $B7,%00010010 + !byte $B7,%00110010 + !byte $B7,%01010010 + !byte $81,%00000000 + !byte $83,%01000000 + !byte $85,%01100000 + !byte $85,%10000001; + !byte $27,%01100000 + !byte $27,%10000001; + !byte $27,%10100001 + !byte $89,%11100001 + !byte $8B,%00000010 + !byte $8D,%01000010 + !byte $8F,%01100010 + !byte $8F,%10000011; + !byte $27,%01100010 + !byte $27,%10000011; + !byte $25,%10100011 + !byte $21,%11000011 + !byte $1F,%11000011 + !byte $93,%11100011 + !byte $1B,%11100011 + !byte $19,%11100011 + !byte $95,%00000100 + !byte $15,%00000100 + !byte $13,%00000100 + !byte $97,%01000100 + !byte $99,%01100100 + !byte $99,%10000101; + !byte $9D,%11100101 + !byte $BD,%00000110 + !byte $9F,%00000110 + !byte $B7,%00100110 + !byte $BF,%01000110 + !byte $B1,%01000110 + !byte $BF,%01100110 + !byte $BF,%10000111; + !byte $AB,%01100110 + !byte $AB,%10000111; + !byte $A9,%01100110 + !byte $A9,%10000111; + !byte $A7,%01100110 + !byte $A7,%10000111; + !byte $A5,%01100110 + !byte $A5,%10000111; + !byte $BF,%10100111 + !byte $BF,%11000111 + !byte $BF,%11100111 + !byte $BD,%11001001 + !byte $BD,%11101001 + !byte $BD,%00001010 + !byte $BD,%00101010 + !byte $BD,%01001010 + !byte $0B,%10101011 + !byte $BB,%00101100 + !byte $BB,%01001100 + !byte $BB,%01101100 + !byte $BB,%10001101; + !byte $BB,%10101101 + !byte $BB,%11001101 + !byte $BB,%11101101 + !byte $B9,%11001111 + !byte $B9,%11101111 + !byte $B9,%00010000 + !byte $B9,%00110000 + !byte $B9,%01010000 + !byte $B9,%01110010 + !byte $B9,%10010011; + !byte $83,%00000000 + !byte $83,%00100000 + !byte $85,%01000000 + !byte $87,%01100000 + !byte $87,%10000001; + !byte $89,%10100001 + !byte $87,%10100001 + !byte $89,%11000001 + !byte $8B,%11100001 + !byte $8D,%00000010 + !byte $8D,%00100010 + !byte $8F,%01000010 + !byte $27,%01000010 + !byte $91,%01100010 + !byte $91,%10000011; + !byte $25,%01100010 + !byte $25,%10000011; + !byte $93,%10100011 + !byte $91,%10100011 + !byte $23,%10100011 + !byte $21,%10100011 + !byte $1F,%10100011 + !byte $93,%11000011 + !byte $1D,%11000011 + !byte $1B,%11000011 + !byte $19,%11000011 + !byte $95,%11100011 + !byte $17,%11100011 + !byte $15,%11100011 + !byte $13,%11100011 + !byte $97,%00000100 + !byte $11,%00000100 + !byte $99,%00100100 + !byte $97,%00100100 + !byte $99,%01000100 + !byte $9B,%01100100 + !byte $9B,%10000101; + !byte $9D,%10100101 + !byte $9B,%10100101 + !byte $9D,%11000101 + !byte $BF,%11100101 + !byte $9F,%11100101 + !byte $BB,%00000110 + !byte $A1,%00000110 + !byte $B5,%00100110 + !byte $A3,%00100110 + !byte $A1,%00100110 + !byte $AF,%01000110 + !byte $A5,%01000110 + !byte $A3,%01000110 + !byte $BF,%00001000 + !byte $BF,%00101000 + !byte $BF,%01001000 + !byte $BF,%01101000 + !byte $BF,%10001001; + !byte $BF,%10101001 + !byte $BF,%11001001 + !byte $BF,%11101001 + !byte $BF,%00001010 + !byte $BD,%01101010 + !byte $BD,%10001011; + !byte $05,%01101010 + !byte $05,%10001011; + !byte $03,%01101010 + !byte $03,%10001011; + !byte $BD,%10101011 + !byte $0F,%10101011 + !byte $0D,%10101011 + !byte $BD,%11001011 + !byte $19,%11001011 + !byte $17,%11001011 + !byte $15,%11001011 + !byte $BD,%11101011 + !byte $23,%11101011 + !byte $21,%11101011 + !byte $1F,%11101011 + !byte $BD,%00001100 + !byte $37,%00001100 + !byte $2B,%00001100 + !byte $29,%00001100 + !byte $BD,%00101100 + !byte $BD,%01001100 + !byte $BD,%01101100 + !byte $BD,%10001101; + !byte $BB,%00001110 + !byte $BB,%00101110 + !byte $BB,%01001110 + !byte $BB,%01101110 + !byte $BB,%10001111; + !byte $BB,%10101111 + !byte $BB,%11001111 + !byte $BB,%11101111 + !byte $BB,%00010000 + !byte $B9,%01110000 + !byte $B9,%10010001; + !byte $B9,%10110001 + !byte $B9,%11010001 + !byte $B9,%11110001 + !byte $B9,%00010010 + !byte $B9,%00110010 + !byte $B9,%01010010 + !byte $BB,%01110010 + !byte $BB,%10010011; + !byte $85,%00100000 + !byte $87,%01000000 + !byte $89,%01100000 + !byte $89,%10000001; + !byte $8B,%11000001 + !byte $27,%11000001 + !byte $8D,%11100001 + !byte $27,%11100001 + !byte $27,%00000010 + !byte $8F,%00100010 + !byte $27,%00100010 + !byte $91,%01000010 + !byte $25,%01000010 + !byte $93,%01100010 + !byte $93,%10000011; + !byte $23,%01100010 + !byte $23,%10000011; + !byte $1D,%10100011 + !byte $95,%11000011 + !byte $17,%11000011 + !byte $97,%11100011 + !byte $11,%11100011 + !byte $9B,%01000100 + !byte $9F,%11000101 + !byte $A1,%11100101 + !byte $B9,%00000110 + !byte $B3,%00100110 + !byte $AD,%01000110 + !byte $AB,%01000110 + !byte $A9,%01000110 + !byte $A7,%01000110 + !byte $BF,%00101010 + !byte $BF,%01001010 + !byte $BF,%01101010 + !byte $BF,%10001011; + !byte $07,%01101010 + !byte $07,%10001011; + !byte $BF,%10101011 + !byte $BF,%11001011 + !byte $35,%00001100 + !byte $2D,%00001100 + !byte $BD,%10101101 + !byte $BD,%11001101 + !byte $BD,%11101101 + !byte $BD,%00001110 + !byte $BD,%00101110 + !byte $BB,%00110000 + !byte $BB,%01010000 + !byte $BB,%01110000 + !byte $BB,%10010001; + !byte $BB,%10110001 + !byte $BB,%11010001 + !byte $BB,%01010010 + !byte $85,%00000000 + !byte $25,%00000000 + !byte $87,%00100000 + !byte $89,%01000000 + !byte $8B,%10100001 + !byte $8D,%11000001 + !byte $8F,%11100001 + !byte $8F,%00000010 + !byte $91,%00100010 + !byte $25,%00100010 + !byte $93,%01000010 + !byte $23,%01000010 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $95,%10100011 + !byte $1B,%10100011 + !byte $19,%10100011 + !byte $17,%10100011 + !byte $97,%11000011 + !byte $15,%11000011 + !byte $13,%11000011 + !byte $11,%11000011 + !byte $99,%11100011 + !byte $0F,%11100011 + !byte $99,%00000100 + !byte $9B,%00100100 + !byte $9D,%01000100 + !byte $9D,%01100100 + !byte $9D,%10000101; + !byte $9F,%10100101 + !byte $A1,%11000101 + !byte $BD,%11100101 + !byte $BB,%11100101 + !byte $A3,%11100101 + !byte $B7,%00000110 + !byte $B5,%00000110 + !byte $A3,%00000110 + !byte $B1,%00100110 + !byte $AF,%00100110 + !byte $A7,%00100110 + !byte $A5,%00100110 + !byte $01,%01001010 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $09,%01101010 + !byte $09,%10001011; + !byte $13,%10101011 + !byte $11,%10101011 + !byte $1F,%11001011 + !byte $1D,%11001011 + !byte $1B,%11001011 + !byte $BF,%11101011 + !byte $27,%11101011 + !byte $25,%11101011 + !byte $BF,%00001100 + !byte $33,%00001100 + !byte $31,%00001100 + !byte $2F,%00001100 + !byte $BF,%00101100 + !byte $BF,%01001100 + !byte $BD,%01001110 + !byte $BD,%01101110 + !byte $BD,%10001111; + !byte $BD,%10101111 + !byte $BD,%11001111 + !byte $BD,%11101111 + !byte $BB,%11110001 + !byte $BB,%00010010 + !byte $BB,%00110010 + !byte $BD,%01110010 + !byte $BD,%10010011; + !byte $87,%00000000 + !byte $25,%00100000 + !byte $25,%01000000 + !byte $8B,%01100000 + !byte $8B,%10000001; + !byte $25,%01100000 + !byte $25,%10000001; + !byte $8D,%10100001 + !byte $25,%11000001 + !byte $25,%11100001 + !byte $91,%00000010 + !byte $25,%00000010 + !byte $23,%00100010 + !byte $21,%01000010 + !byte $1F,%01000010 + !byte $95,%01100010 + !byte $95,%10000011; + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $19,%01100010 + !byte $19,%10000011; + !byte $15,%10100011 + !byte $13,%10100011 + !byte $0F,%11000011 + !byte $0D,%11000011 + !byte $9B,%00000100 + !byte $9F,%01100100 + !byte $9F,%10000101; + !byte $A1,%10100101 + !byte $B9,%11100101 + !byte $A5,%00000110 + !byte $AD,%00100110 + !byte $AB,%00100110 + !byte $A9,%00100110 + !byte $15,%10101011 + !byte $BF,%01101100 + !byte $BF,%10001101; + !byte $BF,%10101101 + !byte $BF,%11001101 + !byte $BF,%11101101 + !byte $BF,%00001110 + !byte $BD,%00010000 + !byte $BD,%00110000 + !byte $BD,%01010000 + !byte $BD,%01110000 + !byte $BD,%10010001; + !byte $BD,%10110001 + !byte $89,%00000000 + !byte $89,%00100000 + !byte $8B,%01000000 + !byte $8D,%01100000 + !byte $8D,%10000001; + !byte $25,%10100001 + !byte $8F,%11000001 + !byte $91,%11100001 + !byte $93,%00000010 + !byte $23,%00000010 + !byte $93,%00100010 + !byte $21,%00100010 + !byte $1F,%00100010 + !byte $95,%01000010 + !byte $1D,%01000010 + !byte $1B,%01000010 + !byte $19,%01000010 + !byte $97,%01100010 + !byte $97,%10000011; + !byte $17,%01100010 + !byte $17,%10000011; + !byte $15,%01100010 + !byte $15,%10000011; + !byte $13,%01100010 + !byte $13,%10000011; + !byte $97,%10100011 + !byte $11,%10100011 + !byte $0F,%10100011 + !byte $0D,%10100011 + !byte $99,%11000011 + !byte $9B,%11100011 + !byte $9D,%00000100 + !byte $9D,%00100100 + !byte $9F,%01000100 + !byte $A1,%01100100 + !byte $A1,%10000101; + !byte $A3,%10100101 + !byte $BF,%11000101 + !byte $BD,%11000101 + !byte $A3,%11000101 + !byte $B7,%11100101 + !byte $A5,%11100101 + !byte $B3,%00000110 + !byte $B1,%00000110 + !byte $AF,%00000110 + !byte $A9,%00000110 + !byte $A7,%00000110 + !byte $05,%01001010 + !byte $03,%01001010 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $19,%10101011 + !byte $17,%10101011 + !byte $23,%11001011 + !byte $21,%11001011 + !byte $35,%11101011 + !byte $33,%11101011 + !byte $2B,%11101011 + !byte $29,%11101011 + !byte $BF,%00101110 + !byte $BF,%01001110 + !byte $BF,%01101110 + !byte $BF,%10001111; + !byte $BF,%10101111 + !byte $BD,%11010001 + !byte $BD,%11110001 + !byte $BD,%00010010 + !byte $BD,%00110010 + !byte $BD,%01010010 + !byte $BF,%01110010 + !byte $BF,%10010011; + !byte $8B,%00100000 + !byte $8D,%01000000 + !byte $8F,%10100001 + !byte $91,%11000001 + !byte $23,%11100001 + !byte $21,%00000010 + !byte $95,%00100010 + !byte $1D,%00100010 + !byte $1B,%00100010 + !byte $97,%01000010 + !byte $17,%01000010 + !byte $15,%01000010 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $99,%10100011 + !byte $0B,%10100011 + !byte $9B,%11000011 + !byte $9F,%00100100 + !byte $A1,%01000100 + !byte $BB,%11000101 + !byte $A5,%11000101 + !byte $B5,%11100101 + !byte $A7,%11100101 + !byte $AD,%00000110 + !byte $AB,%00000110 + !byte $31,%11101011 + !byte $2D,%11101011 + !byte $BF,%11001111 + !byte $BF,%11101111 + !byte $BF,%00010000 + !byte $BF,%00110000 + !byte $BF,%01010000 + !byte $8B,%00000000 + !byte $8D,%00100000 + !byte $8F,%01000000 + !byte $91,%01100000 + !byte $91,%10000001; + !byte $8F,%01100000 + !byte $8F,%10000001; + !byte $91,%10100001 + !byte $23,%10100001 + !byte $93,%11000001 + !byte $23,%11000001 + !byte $95,%11100001 + !byte $93,%11100001 + !byte $21,%11100001 + !byte $95,%00000010 + !byte $1F,%00000010 + !byte $1D,%00000010 + !byte $1B,%00000010 + !byte $97,%00100010 + !byte $19,%00100010 + !byte $17,%00100010 + !byte $15,%00100010 + !byte $99,%01000010 + !byte $13,%01000010 + !byte $11,%01000010 + !byte $0F,%01000010 + !byte $9B,%01100010 + !byte $9B,%10000011; + !byte $99,%01100010 + !byte $99,%10000011; + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $9B,%10100011 + !byte $9D,%11000011 + !byte $9F,%11100011 + !byte $9D,%11100011 + !byte $9F,%00000100 + !byte $A1,%00100100 + !byte $A3,%01000100 + !byte $A5,%01100100 + !byte $A5,%10000101; + !byte $A3,%01100100 + !byte $A3,%10000101; + !byte $BF,%10100101 + !byte $A5,%10100101 + !byte $B9,%11000101 + !byte $A7,%11000101 + !byte $B3,%11100101 + !byte $B1,%11100101 + !byte $AF,%11100101 + !byte $AD,%11100101 + !byte $AB,%11100101 + !byte $A9,%11100101 + !byte $01,%00101010 + !byte $0B,%01001010 + !byte $09,%01001010 + !byte $07,%01001010 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $13,%01101010 + !byte $13,%10001011; + !byte $11,%01101010 + !byte $11,%10001011; + !byte $1F,%10101011 + !byte $1D,%10101011 + !byte $1B,%10101011 + !byte $35,%11001011 + !byte $27,%11001011 + !byte $25,%11001011 + !byte $2F,%11101011 + !byte $BF,%01110000 + !byte $BF,%10010001; + !byte $BF,%10110001 + !byte $BF,%11010001 + !byte $BF,%11110001 + !byte $BF,%00010010 + !byte $BF,%00110010 + !byte $BF,%01010010 + !byte $8D,%00000000 + !byte $23,%00000000 + !byte $8F,%00100000 + !byte $23,%00100000 + !byte $23,%01000000 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $93,%10100001 + !byte $95,%11000001 + !byte $21,%11000001 + !byte $1F,%11100001 + !byte $1D,%11100001 + !byte $97,%00000010 + !byte $19,%00000010 + !byte $17,%00000010 + !byte $99,%00100010 + !byte $13,%00100010 + !byte $11,%00100010 + !byte $0D,%01000010 + !byte $9D,%10100011 + !byte $9F,%11000011 + !byte $A1,%00000100 + !byte $A3,%00100100 + !byte $BD,%10100101 + !byte $A7,%10100101 + !byte $B7,%11000101 + !byte $A9,%11000101 + !byte $33,%11001011 + !byte $8F,%00000000 + !byte $91,%01000000 + !byte $93,%01100000 + !byte $93,%10000001; + !byte $21,%01100000 + !byte $21,%10000001; + !byte $95,%10100001 + !byte $21,%10100001 + !byte $1F,%11000001 + !byte $1D,%11000001 + !byte $97,%11100001 + !byte $1B,%11100001 + !byte $19,%11100001 + !byte $17,%11100001 + !byte $99,%00000010 + !byte $15,%00000010 + !byte $13,%00000010 + !byte $11,%00000010 + !byte $0F,%00100010 + !byte $0D,%00100010 + !byte $0B,%00100010 + !byte $9B,%01000010 + !byte $0B,%01000010 + !byte $09,%01000010 + !byte $9D,%01100010 + !byte $9D,%10000011; + !byte $9F,%10100011 + !byte $A1,%11100011 + !byte $A3,%00000100 + !byte $A5,%01000100 + !byte $BF,%01100100 + !byte $BF,%10000101; + !byte $A7,%01100100 + !byte $A7,%10000101; + !byte $BB,%10100101 + !byte $B9,%10100101 + !byte $A9,%10100101 + !byte $B5,%11000101 + !byte $B3,%11000101 + !byte $B1,%11000101 + !byte $AF,%11000101 + !byte $AD,%11000101 + !byte $AB,%11000101 + !byte $05,%00101010 + !byte $03,%00101010 + !byte $0F,%01001010 + !byte $0D,%01001010 + !byte $19,%01101010 + !byte $19,%10001011; + !byte $17,%01101010 + !byte $17,%10001011; + !byte $23,%10101011 + !byte $21,%10101011 + !byte $31,%11001011 + !byte $2F,%11001011 + !byte $2D,%11001011 + !byte $2B,%11001011 + !byte $29,%11001011 + !byte $91,%00100000 + !byte $93,%01000000 + !byte $21,%01000000 + !byte $1F,%10100001 + !byte $97,%11000001 + !byte $1B,%11000001 + !byte $19,%11000001 + !byte $99,%11100001 + !byte $15,%11100001 + !byte $13,%11100001 + !byte $0F,%00000010 + !byte $0D,%00000010 + !byte $9B,%00100010 + !byte $09,%00100010 + !byte $9D,%01000010 + !byte $A1,%11000011 + !byte $A3,%11100011 + !byte $A5,%00100100 + !byte $A7,%01000100 + !byte $A9,%01100100 + !byte $A9,%10000101; + !byte $AB,%10100101 + !byte $07,%00101010 + !byte $33,%10101011 + !byte $91,%00000000 + !byte $21,%00000000 + !byte $93,%00100000 + !byte $21,%00100000 + !byte $95,%01000000 + !byte $95,%01100000 + !byte $95,%10000001; + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $97,%10100001 + !byte $1D,%10100001 + !byte $1B,%10100001 + !byte $19,%10100001 + !byte $99,%11000001 + !byte $17,%11000001 + !byte $15,%11000001 + !byte $13,%11000001 + !byte $11,%11100001 + !byte $0F,%11100001 + !byte $0D,%11100001 + !byte $9B,%00000010 + !byte $0B,%00000010 + !byte $09,%00000010 + !byte $07,%00000010 + !byte $9D,%00100010 + !byte $9F,%01000010 + !byte $9F,%01100010 + !byte $9F,%10000011; + !byte $A1,%10100011 + !byte $A3,%11000011 + !byte $A5,%11100011 + !byte $A5,%00000100 + !byte $A7,%00100100 + !byte $A9,%01000100 + !byte $BD,%01100100 + !byte $BD,%10000101; + !byte $BB,%01100100 + !byte $BB,%10000101; + !byte $AB,%01100100 + !byte $AB,%10000101; + !byte $B7,%10100101 + !byte $B5,%10100101 + !byte $B3,%10100101 + !byte $B1,%10100101 + !byte $AF,%10100101 + !byte $AD,%10100101 + !byte $01,%00001010 + !byte $0B,%00101010 + !byte $09,%00101010 + !byte $15,%01001010 + !byte $13,%01001010 + !byte $11,%01001010 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $31,%10101011 + !byte $27,%10101011 + !byte $25,%10101011 + !byte $93,%00000000 + !byte $95,%00100000 + !byte $97,%01000000 + !byte $1F,%01000000 + !byte $97,%01100000 + !byte $97,%10000001; + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $99,%10100001 + !byte $17,%10100001 + !byte $9B,%11000001 + !byte $11,%11000001 + !byte $9B,%11100001 + !byte $0B,%11100001 + !byte $9D,%00000010 + !byte $9F,%00100010 + !byte $A1,%01000010 + !byte $A1,%01100010 + !byte $A1,%10000011; + !byte $A3,%10100011 + !byte $A5,%11000011 + !byte $A7,%00000100 + !byte $A9,%00100100 + !byte $AB,%01000100 + !byte $AD,%01100100 + !byte $AD,%10000101; + !byte $03,%00001010 + !byte $2F,%10101011 + !byte $29,%10101011 + !byte $95,%00000000 + !byte $1F,%00000000 + !byte $97,%00100000 + !byte $1F,%00100000 + !byte $1D,%01000000 + !byte $1B,%01000000 + !byte $99,%01100000 + !byte $99,%10000001; + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $19,%01100000 + !byte $19,%10000001; + !byte $17,%01100000 + !byte $17,%10000001; + !byte $9B,%10100001 + !byte $15,%10100001 + !byte $13,%10100001 + !byte $11,%10100001 + !byte $9D,%11000001 + !byte $0F,%11000001 + !byte $0D,%11000001 + !byte $0B,%11000001 + !byte $9D,%11100001 + !byte $09,%11100001 + !byte $07,%11100001 + !byte $05,%11100001 + !byte $9F,%00000010 + !byte $A1,%00100010 + !byte $A3,%01100010 + !byte $A3,%10000011; + !byte $A5,%10100011 + !byte $A7,%11000011 + !byte $A7,%11100011 + !byte $A9,%00000100 + !byte $AB,%00100100 + !byte $BF,%01000100 + !byte $BD,%01000100 + !byte $AD,%01000100 + !byte $B9,%01100100 + !byte $B9,%10000101; + !byte $B7,%01100100 + !byte $B7,%10000101; + !byte $B5,%01100100 + !byte $B5,%10000101; + !byte $B3,%01100100 + !byte $B3,%10000101; + !byte $B1,%01100100 + !byte $B1,%10000101; + !byte $AF,%01100100 + !byte $AF,%10000101; + !byte $07,%00001010 + !byte $05,%00001010 + !byte $11,%00101010 + !byte $0F,%00101010 + !byte $0D,%00101010 + !byte $1B,%01001010 + !byte $19,%01001010 + !byte $17,%01001010 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $21,%01101010 + !byte $21,%10001011; + !byte $2D,%10101011 + !byte $2B,%10101011 + !byte $97,%00000000 + !byte $1D,%00100000 + !byte $99,%01000000 + !byte $19,%01000000 + !byte $9B,%01100000 + !byte $9B,%10000001; + !byte $15,%01100000 + !byte $15,%10000001; + !byte $13,%01100000 + !byte $13,%10000001; + !byte $0F,%10100001 + !byte $0D,%10100001 + !byte $09,%11000001 + !byte $07,%11000001 + !byte $9F,%11100001 + !byte $A1,%00000010 + !byte $A3,%01000010 + !byte $A5,%01100010 + !byte $A5,%10000011; + !byte $A7,%10100011 + !byte $A9,%11100011 + !byte $AB,%00000100 + !byte $AD,%00100100 + !byte $BB,%01000100 + !byte $AF,%01000100 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $1D,%00000000 + !byte $1B,%00000000 + !byte $99,%00100000 + !byte $1B,%00100000 + !byte $19,%00100000 + !byte $9B,%01000000 + !byte $17,%01000000 + !byte $15,%01000000 + !byte $13,%01000000 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $9D,%10100001 + !byte $0B,%10100001 + !byte $09,%10100001 + !byte $07,%10100001 + !byte $9F,%11000001 + !byte $05,%11000001 + !byte $03,%11000001 + !byte $A1,%11100001 + !byte $A3,%00100010 + !byte $A5,%01000010 + !byte $A7,%01100010 + !byte $A7,%10000011; + !byte $A9,%11000011 + !byte $AB,%11100011 + !byte $BF,%00100100 + !byte $BD,%00100100 + !byte $AF,%00100100 + !byte $B9,%01000100 + !byte $B7,%01000100 + !byte $B5,%01000100 + !byte $B3,%01000100 + !byte $B1,%01000100 + !byte $01,%11101001 + !byte $0B,%00001010 + !byte $09,%00001010 + !byte $15,%00101010 + !byte $13,%00101010 + !byte $1F,%01001010 + !byte $1D,%01001010 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $29,%01101010 + !byte $29,%10001011; + !byte $27,%01101010 + !byte $27,%10001011; + !byte $25,%01101010 + !byte $25,%10001011; + !byte $99,%00000000 + !byte $9B,%00100000 + !byte $17,%00100000 + !byte $15,%00100000 + !byte $11,%01000000 + !byte $0F,%01000000 + !byte $9D,%01100000 + !byte $9D,%10000001; + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $09,%01100000 + !byte $09,%10000001; + !byte $9F,%10100001 + !byte $05,%10100001 + !byte $03,%10100001 + !byte $A3,%00000010 + !byte $A5,%00100010 + !byte $A9,%10100011 + !byte $AB,%11000011 + !byte $AD,%00000100 + !byte $B1,%00100100 + !byte $9B,%00000000 + !byte $19,%00000000 + !byte $17,%00000000 + !byte $15,%00000000 + !byte $9D,%00100000 + !byte $13,%00100000 + !byte $11,%00100000 + !byte $0F,%00100000 + !byte $9D,%01000000 + !byte $0D,%01000000 + !byte $0B,%01000000 + !byte $09,%01000000 + !byte $9F,%01100000 + !byte $9F,%10000001; + !byte $07,%01100000 + !byte $07,%10000001; + !byte $05,%01100000 + !byte $05,%10000001; + !byte $03,%01100000 + !byte $03,%10000001; + !byte $A1,%10100001 + !byte $A1,%11000001 + !byte $A3,%11100001 + !byte $A5,%00000010 + !byte $A7,%00100010 + !byte $A7,%01000010 + !byte $A9,%01100010 + !byte $A9,%10000011; + !byte $AB,%10100011 + !byte $AD,%11100011 + !byte $BF,%00000100 + !byte $AF,%00000100 + !byte $BB,%00100100 + !byte $B9,%00100100 + !byte $B7,%00100100 + !byte $B5,%00100100 + !byte $B3,%00100100 + !byte $07,%11101001 + !byte $05,%11101001 + !byte $03,%11101001 + !byte $11,%00001010 + !byte $0F,%00001010 + !byte $0D,%00001010 + !byte $19,%00101010 + !byte $17,%00101010 + !byte $2F,%01001010 + !byte $23,%01001010 + !byte $21,%01001010 + !byte $9D,%00000000 + !byte $13,%00000000 + !byte $0D,%00100000 + !byte $9F,%01000000 + !byte $07,%01000000 + !byte $A1,%01100000 + !byte $A1,%10000001; + !byte $01,%01100000 + !byte $01,%10000001; + !byte $A3,%10100001 + !byte $A3,%11000001 + !byte $A5,%11100001 + !byte $A7,%00000010 + !byte $A9,%01000010 + !byte $AB,%01100010 + !byte $AB,%10000011; + !byte $AD,%10100011 + !byte $AD,%11000011 + !byte $AF,%11100011 + !byte $B3,%00000100 + !byte $B1,%00000100 + !byte $1B,%00101010 + !byte $2D,%01001010 + !byte $25,%01001010 + !byte $9F,%00000000 + !byte $11,%00000000 + !byte $0F,%00000000 + !byte $0D,%00000000 + !byte $0B,%00000000 + !byte $9F,%00100000 + !byte $0B,%00100000 + !byte $09,%00100000 + !byte $07,%00100000 + !byte $A1,%01000000 + !byte $05,%01000000 + !byte $03,%01000000 + !byte $01,%01000000 + !byte $A3,%01100000 + !byte $A3,%10000001; + !byte $A5,%10100001 + !byte $A5,%11000001 + !byte $A7,%11100001 + !byte $A9,%00000010 + !byte $A9,%00100010 + !byte $AB,%01000010 + !byte $AD,%01100010 + !byte $AD,%10000011; + !byte $AF,%10100011 + !byte $AF,%11000011 + !byte $B3,%11100011 + !byte $B1,%11100011 + !byte $BD,%00000100 + !byte $BB,%00000100 + !byte $B9,%00000100 + !byte $B7,%00000100 + !byte $B5,%00000100 + !byte $03,%11001001 + !byte $01,%11001001 + !byte $0D,%11101001 + !byte $0B,%11101001 + !byte $09,%11101001 + !byte $15,%00001010 + !byte $13,%00001010 + !byte $2F,%00101010 + !byte $1F,%00101010 + !byte $1D,%00101010 + !byte $2B,%01001010 + !byte $29,%01001010 + !byte $27,%01001010 + !byte $09,%00000000 + !byte $A1,%00100000 + !byte $05,%00100000 + !byte $03,%00100000 + !byte $A3,%01000000 + !byte $A7,%11000001 + !byte $A9,%11100001 + !byte $AB,%00100010 + !byte $AD,%01000010 + !byte $B1,%11000011 + !byte $BF,%11100011 + !byte $B5,%11100011 + !byte $A1,%00000000 + !byte $07,%00000000 + !byte $05,%00000000 + !byte $03,%00000000 + !byte $01,%00000000 + !byte $A3,%00100000 + !byte $01,%00100000 + !byte $A5,%01100000 + !byte $A5,%10000001; + !byte $A7,%10100001 + !byte $A9,%11000001 + !byte $AB,%00000010 + !byte $AD,%00100010 + !byte $AF,%01100010 + !byte $AF,%10000011; + !byte $B1,%10100011 + !byte $B3,%11000011 + !byte $BD,%11100011 + !byte $BB,%11100011 + !byte $B9,%11100011 + !byte $B7,%11100011 + !byte $07,%11001001 + !byte $05,%11001001 + !byte $11,%11101001 + !byte $0F,%11101001 + !byte $19,%00001010 + !byte $17,%00001010 + !byte $2D,%00101010 + !byte $2B,%00101010 + !byte $23,%00101010 + !byte $21,%00101010 + !byte $A3,%00000000 + !byte $A5,%01000000 + !byte $A7,%01100000 + !byte $A7,%10000001; + !byte $AB,%11100001 + !byte $AD,%00000010 + !byte $AF,%01000010 + !byte $B1,%01100010 + !byte $B1,%10000011; + !byte $B3,%10100011 + !byte $B7,%11000011 + !byte $B5,%11000011 + !byte $1B,%00001010 + !byte $29,%00101010 + !byte $A5,%00000000 + !byte $A5,%00100000 + !byte $A7,%01000000 + !byte $A9,%01100000 + !byte $A9,%10000001; + !byte $A9,%10100001 + !byte $AB,%11000001 + !byte $AD,%11100001 + !byte $AF,%00000010 + !byte $AF,%00100010 + !byte $B1,%01000010 + !byte $B3,%01100010 + !byte $B3,%10000011; + !byte $B5,%10100011 + !byte $BF,%11000011 + !byte $BD,%11000011 + !byte $BB,%11000011 + !byte $B9,%11000011 + !byte $03,%10101001 + !byte $01,%10101001 + !byte $0D,%11001001 + !byte $0B,%11001001 + !byte $09,%11001001 + !byte $15,%11101001 + !byte $13,%11101001 + !byte $2D,%00001010 + !byte $1F,%00001010 + !byte $1D,%00001010 + !byte $27,%00101010 + !byte $25,%00101010 + !byte $A7,%00100000 + !byte $A9,%01000000 + !byte $AB,%01100000 + !byte $AB,%10000001; + !byte $AB,%10100001 + !byte $AD,%11000001 + !byte $AF,%11100001 + !byte $B1,%00100010 + !byte $B3,%01000010 + !byte $B5,%01100010 + !byte $B5,%10000011; + !byte $B9,%10100011 + !byte $B7,%10100011 + !byte $17,%11101001 + !byte $2B,%00001010 + !byte $A7,%00000000 + !byte $A9,%00100000 + !byte $AB,%01000000 + !byte $AD,%10100001 + !byte $AF,%11000001 + !byte $B1,%11100001 + !byte $B1,%00000010 + !byte $B3,%00100010 + !byte $B5,%01000010 + !byte $B9,%01100010 + !byte $B9,%10000011; + !byte $B7,%01100010 + !byte $B7,%10000011; + !byte $BF,%10100011 + !byte $BD,%10100011 + !byte $BB,%10100011 + !byte $07,%10101001 + !byte $05,%10101001 + !byte $11,%11001001 + !byte $0F,%11001001 + !byte $1B,%11101001 + !byte $19,%11101001 + !byte $29,%00001010 + !byte $27,%00001010 + !byte $25,%00001010 + !byte $23,%00001010 + !byte $21,%00001010 + !byte $A9,%00000000 + !byte $AB,%00100000 + !byte $AD,%01100000 + !byte $AD,%10000001; + !byte $AF,%10100001 + !byte $B3,%00000010 + !byte $B5,%00100010 + !byte $B7,%01000010 + !byte $BB,%01100010 + !byte $BB,%10000011; + !byte $AB,%00000000 + !byte $AD,%01000000 + !byte $AF,%01100000 + !byte $AF,%10000001; + !byte $B1,%11000001 + !byte $B3,%11100001 + !byte $B5,%00000010 + !byte $B7,%00100010 + !byte $B9,%01000010 + !byte $BF,%01100010 + !byte $BF,%10000011; + !byte $BD,%01100010 + !byte $BD,%10000011; + !byte $03,%01101000 + !byte $03,%10001001; + !byte $01,%01101000 + !byte $01,%10001001; + !byte $0D,%10101001 + !byte $0B,%10101001 + !byte $09,%10101001 + !byte $15,%11001001 + !byte $13,%11001001 + !byte $2B,%11101001 + !byte $29,%11101001 + !byte $1F,%11101001 + !byte $1D,%11101001 + !byte $AD,%00100000 + !byte $AF,%01000000 + !byte $B1,%10100001 + !byte $B3,%11000001 + !byte $BB,%01000010 + !byte $17,%11001001 + !byte $27,%11101001 + !byte $AD,%00000000 + !byte $AF,%00100000 + !byte $B1,%01000000 + !byte $B1,%01100000 + !byte $B1,%10000001; + !byte $B3,%10100001 + !byte $B5,%11000001 + !byte $B5,%11100001 + !byte $B9,%00000010 + !byte $B7,%00000010 + !byte $BB,%00100010 + !byte $B9,%00100010 + !byte $BF,%01000010 + !byte $BD,%01000010 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $05,%01101000 + !byte $05,%10001001; + !byte $11,%10101001 + !byte $0F,%10101001 + !byte $2B,%11001001 + !byte $29,%11001001 + !byte $1B,%11001001 + !byte $19,%11001001 + !byte $25,%11101001 + !byte $23,%11101001 + !byte $21,%11101001 + !byte $AF,%00000000 + !byte $B1,%00100000 + !byte $B3,%01100000 + !byte $B3,%10000001; + !byte $B5,%10100001 + !byte $B7,%11000001 + !byte $B7,%11100001 + !byte $BB,%00000010 + !byte $BF,%00100010 + !byte $BD,%00100010 + !byte $09,%01101000 + !byte $09,%10001001; + !byte $13,%10101001 + !byte $B1,%00000000 + !byte $B3,%00100000 + !byte $B3,%01000000 + !byte $B5,%01100000 + !byte $B5,%10000001; + !byte $B7,%10100001 + !byte $B9,%11000001 + !byte $BB,%11100001 + !byte $B9,%11100001 + !byte $BD,%00000010 + !byte $03,%01001000 + !byte $01,%01001000 + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $17,%10101001 + !byte $15,%10101001 + !byte $27,%11001001 + !byte $25,%11001001 + !byte $23,%11001001 + !byte $21,%11001001 + !byte $1F,%11001001 + !byte $1D,%11001001 + !byte $B5,%01000000 + !byte $B7,%01100000 + !byte $B7,%10000001; + !byte $BF,%00000010 + !byte $29,%10101001 + !byte $B3,%00000000 + !byte $B5,%00100000 + !byte $B7,%01000000 + !byte $B9,%10100001 + !byte $BB,%11000001 + !byte $BF,%11100001 + !byte $BD,%11100001 + !byte $09,%01001000 + !byte $07,%01001000 + !byte $05,%01001000 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $27,%10101001 + !byte $25,%10101001 + !byte $1B,%10101001 + !byte $19,%10101001 + !byte $B5,%00000000 + !byte $B7,%00100000 + !byte $B9,%01100000 + !byte $B9,%10000001; + !byte $BB,%10100001 + !byte $BD,%11000001 + !byte $B7,%00000000 + !byte $B9,%00100000 + !byte $B9,%01000000 + !byte $BB,%01100000 + !byte $BB,%10000001; + !byte $BF,%10100001 + !byte $BD,%10100001 + !byte $BF,%11000001 + !byte $05,%00101000 + !byte $03,%00101000 + !byte $01,%00101000 + !byte $0D,%01001000 + !byte $0B,%01001000 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $17,%01101000 + !byte $17,%10001001; + !byte $15,%01101000 + !byte $15,%10001001; + !byte $13,%01101000 + !byte $13,%10001001; + !byte $23,%10101001 + !byte $21,%10101001 + !byte $1F,%10101001 + !byte $1D,%10101001 + !byte $B9,%00000000 + !byte $BB,%01000000 + !byte $BD,%01100000 + !byte $BD,%10000001; + !byte $BB,%00000000 + !byte $BB,%00100000 + !byte $BD,%01000000 + !byte $BF,%01100000 + !byte $BF,%10000001; + !byte $09,%00101000 + !byte $07,%00101000 + !byte $13,%01001000 + !byte $11,%01001000 + !byte $0F,%01001000 + !byte $25,%01101000 + !byte $25,%10001001; + !byte $23,%01101000 + !byte $23,%10001001; + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $19,%01101000 + !byte $19,%10001001; + !byte $BD,%00100000 + !byte $BF,%01000000 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $BD,%00000000 + !byte $BF,%00100000 + !byte $03,%00001000 + !byte $01,%00001000 + !byte $0D,%00101000 + !byte $0B,%00101000 + !byte $25,%01001000 + !byte $23,%01001000 + !byte $17,%01001000 + !byte $15,%01001000 + !byte $BF,%00000000 + !byte $07,%00001000 + !byte $05,%00001000 + !byte $25,%00101000 + !byte $13,%00101000 + !byte $11,%00101000 + !byte $0F,%00101000 + !byte $21,%01001000 + !byte $1F,%01001000 + !byte $1D,%01001000 + !byte $1B,%01001000 + !byte $19,%01001000 + !byte $09,%00001000 + !byte $05,%11100111 + !byte $03,%11100111 + !byte $01,%11100111 + !byte $0F,%00001000 + !byte $0D,%00001000 + !byte $0B,%00001000 + !byte $23,%00101000 + !byte $21,%00101000 + !byte $17,%00101000 + !byte $15,%00101000 + !byte $1F,%00101000 + !byte $09,%11100111 + !byte $07,%11100111 + !byte $23,%00001000 + !byte $21,%00001000 + !byte $11,%00001000 + !byte $1D,%00101000 + !byte $1B,%00101000 + !byte $19,%00101000 + !byte $1F,%00001000 + !byte $13,%00001000 + !byte $03,%11000111 + !byte $01,%11000111 + !byte $0F,%11100111 + !byte $0D,%11100111 + !byte $0B,%11100111 + !byte $1D,%00001000 + !byte $1B,%00001000 + !byte $19,%00001000 + !byte $17,%00001000 + !byte $15,%00001000 + !byte $05,%11000111 + !byte $21,%11100111 + !byte $0B,%11000111 + !byte $09,%11000111 + !byte $07,%11000111 + !byte $1F,%11100111 + !byte $13,%11100111 + !byte $11,%11100111 + !byte $01,%10100111 + !byte $1D,%11100111 + !byte $05,%10100111 + !byte $03,%10100111 + !byte $1F,%11000111 + !byte $0D,%11000111 + !byte $1B,%11100111 + !byte $19,%11100111 + !byte $17,%11100111 + !byte $15,%11100111 + !byte $09,%10100111 + !byte $07,%10100111 + !byte $1D,%11000111 + !byte $1B,%11000111 + !byte $19,%11000111 + !byte $17,%11000111 + !byte $15,%11000111 + !byte $13,%11000111 + !byte $11,%11000111 + !byte $0F,%11000111 + !byte $1F,%10100111 + !byte $0B,%10100111 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $03,%01100110 + !byte $03,%10000111; + !byte $01,%01100110 + !byte $01,%10000111; + !byte $1D,%10100111 + !byte $1B,%10100111 + !byte $0F,%10100111 + !byte $0D,%10100111 + !byte $01,%01000110 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $09,%01100110 + !byte $09,%10000111; + !byte $07,%01100110 + !byte $07,%10000111; + !byte $19,%10100111 + !byte $17,%10100111 + !byte $15,%10100111 + !byte $13,%10100111 + !byte $11,%10100111 + !byte $05,%01000110 + !byte $03,%01000110 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $19,%01100110 + !byte $19,%10000111; + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $17,%01100110 + !byte $17,%10000111; + !byte $15,%01100110 + !byte $15,%10000111; + !byte $13,%01100110 + !byte $13,%10000111; + !byte $11,%01100110 + !byte $11,%10000111; + !byte $01,%00100110 + !byte $1B,%01000110 + !byte $19,%01000110 + !byte $0B,%01000110 + !byte $09,%01000110 + !byte $07,%01000110 + !byte $17,%01000110 + !byte $1B,%00100110 + !byte $05,%00100110 + !byte $03,%00100110 + !byte $15,%01000110 + !byte $13,%01000110 + !byte $11,%01000110 + !byte $0F,%01000110 + !byte $0D,%01000110 + !byte $01,%00000110 + !byte $19,%00100110 + !byte $17,%00100110 + !byte $09,%00100110 + !byte $07,%00100110 + !byte $15,%00100110 + !byte $19,%00000110 + !byte $17,%00000110 + !byte $05,%00000110 + !byte $03,%00000110 + !byte $13,%00100110 + !byte $11,%00100110 + !byte $0F,%00100110 + !byte $0D,%00100110 + !byte $0B,%00100110 + !byte $15,%00000110 + !byte $07,%00000110 + !byte $17,%11100101 + !byte $01,%11100101 + !byte $13,%00000110 + !byte $11,%00000110 + !byte $0F,%00000110 + !byte $0D,%00000110 + !byte $0B,%00000110 + !byte $09,%00000110 + !byte $15,%11100101 + !byte $13,%11100101 + !byte $07,%11100101 + !byte $05,%11100101 + !byte $03,%11100101 + !byte $15,%11000101 + !byte $11,%11100101 + !byte $0F,%11100101 + !byte $0D,%11100101 + !byte $0B,%11100101 + !byte $09,%11100101 + !byte $01,%11000101 + !byte $15,%10100101 + !byte $13,%11000101 + !byte $11,%11000101 + !byte $0F,%11000101 + !byte $07,%11000101 + !byte $05,%11000101 + !byte $03,%11000101 + !byte $0D,%11000101 + !byte $0B,%11000101 + !byte $09,%11000101 + !byte $13,%10100101 + !byte $11,%10100101 + !byte $03,%10100101 + !byte $01,%10100101 + !byte $0F,%10100101 + !byte $13,%01100100 + !byte $13,%10000101; + !byte $0D,%10100101 + !byte $0B,%10100101 + !byte $09,%10100101 + !byte $07,%10100101 + !byte $05,%10100101 + !byte $11,%01100100 + !byte $11,%10000101; + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $01,%01100100 + !byte $01,%10000101; + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $11,%01000100 + !byte $0F,%01000100 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $09,%01100100 + !byte $09,%10000101; + !byte $07,%01100100 + !byte $07,%10000101; + !byte $05,%01100100 + !byte $05,%10000101; + !byte $03,%01100100 + !byte $03,%10000101; + !byte $0D,%01000100 + !byte $0B,%01000100 + !byte $09,%01000100 + !byte $07,%01000100 + !byte $05,%01000100 + !byte $03,%01000100 + !byte $01,%01000100 + !byte $0F,%00100100 + !byte $0D,%00100100 + !byte $0B,%00100100 + !byte $0F,%00000100 + !byte $0D,%00000100 + !byte $09,%00100100 + !byte $07,%00100100 + !byte $05,%00100100 + !byte $03,%00100100 + !byte $01,%00100100 + !byte $0B,%00000100 + !byte $0D,%11100011 + !byte $09,%00000100 + !byte $07,%00000100 + !byte $05,%00000100 + !byte $03,%00000100 + !byte $01,%00000100 + !byte $0B,%11100011 + !byte $09,%11100011 + !byte $0B,%11000011 + !byte $07,%11100011 + !byte $05,%11100011 + !byte $03,%11100011 + !byte $01,%11100011 + !byte $09,%11000011 + !byte $07,%11000011 + !byte $05,%11000011 + !byte $09,%10100011 + !byte $07,%10100011 + !byte $03,%11000011 + !byte $01,%11000011 + !byte $05,%10100011 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $03,%10100011 + !byte $01,%10100011 + !byte $07,%01100010 + !byte $07,%10000011; + !byte $05,%01100010 + !byte $05,%10000011; + !byte $03,%01100010 + !byte $03,%10000011; + !byte $07,%01000010 + !byte $05,%01000010 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $03,%01000010 + !byte $07,%00100010 + !byte $05,%00100010 + !byte $01,%01000010 + !byte $03,%00100010 + !byte $01,%00100010 + !byte $05,%00000010 + !byte $03,%00000010 + !byte $03,%11100001 + !byte $01,%00000010 + !byte $01,%11100001 + !byte $01,%11000001 + !byte $01,%10100001 diff --git a/src/fx/fx.hgr.maple.in.a b/src/fx/fx.hgr.maple.in.a new file mode 100644 index 0000000..0c75205 --- /dev/null +++ b/src/fx/fx.hgr.maple.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MAPLE.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/MAPLE.DATA" diff --git a/src/fx/fx.hgr.maple.ripple.a b/src/fx/fx.hgr.maple.ripple.a new file mode 100644 index 0000000..8333d73 --- /dev/null +++ b/src/fx/fx.hgr.maple.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/MAPLE.RIPPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 13 + !text "FX/MAPLE.DATA" diff --git a/src/fx/fx.hgr.meet.in.the.middle.a b/src/fx/fx.hgr.meet.in.the.middle.a new file mode 100644 index 0000000..39493a9 --- /dev/null +++ b/src/fx/fx.hgr.meet.in.the.middle.a @@ -0,0 +1,98 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/MEETINTHEMIDDLE",plain +*=$6000 + +maskindex = $fc +row = $fd +col1 = $fe +col2 = $ff + + !source "src/constants.a" + + lda #0 + sta col1 + lda #39 + sta col2 +@colloop + lda #6 + sta maskindex + jsr WaitForVBL +@maskloop + ldx maskindex + lda copymasks1,x + sta @copymask1 + lda copymasks2,x + sta @copymask2 + + lda #23 + sta row +@rowloop + lda row + asl + asl + asl + jsr HGRCalc + clc + ldx #8 +@blockloop + ldy col1 + lda ($26),y + eor ($3c),y +@copymask1=*+1 + and #0 ; SMC + eor ($26),y + sta ($26),y + + ldy col2 + lda ($26),y + eor ($3c),y +@copymask2=*+1 + and #0 ; SMC + eor ($26),y + sta ($26),y + + lda $27 + adc #4 + sta $27 + eor #$60 + sta $3d + dex + bne @blockloop + + dec row + bpl @rowloop + + lda #1 + jsr WaitForKeyWithTimeout + bmi @exit + dec maskindex + bpl @maskloop + inc col1 + dec col2 + lda col1 + cmp #20 + bne @colloop +@exit jmp UnwaitForVBL +copymasks1 + !byte %11111111 + !byte %10111111 + !byte %10011111 + !byte %10001111 + !byte %10000111 + !byte %10000011 + !byte %10000001 +copymasks2 + !byte %11111111 + !byte %11111110 + !byte %11111100 + !byte %11111000 + !byte %11110000 + !byte %11100000 + !byte %11000000 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.onesquare.white.a b/src/fx/fx.hgr.onesquare.white.a new file mode 100644 index 0000000..1eff718 --- /dev/null +++ b/src/fx/fx.hgr.onesquare.white.a @@ -0,0 +1,147 @@ +;license:MIT +;(c) 2018-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/ONESQUARE",plain +*=$6000 + + ldy #0 + sty $FA + ldx #40 + stx $FB + dex + stx $FC + lda #23 + sta $FD + lda #Coordinates + sta $FF +-- ldx $FA +- lda $FA + sta ($FE), y + iny + txa + sta ($FE), y + iny + bne + + inc $FF ++ inx + cpx $FB + bne - + ldx $FA +- inx + cpx $FD + bcs + + txa + sta ($FE), y + iny + lda $FA + sta ($FE), y + iny + txa + sta ($FE), y + iny + lda $FC + sta ($FE), y + iny + bne - + inc $FF + bne - ; always branches ++ ldx $FA +- lda $FD + sta ($FE), y + iny + txa + sta ($FE), y + iny + bne + + inc $FF ++ inx + cpx $FB + bne - + lda #$FF + sta ($FE), y + iny + sta ($FE), y + iny + dec $FB + dec $FC + dec $FD + inc $FA + lda $FA + cmp #12 + bne -- + + lda #$80 + sta Coordinates+$798 + + lda #Coordinates + sta $FF + ldy #$00 +@loop1 + lda ($FE),y + bpl @copy + lda #$18 + jsr WaitForKeyWithTimeout + bmi @exit + bpl @next ; always branches +@copy + tax + iny + lda ($fe),y + tay + txa + jsr HGRBlockToWhite +@next + inc $FE + bne + + inc $FF ++ inc $FE + bne + + inc $FF ++ ldy #$00 + lda ($FE),y + cmp #$80 + bne @loop1 + +@loop2 + dec $FE + lda $FE + cmp #$FF + bne + + dec $FF ++ dec $FE + lda $FE + cmp #$FF + bne + + dec $FF ++ ldy #$00 + lda ($FE),y + cmp #$80 + beq @exit + lda ($FE),y + bpl @copy2 + lda #$18 + jsr WaitForKeyWithTimeout + bmi @exit + bpl @loop2 ; always branches +@copy2 + tax + iny + lda ($fe),y + tay + txa + jsr HGRBlockCopy + beq @loop2 ; always branches +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_BLOCK_COPY_ROUTINES + + !byte $80,$80 +Coordinates diff --git a/src/fx/fx.hgr.palette.fizzle.a b/src/fx/fx.hgr.palette.fizzle.a new file mode 100644 index 0000000..25696e2 --- /dev/null +++ b/src/fx/fx.hgr.palette.fizzle.a @@ -0,0 +1,100 @@ +;license:MIT +;(c) 2017-2019 by qkumba and 4am + +!cpu 6502 +!to "build/FX/PALETTE.FIZZLE",plain +*=$6000 + +copymask_even = $f0 +copymask_odd = $f1 +counter = $f2 + + !source "src/fx/macros.a" + + ;init masks + + lda #%11010101 + sta copymask_even + lda #%10101010 + sta copymask_odd + lda #2 + sta counter + +@outerloop + ;init RNG + + ldx #1 + stx @rnd1+1 + dex + stx @rnd2+1 + + ;iterate + +@loop + ldy @rnd1+1 + ldx @rnd2+1 + lsr @rnd2+1 + ror @rnd1+1 + bcc + + + ;feedback polynomial forms #$100D for period of 8191 + + lda @rnd1+1 + eor #$0d + sta @rnd1+1 + lda @rnd2+1 + eor #$10 + sta @rnd2+1 + + ;little hack to avoid missing offset zero + ;screen hole at $xxFF is missed instead + ++ tya + eor #$ff + sta $26 + sta $3c + txa + + ;target page 1 + + ora #$20 + sta $27 + eor #$60 + sta $3d + + ;copy pixel from other page to this page + ldy #0 + lda $26 + ror + bcs @odd + lda ($26),y + eor ($3c),y + and copymask_even + eor ($26),y + sta ($26),y + jmp @next +@odd + lda ($26),y + eor ($3c),y + and copymask_odd + eor ($26),y + sta ($26),y +@next + + lda $c000 + bmi @exit + + ;and exit condition + +@rnd2 lda #0 + bne @loop +@rnd1 lda #0 + cmp #1 + bne @loop + + lda #$FF + sta copymask_even + sta copymask_odd + dec counter + +LBNE @outerloop +@exit rts diff --git a/src/fx/fx.hgr.pinwheels.a b/src/fx/fx.hgr.pinwheels.a new file mode 100644 index 0000000..af1c857 --- /dev/null +++ b/src/fx/fx.hgr.pinwheels.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/PINWHEELS",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + !source "src/fx/fx.hgr.radial.common.a" + +!if * and 1 { + !byte 0 +} +Coordinates + !source "src/fx/fx.hgr.pinwheels.data.a" +EndCoordinates + !byte $80 diff --git a/src/fx/fx.hgr.pinwheels.data.a b/src/fx/fx.hgr.pinwheels.data.a new file mode 100644 index 0000000..a52a95b --- /dev/null +++ b/src/fx/fx.hgr.pinwheels.data.a @@ -0,0 +1,6720 @@ + !byte $0C,%11000100 + !byte $24,%11010011 + !byte $5E,%01110001 + !byte $46,%01100010 + !byte $0C,%11001001 + !byte $24,%11001110 + !byte $5E,%01101100 + !byte $5E,%01100010 + !byte $24,%11001001 + !byte $0C,%11001110 + !byte $46,%01101100 + !byte $46,%01100111 + !byte $24,%11000100 + !byte $0C,%11010011 + !byte $46,%01110001 + !byte $5E,%01100111 + !byte $0C,%10100100 + !byte $2E,%01110001 + !byte $5C,%01110001 + !byte $5C,%01100010 + !byte $0C,%10101001 + !byte $2E,%01101100 + !byte $5C,%01101100 + !byte $44,%01100010 + !byte $24,%10101001 + !byte $16,%01101100 + !byte $44,%01101100 + !byte $44,%01100111 + !byte $24,%10100100 + !byte $16,%01110001 + !byte $44,%01110001 + !byte $5C,%01100111 + !byte $0C,%10000100 + !byte $24,%10110011 + !byte $5A,%01110001 + !byte $48,%10000111 + !byte $0C,%10001001 + !byte $24,%10101110 + !byte $5A,%01101100 + !byte $30,%10000111 + !byte $24,%10001001 + !byte $0C,%10101110 + !byte $42,%01101100 + !byte $48,%10000010 + !byte $24,%10000100 + !byte $0C,%10110011 + !byte $42,%01110001 + !byte $42,%01100010 + !byte $0C,%01101001 + !byte $2C,%01110001 + !byte $58,%01110001 + !byte $42,%01100111 + !byte $24,%01101001 + !byte $2C,%01101100 + !byte $40,%01110001 + !byte $5A,%01100111 + !byte $0C,%01100100 + !byte $14,%01101100 + !byte $58,%01101100 + !byte $5A,%01100010 + !byte $24,%01100100 + !byte $14,%01110001 + !byte $40,%01101100 + !byte $30,%10000010 + !byte $0C,%01001001 + !byte $24,%10010011 + !byte $56,%01110001 + !byte $32,%10000111 + !byte $24,%01001001 + !byte $24,%10001110 + !byte $3E,%01110001 + !byte $4A,%10000111 + !byte $2E,%01100010 + !byte $0C,%10001110 + !byte $3E,%01101100 + !byte $32,%10000010 + !byte $16,%01100010 + !byte $0C,%10010011 + !byte $30,%10010001 + !byte $4A,%10000010 + !byte $16,%01100111 + !byte $2A,%01110001 + !byte $56,%01101100 + !byte $40,%01100111 + !byte $2E,%01100111 + !byte $2A,%01101100 + !byte $48,%10010001 + !byte $54,%11001001 + !byte $0C,%01000100 + !byte $12,%01101100 + !byte $54,%11010011 + !byte $54,%11000100 + !byte $24,%01000100 + !byte $12,%01110001 + !byte $54,%11001110 + !byte $34,%10000111 + !byte $0C,%00101001 + !byte $24,%01101110 + !byte $30,%10001100 + !byte $40,%01100010 + !byte $24,%00101001 + !byte $0C,%01101110 + !byte $48,%10001100 + !byte $58,%01100111 + !byte $0C,%00100100 + !byte $24,%01110011 + !byte $32,%10010001 + !byte $34,%10000010 + !byte $00,%10000111 + !byte $0C,%01110011 + !byte $54,%10101110 + !byte $3C,%11001001 + !byte $18,%10000111 + !byte $28,%01110001 + !byte $32,%10001100 + !byte $4C,%10000111 + !byte $24,%00100100 + !byte $10,%01110001 + !byte $3C,%11010011 + !byte $3C,%11000100 + !byte $14,%01100010 + !byte $24,%01001110 + !byte $3C,%11001110 + !byte $54,%10101001 + !byte $2C,%01100010 + !byte $0C,%01001110 + !byte $54,%10110011 + !byte $54,%10100100 + !byte $14,%01100111 + !byte $24,%01010011 + !byte $46,%01001100 + !byte $58,%01100010 + !byte $2C,%01100111 + !byte $0C,%01010011 + !byte $3C,%10101110 + !byte $4C,%10000010 + !byte $24,%00001001 + !byte $24,%00101110 + !byte $4A,%10010001 + !byte $3C,%10100100 + !byte $0C,%00000100 + !byte $0C,%00101110 + !byte $3C,%10110011 + !byte $3C,%10101001 + !byte $0C,%00001001 + !byte $28,%01101100 + !byte $54,%10010011 + !byte $54,%10000100 + !byte $24,%00000100 + !byte $10,%01101100 + !byte $54,%10001110 + !byte $54,%10001001 + !byte $18,%10000010 + !byte $0C,%00110011 + !byte $46,%01010001 + !byte $3C,%10001001 + !byte $00,%10000010 + !byte $24,%00110011 + !byte $4A,%10001100 + !byte $3C,%10000100 + !byte $0C,%11000011 + !byte $24,%00001110 + !byte $3C,%10010011 + !byte $36,%10000010 + !byte $0C,%11001000 + !byte $0C,%00001110 + !byte $5E,%01001100 + !byte $54,%01100100 + !byte $24,%11001000 + !byte $24,%00010011 + !byte $3C,%10001110 + !byte $3C,%01101001 + !byte $24,%11000011 + !byte $0C,%00010011 + !byte $54,%01110011 + !byte $54,%01101001 + !byte $1A,%10000111 + !byte $26,%01110001 + !byte $54,%01101110 + !byte $46,%01000010 + !byte $02,%10000111 + !byte $24,%11001101 + !byte $5E,%01010001 + !byte $36,%10000111 + !byte $12,%01100010 + !byte $0C,%11001101 + !byte $34,%10001100 + !byte $46,%01000111 + !byte $12,%01100111 + !byte $0C,%11010010 + !byte $34,%10010001 + !byte $3C,%01100100 + !byte $2A,%01100111 + !byte $24,%11010010 + !byte $3C,%01101110 + !byte $54,%01001001 + !byte $2A,%01100010 + !byte $0E,%01110001 + !byte $3C,%01110011 + !byte $3A,%00000000 + !byte $0C,%10100011 + !byte $24,%10110010 + !byte $44,%01001100 + !byte $3A,%00000101 + !byte $0C,%10101000 + !byte $24,%10101101 + !byte $54,%01010011 + !byte $54,%01000100 + !byte $24,%10101000 + !byte $0C,%10101101 + !byte $54,%01001110 + !byte $3C,%01001001 + !byte $24,%10100011 + !byte $0C,%10110010 + !byte $44,%01010001 + !byte $4E,%10000010 + !byte $02,%10000010 + !byte $18,%10010001 + !byte $3C,%01001110 + !byte $3C,%01000100 + !byte $1A,%10000010 + !byte $00,%10010001 + !byte $3C,%01010011 + !byte $4E,%10000111 + !byte $0C,%10001000 + !byte $0C,%10001101 + !byte $4C,%10010001 + !byte $54,%00101001 + !byte $0C,%10000011 + !byte $0C,%10010010 + !byte $4C,%10001100 + !byte $5E,%01000010 + !byte $24,%10001000 + !byte $18,%10001100 + !byte $3A,%00001010 + !byte $5E,%01000111 + !byte $1C,%10000111 + !byte $24,%10010010 + !byte $54,%00110011 + !byte $3E,%01100111 + !byte $24,%10000011 + !byte $24,%10001101 + !byte $54,%00101110 + !byte $54,%00100100 + !byte $0C,%01101000 + !byte $00,%10001100 + !byte $3A,%00001111 + !byte $30,%10100111 + !byte $1C,%10000010 + !byte $1A,%10010001 + !byte $5C,%01001100 + !byte $3C,%00100100 + !byte $0C,%01100011 + !byte $0C,%01101101 + !byte $5C,%01010001 + !byte $3C,%00101001 + !byte $28,%01100111 + !byte $0C,%01110010 + !byte $3C,%00101110 + !byte $3A,%00100000 + !byte $04,%10000111 + !byte $26,%01101100 + !byte $3C,%00110011 + !byte $56,%01100111 + !byte $04,%10000010 + !byte $1A,%10001100 + !byte $54,%01110001 + !byte $3A,%00100101 + !byte $0C,%01001000 + !byte $0C,%01001101 + !byte $54,%00010011 + !byte $48,%10100111 + !byte $28,%01100010 + !byte $24,%01110010 + !byte $54,%00001110 + !byte $54,%00001001 + !byte $0C,%01000011 + !byte $24,%01101101 + !byte $3A,%00101010 + !byte $48,%10100010 + !byte $24,%01101000 + !byte $0C,%01010010 + !byte $3A,%00101111 + !byte $54,%00000100 + !byte $24,%01100011 + !byte $02,%10010001 + !byte $3C,%00001110 + !byte $3C,%00001001 + !byte $10,%01100111 + !byte $0C,%00101101 + !byte $3C,%00010011 + !byte $30,%10100010 + !byte $0C,%00100011 + !byte $2E,%01001100 + !byte $54,%11001101 + !byte $3C,%00000100 + !byte $1E,%10000010 + !byte $0C,%00110010 + !byte $3C,%11010010 + !byte $44,%01000010 + !byte $0C,%00101000 + !byte $02,%10001100 + !byte $48,%10110001 + !byte $5C,%01000010 + !byte $1E,%10000111 + !byte $0E,%01101100 + !byte $52,%00001111 + !byte $52,%00000000 + !byte $10,%01100010 + !byte $1C,%10010001 + !byte $52,%00001010 + !byte $44,%01000111 + !byte $24,%01001000 + !byte $1C,%10001100 + !byte $3C,%11001101 + !byte $52,%00000101 + !byte $06,%10000010 + !byte $2E,%01010001 + !byte $3A,%01001111 + !byte $3A,%01000101 + !byte $24,%01000011 + !byte $24,%01010010 + !byte $54,%11010010 + !byte $3A,%01000000 + !byte $06,%10000111 + !byte $24,%01001101 + !byte $48,%10101100 + !byte $5C,%01000111 + !byte $2E,%01000010 + !byte $16,%01001100 + !byte $30,%10110001 + !byte $56,%01100010 + !byte $18,%10100111 + !byte $04,%10001100 + !byte $3A,%01001010 + !byte $3E,%01100010 + !byte $16,%01000010 + !byte $04,%10010001 + !byte $42,%01001100 + !byte $54,%11001000 + !byte $0C,%00000011 + !byte $16,%01010001 + !byte $42,%01010001 + !byte $3C,%11000011 + !byte $2E,%01000111 + !byte $0C,%00001101 + !byte $5A,%01001100 + !byte $3C,%11001000 + !byte $18,%10100010 + !byte $0C,%00010010 + !byte $36,%10001100 + !byte $52,%00100101 + !byte $0C,%00001000 + !byte $2C,%01001100 + !byte $5A,%01010001 + !byte $54,%11000011 + !byte $00,%10100111 + !byte $2C,%01010001 + !byte $4E,%10001100 + !byte $3A,%01100101 + !byte $16,%01000111 + !byte $14,%01001100 + !byte $52,%00101111 + !byte $4A,%10100111 + !byte $00,%10100010 + !byte $24,%00110010 + !byte $52,%00101010 + !byte $52,%00100000 + !byte $24,%00101000 + !byte $14,%01010001 + !byte $36,%10010001 + !byte $3A,%01100000 + !byte $0C,%11000111 + !byte $24,%00101101 + !byte $3A,%01101010 + !byte $32,%10100111 + !byte $26,%01100111 + !byte $18,%10110001 + !byte $3A,%01101111 + !byte $4A,%10100010 + !byte $24,%00100011 + !byte $0C,%11001100 + !byte $4E,%10010001 + !byte $32,%10100010 + !byte $1A,%10100111 + !byte $00,%10110001 + !byte $30,%10101100 + !byte $52,%01000101 + !byte $14,%01000010 + !byte $1E,%10001100 + !byte $3C,%01110001 + !byte $52,%01000000 + !byte $02,%10100111 + !byte $06,%10001100 + !byte $54,%10110010 + !byte $3A,%10000000 + !byte $1A,%10100010 + !byte $0C,%11010001 + !byte $54,%10101101 + !byte $3A,%10000101 + !byte $14,%01000111 + !byte $1E,%10010001 + !byte $3C,%10110010 + !byte $38,%10000010 + !byte $2C,%01000010 + !byte $06,%10010001 + !byte $52,%01001111 + !byte $54,%10101000 + !byte $08,%10000010 + !byte $18,%10101100 + !byte $3C,%10101101 + !byte $54,%10100011 + !byte $0C,%11000010 + !byte $00,%10101100 + !byte $52,%01001010 + !byte $3C,%10100011 + !byte $2C,%01000111 + !byte $2A,%01010001 + !byte $3A,%10001010 + !byte $3C,%10101000 + !byte $20,%10000010 + !byte $2A,%01001100 + !byte $3A,%10001111 + !byte $52,%01100101 + !byte $02,%10100010 + !byte $12,%01001100 + !byte $46,%00101100 + !byte $52,%01100000 + !byte $0E,%01100111 + !byte $12,%01010001 + !byte $52,%01101111 + !byte $50,%10000010 + !byte $08,%10000111 + !byte $1A,%10110001 + !byte $5E,%00101100 + !byte $3A,%10100000 + !byte $20,%10000111 + !byte $02,%10110001 + !byte $52,%01101010 + !byte $3A,%10100101 + !byte $0A,%00000101 + !byte $24,%00010010 + !byte $4A,%10110001 + !byte $42,%01000010 + !byte $0A,%00000000 + !byte $1A,%10101100 + !byte $3C,%10001101 + !byte $42,%01000111 + !byte $26,%01100010 + !byte $02,%10101100 + !byte $46,%00110001 + !byte $3C,%10000011 + !byte $1C,%10100111 + !byte $24,%00001101 + !byte $32,%10110001 + !byte $38,%10000111 + !byte $24,%00001000 + !byte $0A,%00001010 + !byte $3C,%10010010 + !byte $5A,%01000010 + !byte $0A,%00100101 + !byte $0A,%00001111 + !byte $5E,%00110001 + !byte $3C,%10001000 + !byte $1C,%10100010 + !byte $2E,%00101100 + !byte $4A,%10101100 + !byte $5A,%01000111 + !byte $0E,%01100010 + !byte $16,%00101100 + !byte $32,%10101100 + !byte $52,%10000000 + !byte $0A,%00100000 + !byte $2E,%00110001 + !byte $3A,%10101111 + !byte $52,%10000101 + !byte $04,%10100111 + !byte $16,%00110001 + !byte $3A,%10101010 + !byte $46,%00100010 + !byte $24,%00000011 + !byte $0A,%00101010 + !byte $52,%10001111 + !byte $50,%10000111 + !byte $18,%11000111 + !byte $0A,%00101111 + !byte $52,%10001010 + !byte $46,%00100111 + !byte $04,%10100010 + !byte $22,%00001111 + !byte $54,%10010010 + !byte $52,%10100101 + !byte $22,%00000101 + !byte $0C,%10110001 + !byte $54,%10001101 + !byte $3A,%11000000 + !byte $22,%00000000 + !byte $22,%00001010 + !byte $3C,%01101101 + !byte $34,%10100111 + !byte $2A,%01000010 + !byte $18,%11010001 + !byte $52,%10101111 + !byte $54,%10001000 + !byte $2A,%01000111 + !byte $20,%10001100 + !byte $3C,%01110010 + !byte $34,%10100010 + !byte $18,%11000010 + !byte $08,%10001100 + !byte $52,%10101010 + !byte $5E,%00100010 + !byte $00,%11000111 + !byte $0A,%01001111 + !byte $3A,%11001010 + !byte $3A,%11000101 + !byte $12,%01000111 + !byte $0C,%10101100 + !byte $3A,%11001111 + !byte $52,%10100000 + !byte $12,%01000010 + !byte $00,%11010001 + !byte $44,%00101100 + !byte $54,%10000011 + !byte $0A,%01000101 + !byte $1C,%10110001 + !byte $40,%01010001 + !byte $30,%11000111 + !byte $2E,%00100010 + !byte $22,%00101010 + !byte $5C,%00101100 + !byte $4C,%10100111 + !byte $0A,%01000000 + !byte $22,%00101111 + !byte $40,%01001100 + !byte $5E,%00100111 + !byte $2E,%00100111 + !byte $0A,%01001010 + !byte $58,%01010001 + !byte $4C,%10100010 + !byte $22,%00100101 + !byte $1C,%10101100 + !byte $44,%00110001 + !byte $3C,%01100011 + !byte $22,%00100000 + !byte $20,%10010001 + !byte $52,%11001010 + !byte $3C,%01101000 + !byte $00,%11000010 + !byte $04,%10110001 + !byte $52,%11001111 + !byte $30,%11000010 + !byte $16,%00100111 + !byte $22,%01001111 + !byte $58,%01001100 + !byte $48,%11000111 + !byte $16,%00100010 + !byte $18,%11001100 + !byte $30,%11001100 + !byte $48,%11000010 + !byte $0A,%01100000 + !byte $04,%10101100 + !byte $30,%11010001 + !byte $52,%11000101 + !byte $0A,%01100101 + !byte $08,%10010001 + !byte $54,%01110010 + !byte $52,%11000000 + !byte $22,%01000101 + !byte $0A,%01101111 + !byte $54,%01101101 + !byte $3A,%00000001 + !byte $22,%01000000 + !byte $0A,%01101010 + !byte $5C,%00110001 + !byte $3A,%00000110 + !byte $0C,%10100111 + !byte $2C,%00110001 + !byte $48,%11010001 + !byte $54,%01100011 + !byte $0C,%10100010 + !byte $22,%01001010 + !byte $3A,%00001011 + !byte $54,%01101000 + !byte $1A,%11000111 + !byte $2C,%00101100 + !byte $3A,%00010000 + !byte $52,%00000001 + !byte $0A,%10000000 + !byte $00,%11001100 + !byte $48,%11001100 + !byte $52,%00000110 + !byte $22,%01100000 + !byte $14,%00101100 + !byte $34,%10101100 + !byte $44,%00100010 + !byte $0A,%10000101 + !byte $14,%00110001 + !byte $54,%01101100 + !byte $44,%00100111 + !byte $22,%01100101 + !byte $26,%11010011 + !byte $34,%10110001 + !byte $5C,%00100010 + !byte $26,%11000100 + !byte $26,%11001110 + !byte $4C,%10110001 + !byte $3C,%01001000 + !byte $26,%11001001 + !byte $28,%01010001 + !byte $3C,%01010010 + !byte $3C,%01000011 + !byte $1A,%11000010 + !byte $22,%01101010 + !byte $4C,%10101100 + !byte $5C,%00100111 + !byte $02,%11000111 + !byte $10,%01010001 + !byte $3C,%01001101 + !byte $4A,%11000111 + !byte $02,%11000010 + !byte $22,%01101111 + !byte $38,%10001100 + !byte $32,%11000111 + !byte $22,%10000101 + !byte $28,%01001100 + !byte $52,%00010000 + !byte $52,%00100110 + !byte $06,%10100010 + !byte $0A,%10001010 + !byte $52,%00001011 + !byte $52,%00100001 + !byte $22,%10000000 + !byte $24,%11010001 + !byte $50,%10001100 + !byte $3A,%00100001 + !byte $14,%00100010 + !byte $10,%01001100 + !byte $38,%10010001 + !byte $3A,%00100110 + !byte $06,%10100111 + !byte $0A,%10001111 + !byte $46,%00001100 + !byte $58,%01000111 + !byte $1E,%10100010 + !byte $24,%11001100 + !byte $5E,%00001100 + !byte $4A,%11000010 + !byte $1E,%10100111 + !byte $26,%10101110 + !byte $52,%00110000 + !byte $32,%11000010 + !byte $14,%00100111 + !byte $26,%10110011 + !byte $46,%00010001 + !byte $40,%01000111 + !byte $2C,%00100010 + !byte $22,%10001010 + !byte $50,%10010001 + !byte $58,%01000010 + !byte $0A,%10100000 + !byte $0E,%11001110 + !byte $52,%00101011 + !byte $40,%01000010 + !byte $26,%10101001 + !byte $1A,%11010001 + !byte $3A,%00101011 + !byte $54,%01001000 + !byte $26,%10100100 + !byte $22,%10001111 + !byte $3A,%00110000 + !byte $48,%00001000 + !byte $0A,%10100101 + !byte $02,%11010001 + !byte $54,%01010010 + !byte $46,%00000010 + !byte $2C,%00100111 + !byte $24,%01110001 + !byte $54,%01001101 + !byte $36,%10100010 + !byte $0E,%11001001 + !byte $16,%00001100 + !byte $5E,%00010001 + !byte $36,%10100111 + !byte $0E,%11000100 + !byte $0E,%11010011 + !byte $4A,%11010001 + !byte $4E,%10100010 + !byte $24,%11000111 + !byte $1A,%11001100 + !byte $4A,%11001100 + !byte $46,%00000111 + !byte $18,%00001000 + !byte $0A,%10101010 + !byte $32,%11010001 + !byte $54,%01000011 + !byte $00,%00001000 + !byte $02,%11001100 + !byte $42,%00101100 + !byte $5E,%00000010 + !byte $26,%10000100 + !byte $0A,%10101111 + !byte $32,%11001100 + !byte $4E,%10100111 + !byte $22,%10100101 + !byte $2E,%00001100 + !byte $3C,%00110010 + !byte $52,%01000001 + !byte $22,%10100000 + !byte $16,%00010001 + !byte $5A,%00101100 + !byte $30,%00001000 + !byte $18,%00000011 + !byte $26,%10001110 + !byte $3C,%00101101 + !byte $5E,%00000111 + !byte $26,%10001001 + !byte $26,%10010011 + !byte $42,%00110001 + !byte $3A,%01000001 + !byte $00,%00000011 + !byte $22,%10101010 + !byte $5A,%00110001 + !byte $3A,%01000110 + !byte $24,%11000010 + !byte $0E,%10101110 + !byte $56,%11001110 + !byte $52,%01000110 + !byte $0E,%10100100 + !byte $0E,%10110011 + !byte $52,%01010000 + !byte $48,%00000011 + !byte $0A,%11000000 + !byte $2E,%00010001 + !byte $52,%01001011 + !byte $30,%00000011 + !byte $0E,%10101001 + !byte $22,%10101111 + !byte $56,%11010011 + !byte $3C,%00101000 + !byte $16,%00000010 + !byte $18,%00010010 + !byte $3A,%01001011 + !byte $3C,%00100011 + !byte $0A,%11000101 + !byte $1E,%10101100 + !byte $3A,%01010000 + !byte $56,%11000100 + !byte $28,%01000111 + !byte $00,%00010010 + !byte $48,%00010010 + !byte $56,%11001001 + !byte $2E,%00000010 + !byte $0A,%11001010 + !byte $3C,%01101100 + !byte $42,%00100111 + !byte $10,%01000111 + !byte $1E,%10110001 + !byte $30,%00010010 + !byte $42,%00100010 + !byte $28,%01000010 + !byte $06,%10101100 + !byte $30,%00001101 + !byte $5A,%00100111 + !byte $22,%11000101 + !byte $0A,%11001111 + !byte $48,%00001101 + !byte $5A,%00100010 + !byte $22,%11000000 + !byte $26,%01110011 + !byte $56,%10110011 + !byte $3E,%11001001 + !byte $1C,%11000111 + !byte $26,%01101110 + !byte $44,%00001100 + !byte $56,%10101001 + !byte $0A,%10000010 + !byte $0E,%10001110 + !byte $3E,%11010011 + !byte $56,%10100100 + !byte $16,%00000111 + !byte $06,%10110001 + !byte $3E,%11001110 + !byte $3E,%11000100 + !byte $2E,%00000111 + !byte $18,%00001101 + !byte $44,%00010001 + !byte $34,%11000111 + !byte $26,%01100100 + !byte $0E,%10010011 + !byte $56,%10101110 + !byte $52,%01100110 + !byte $0E,%10000100 + !byte $22,%11001111 + !byte $36,%10101100 + !byte $52,%01100001 + !byte $0E,%10001001 + !byte $22,%11001010 + !byte $36,%10110001 + !byte $4C,%11000111 + !byte $26,%01101001 + !byte $2A,%00101100 + !byte $5C,%00001100 + !byte $34,%11000010 + !byte $1C,%11000010 + !byte $00,%00001101 + !byte $54,%00110010 + !byte $4C,%11000010 + !byte $10,%01000010 + !byte $2A,%00110001 + !byte $4E,%10101100 + !byte $3A,%01100110 + !byte $04,%11000111 + !byte $12,%00101100 + !byte $5C,%00010001 + !byte $3A,%01100001 + !byte $04,%11000010 + !byte $12,%00110001 + !byte $4E,%10110001 + !byte $38,%00000000 + !byte $0A,%00000001 + !byte $0E,%01101110 + !byte $54,%00101101 + !byte $38,%00000101 + !byte $0E,%01100100 + !byte $0E,%01110011 + !byte $52,%01101011 + !byte $54,%00101000 + !byte $0A,%00000110 + !byte $26,%01010011 + !byte $46,%11001011 + !byte $44,%00000010 + !byte $22,%00000110 + !byte $26,%01001110 + !byte $3E,%10110011 + !byte $3E,%10101001 + !byte $22,%00000001 + !byte $0A,%00001011 + !byte $52,%01110000 + !byte $56,%10000100 + !byte $0E,%01101001 + !byte $0A,%00010000 + !byte $3E,%10101110 + !byte $3E,%10100100 + !byte $1A,%00001000 + !byte $1C,%11010001 + !byte $38,%00001111 + !byte $44,%00000111 + !byte $22,%10000010 + !byte $22,%00001011 + !byte $56,%10010011 + !byte $56,%10001001 + !byte $26,%01001001 + !byte $22,%00010000 + !byte $56,%10001110 + !byte $4A,%00001000 + !byte $26,%01000100 + !byte $1C,%11001100 + !byte $3A,%01101011 + !byte $5C,%00000010 + !byte $02,%00001000 + !byte $14,%00001100 + !byte $46,%11010000 + !byte $32,%00001000 + !byte $1A,%00000011 + !byte $04,%11010001 + !byte $3A,%01110000 + !byte $5C,%00000111 + !byte $2A,%00100010 + !byte $04,%11001100 + !byte $5E,%11001011 + !byte $54,%00100011 + !byte $02,%00000011 + !byte $0E,%01001110 + !byte $5E,%11010000 + !byte $4A,%00000011 + !byte $2A,%00100111 + !byte $0E,%01010011 + !byte $3C,%00010010 + !byte $32,%00000011 + !byte $0A,%10000111 + !byte $2C,%00001100 + !byte $38,%00001010 + !byte $46,%11000001 + !byte $18,%00101000 + !byte $14,%00010001 + !byte $4C,%11010001 + !byte $48,%00101000 + !byte $12,%00100010 + !byte $2C,%00010001 + !byte $3C,%00001101 + !byte $3E,%10001001 + !byte $12,%00100111 + !byte $1A,%00010010 + !byte $56,%01010001 + !byte $50,%00000000 + !byte $0E,%01000100 + !byte $26,%00101110 + !byte $34,%11010001 + !byte $38,%00100000 + !byte $0E,%01001001 + !byte $26,%00110011 + !byte $4C,%11001100 + !byte $46,%11000110 + !byte $18,%00100011 + !byte $16,%11001011 + !byte $34,%11001100 + !byte $50,%00000101 + !byte $0A,%00100001 + !byte $02,%00010010 + !byte $3E,%10010011 + !byte $5E,%11000001 + !byte $00,%00101000 + !byte $1A,%00001101 + !byte $3E,%10001110 + !byte $38,%00100101 + !byte $22,%00100110 + !byte $2E,%11001011 + !byte $56,%01101110 + !byte $3E,%10000100 + !byte $22,%00100001 + !byte $16,%11010000 + !byte $38,%00101010 + !byte $54,%01100111 + !byte $0A,%00100110 + !byte $02,%00001101 + !byte $56,%01110011 + !byte $30,%00101000 + !byte $00,%00100011 + !byte $0E,%00101110 + !byte $50,%00001010 + !byte $52,%10000001 + !byte $14,%00000010 + !byte $0E,%00110011 + !byte $38,%00101111 + !byte $3C,%00001000 + !byte $26,%00101001 + !byte $0A,%00101011 + !byte $50,%00001111 + !byte $52,%10000110 + !byte $26,%00100100 + !byte $18,%00110010 + !byte $4A,%00010010 + !byte $48,%00100011 + !byte $14,%00000111 + !byte $22,%00101011 + !byte $3E,%01010001 + !byte $56,%01101001 + !byte $2C,%00000010 + !byte $0A,%00110000 + !byte $4A,%00001101 + !byte $56,%01100100 + !byte $0E,%00100100 + !byte $2E,%11010000 + !byte $32,%00010010 + !byte $5E,%11000110 + !byte $0E,%00101001 + !byte $22,%00110000 + !byte $56,%01001100 + !byte $30,%00100011 + !byte $16,%11000001 + !byte $18,%00101101 + !byte $48,%00110010 + !byte $3C,%00000011 + !byte $2C,%00000111 + !byte $00,%00110010 + !byte $52,%10001011 + !byte $38,%01000101 + !byte $22,%10000111 + !byte $00,%00101101 + !byte $32,%00001101 + !byte $3A,%10000001 + !byte $16,%11000110 + !byte $0C,%10010001 + !byte $52,%10010000 + !byte $50,%00100101 + !byte $2E,%11000001 + !byte $24,%10110001 + !byte $3E,%01101110 + !byte $3A,%10000110 + !byte $08,%10100010 + !byte $26,%00001110 + !byte $3E,%01110011 + !byte $50,%00100000 + !byte $2E,%11000110 + !byte $26,%00010011 + !byte $48,%00101101 + !byte $3E,%01101001 + !byte $20,%10100010 + !byte $0E,%00001110 + !byte $30,%00110010 + !byte $3E,%01100100 + !byte $08,%00000000 + !byte $08,%00001111 + !byte $38,%01001010 + !byte $38,%01000000 + !byte $08,%00000101 + !byte $0E,%00010011 + !byte $50,%00101111 + !byte $3A,%10000010 + !byte $08,%10100111 + !byte $08,%00001010 + !byte $30,%00101101 + !byte $56,%01001001 + !byte $26,%00001001 + !byte $24,%10101100 + !byte $38,%01001111 + !byte $56,%01000100 + !byte $26,%00000100 + !byte $22,%01001011 + !byte $56,%01010011 + !byte $50,%01000101 + !byte $0A,%01000001 + !byte $22,%01010000 + !byte $3E,%01001100 + !byte $38,%01100101 + !byte $22,%01000110 + !byte $0A,%01001011 + !byte $50,%00101010 + !byte $50,%01000000 + !byte $22,%01000001 + !byte $20,%00001010 + !byte $56,%01001110 + !byte $3E,%01001001 + !byte $0A,%01000110 + !byte $0A,%01010000 + !byte $58,%00110001 + !byte $38,%01100000 + !byte $0E,%00000100 + !byte $0A,%10001100 + !byte $3A,%10001011 + !byte $3E,%01000100 + !byte $20,%10100111 + !byte $20,%00001111 + !byte $58,%00101100 + !byte $30,%01001000 + !byte $06,%11000010 + !byte $18,%01001101 + !byte $40,%00110001 + !byte $46,%10100110 + !byte $0E,%00001001 + !byte $26,%01010001 + !byte $3A,%10010000 + !byte $52,%10100001 + !byte $1E,%11000010 + !byte $26,%11001101 + !byte $40,%00101100 + !byte $48,%01001000 + !byte $06,%11000111 + !byte $08,%00101111 + !byte $3E,%01001110 + !byte $48,%01000011 + !byte $1E,%11000111 + !byte $26,%11010010 + !byte $3E,%01010011 + !byte $56,%01000111 + !byte $20,%00000101 + !byte $0C,%10001100 + !byte $54,%00010010 + !byte $5E,%10100001 + !byte $1C,%00001000 + !byte $00,%01010010 + !byte $50,%01001111 + !byte $46,%10100001 + !byte $1C,%00000011 + !byte $18,%01010010 + !byte $42,%00001100 + !byte $52,%10100110 + !byte $20,%00000000 + !byte $08,%00101010 + !byte $42,%00010001 + !byte $32,%00101000 + !byte $04,%00001000 + !byte $2E,%10101011 + !byte $5A,%00001100 + !byte $50,%01100101 + !byte $08,%00100000 + !byte $16,%10110000 + !byte $50,%01001010 + !byte $38,%10100010 + !byte $08,%00100101 + !byte $1A,%00101101 + !byte $44,%11001011 + !byte $44,%11000110 + !byte $1A,%00101000 + !byte $16,%10101011 + !byte $5A,%00010001 + !byte $4A,%00101000 + !byte $04,%00000011 + !byte $0E,%11010010 + !byte $44,%11010000 + !byte $4A,%00100011 + !byte $1A,%00100011 + !byte $1A,%00110010 + !byte $5C,%11001011 + !byte $44,%11000001 + !byte $02,%00101000 + !byte $02,%00110010 + !byte $38,%01101010 + !byte $56,%00101001 + !byte $18,%01001000 + !byte $2C,%11001011 + !byte $54,%00001101 + !byte $50,%01100000 + !byte $18,%01000011 + !byte $0E,%11001101 + !byte $46,%10101011 + !byte $56,%00100100 + !byte $02,%00100011 + !byte $28,%00110001 + !byte $38,%01101111 + !byte $5C,%11000001 + !byte $00,%01001000 + !byte $1C,%00001101 + !byte $5C,%11010000 + !byte $36,%11000010 + !byte $26,%11001000 + !byte $08,%10101100 + !byte $46,%10110000 + !byte $34,%00001000 + !byte $26,%11000011 + !byte $1C,%00010010 + !byte $5E,%10101011 + !byte $42,%00000010 + !byte $20,%00100101 + !byte $14,%11001011 + !byte $56,%00110011 + !byte $42,%00000111 + !byte $20,%00100000 + !byte $14,%11010000 + !byte $5E,%10110000 + !byte $58,%00100111 + !byte $00,%01000011 + !byte $04,%00010010 + !byte $56,%00101110 + !byte $4C,%00001000 + !byte $0E,%11000011 + !byte $2A,%00001100 + !byte $3E,%00110011 + !byte $4C,%00000011 + !byte $0E,%11001000 + !byte $2A,%00010001 + !byte $50,%01101111 + !byte $54,%00001000 + !byte $24,%10100111 + !byte $1E,%11001100 + !byte $50,%01101010 + !byte $5A,%00000010 + !byte $22,%01100001 + !byte $20,%00101111 + !byte $3E,%00101110 + !byte $38,%10000101 + !byte $08,%01000000 + !byte $06,%11001100 + !byte $52,%10101011 + !byte $36,%11000111 + !byte $08,%01000101 + !byte $12,%00010001 + !byte $3C,%11010001 + !byte $38,%10000000 + !byte $22,%01100110 + !byte $1E,%11010001 + !byte $52,%10110000 + !byte $5A,%00000111 + !byte $0A,%01100110 + !byte $12,%00001100 + !byte $38,%10001111 + !byte $4E,%11000010 + !byte $0A,%01100001 + !byte $06,%11010001 + !byte $48,%01010010 + !byte $34,%00000011 + !byte $16,%10100001 + !byte $20,%00101010 + !byte $48,%01001101 + !byte $40,%00100111 + !byte $28,%11000100 + !byte $28,%00101100 + !byte $38,%10001010 + !byte $4E,%11000111 + !byte $16,%10100110 + !byte $04,%00001101 + !byte $4A,%00110010 + !byte $54,%00000011 + !byte $2E,%10100001 + !byte $20,%10101100 + !byte $30,%01010010 + !byte $40,%00100010 + !byte $14,%11000001 + !byte $10,%00110001 + !byte $3C,%11001100 + !byte $58,%00100010 + !byte $20,%01000101 + !byte $2C,%11010000 + !byte $30,%01001101 + !byte $3E,%00100100 + !byte $20,%01000000 + !byte $10,%00101100 + !byte $4A,%00101101 + !byte $3E,%00101001 + !byte $14,%11000110 + !byte $08,%10110001 + !byte $32,%00110010 + !byte $5C,%11000110 + !byte $28,%11001001 + !byte $08,%01001010 + !byte $4C,%00010010 + !byte $32,%00100011 + !byte $2E,%10100110 + !byte $2E,%10110000 + !byte $56,%00010011 + !byte $38,%10100111 + !byte $24,%10100010 + !byte $08,%01001111 + !byte $56,%00001110 + !byte $50,%10100010 + !byte $2C,%11000110 + !byte $26,%01001100 + !byte $50,%10001111 + !byte $3E,%01000111 + !byte $2C,%11000001 + !byte $02,%00101101 + !byte $50,%10001010 + !byte $5E,%10100110 + !byte $08,%01100101 + !byte $28,%11010011 + !byte $32,%00101101 + !byte $56,%01000010 + !byte $12,%00000010 + !byte $22,%10001100 + !byte $4C,%00001101 + !byte $30,%01000011 + !byte $12,%00000111 + !byte $20,%10110001 + !byte $34,%00001101 + !byte $3A,%10000111 + !byte $2A,%00000111 + !byte $28,%11001110 + !byte $34,%00010010 + !byte $50,%10000101 + !byte $2A,%00000010 + !byte $0E,%01010001 + !byte $3E,%00001110 + !byte $3A,%10100001 + !byte $08,%01100000 + !byte $22,%01101011 + !byte $3E,%00010011 + !byte $50,%10100111 + !byte $10,%11001001 + !byte $00,%01001101 + !byte $36,%11001100 + !byte $52,%10000010 + !byte $10,%11000100 + !byte $0A,%10010001 + !byte $4E,%11001100 + !byte $50,%10000000 + !byte $0E,%10101000 + !byte $22,%01110000 + !byte $36,%11010001 + !byte $3A,%10100110 + !byte $28,%00100111 + !byte $0A,%01101011 + !byte $3A,%10101011 + !byte $3E,%01000010 + !byte $0E,%10100011 + !byte $20,%01001111 + !byte $3A,%10110000 + !byte $54,%01100010 + !byte $18,%01101000 + !byte $20,%01001010 + !byte $4E,%11010001 + !byte $3C,%01100111 + !byte $26,%10100011 + !byte $0A,%01110000 + !byte $38,%10101111 + !byte $38,%10100000 + !byte $26,%10101000 + !byte $26,%10101101 + !byte $46,%10001011 + !byte $38,%10100101 + !byte $18,%01100011 + !byte $0E,%10101101 + !byte $38,%10101010 + !byte $56,%00001001 + !byte $28,%00100010 + !byte $0E,%10110010 + !byte $38,%10101100 + !byte $56,%00000100 + !byte $0C,%10000111 + !byte $26,%10110010 + !byte $46,%10010000 + !byte $3E,%00000100 + !byte $20,%01100101 + !byte $0E,%01001100 + !byte $5E,%10001011 + !byte $3E,%00001001 + !byte $28,%10100100 + !byte $10,%11001110 + !byte $44,%10101011 + !byte $50,%10100101 + !byte $10,%00100111 + !byte $10,%11010011 + !byte $50,%10101111 + !byte $3C,%11000111 + !byte $20,%01100000 + !byte $28,%10110011 + !byte $50,%10101010 + !byte $50,%10100000 + !byte $00,%01101000 + !byte $28,%10101110 + !byte $5E,%10010000 + !byte $3C,%11000010 + !byte $28,%10101001 + !byte $08,%01101010 + !byte $38,%10110001 + !byte $48,%01101000 + !byte $1A,%01001000 + !byte $08,%01101111 + !byte $58,%11010011 + !byte $52,%11000001 + !byte $10,%00100010 + !byte $22,%10010001 + !byte $58,%11001110 + !byte $46,%10000001 + !byte $00,%01100011 + !byte $20,%01101111 + !byte $50,%10101100 + !byte $48,%01100011 + !byte $22,%10000110 + !byte $24,%01101100 + !byte $44,%10110000 + !byte $58,%11000100 + !byte $22,%10000001 + !byte $20,%01101010 + !byte $5C,%10101011 + !byte $30,%01101000 + !byte $1A,%01000011 + !byte $18,%01110010 + !byte $56,%11010010 + !byte $58,%11001001 + !byte $10,%10100100 + !byte $10,%10101110 + !byte $56,%11001101 + !byte $46,%10000110 + !byte $02,%01001000 + !byte $10,%10110011 + !byte $5C,%10110000 + !byte $52,%11000110 + !byte $26,%01000111 + !byte $18,%01101101 + !byte $3E,%11010010 + !byte $30,%01100011 + !byte $08,%10000000 + !byte $00,%01110010 + !byte $48,%01110010 + !byte $5E,%10000001 + !byte $02,%01000011 + !byte $28,%10001110 + !byte $3E,%11001101 + !byte $38,%11000101 + !byte $08,%10000101 + !byte $16,%10001011 + !byte $40,%11001110 + !byte $4A,%01001000 + !byte $1C,%00101000 + !byte $1A,%01010010 + !byte $50,%10110001 + !byte $38,%11000000 + !byte $10,%10101001 + !byte $00,%01101101 + !byte $42,%11010000 + !byte $5E,%10000110 + !byte $1C,%00100011 + !byte $08,%10001111 + !byte $38,%11001111 + !byte $44,%10100001 + !byte $0A,%10000001 + !byte $28,%10010011 + !byte $42,%11001011 + !byte $52,%10000111 + !byte $28,%10000100 + !byte $22,%10001011 + !byte $30,%01110010 + !byte $56,%11000011 + !byte $04,%00101000 + !byte $16,%10010000 + !byte $48,%01101101 + !byte $3E,%11000011 + !byte $20,%10000101 + !byte $08,%10001010 + !byte $38,%11001010 + !byte $56,%11001000 + !byte $20,%10000000 + !byte $1A,%01001101 + !byte $40,%11010011 + !byte $32,%01001000 + !byte $28,%10001001 + !byte $22,%10010000 + !byte $5A,%11010000 + !byte $4A,%01000011 + !byte $04,%00100011 + !byte $2E,%10001011 + !byte $5A,%11001011 + !byte $3E,%11001000 + !byte $0A,%10000110 + !byte $2E,%10010000 + !byte $30,%01101101 + !byte $44,%10100110 + !byte $16,%10000001 + !byte $02,%01010010 + !byte $58,%10110011 + !byte $50,%11000101 + !byte $16,%10000110 + !byte $0E,%10010010 + !byte $58,%10101110 + !byte $50,%11000000 + !byte $26,%01000010 + !byte $0E,%10001101 + !byte $52,%11001011 + !byte $32,%01000011 + !byte $10,%10000100 + !byte $26,%10010010 + !byte $50,%11001111 + !byte $5C,%10100001 + !byte $2E,%10000001 + !byte $02,%01001101 + !byte $3A,%10001100 + !byte $36,%00000101 + !byte $0E,%01000111 + !byte $20,%10001111 + !byte $4A,%01010010 + !byte $40,%11000100 + !byte $0E,%10000011 + !byte $26,%10001101 + !byte $50,%11001010 + !byte $40,%11001001 + !byte $0E,%10001000 + !byte $20,%10001010 + !byte $54,%11010001 + !byte $5C,%10100110 + !byte $2E,%10000110 + !byte $10,%10001110 + !byte $36,%00001111 + !byte $36,%00000000 + !byte $06,%00000011 + !byte $14,%10101011 + !byte $52,%11010000 + !byte $58,%10100100 + !byte $10,%10001001 + !byte $10,%10010011 + !byte $4A,%01001101 + !byte $58,%10101001 + !byte $1E,%00000011 + !byte $14,%10110000 + !byte $32,%01010010 + !byte $4C,%00101000 + !byte $08,%10100101 + !byte $1C,%00110010 + !byte $36,%00001010 + !byte $4C,%00100011 + !byte $1E,%00001000 + !byte $2C,%10101011 + !byte $40,%10101110 + !byte $34,%00100011 + !byte $08,%10100000 + !byte $0A,%10001011 + !byte $40,%10110011 + !byte $34,%00101000 + !byte $06,%00001000 + !byte $2C,%10110000 + !byte $32,%01001101 + !byte $3A,%11000001 + !byte $26,%10001000 + !byte $1C,%00101101 + !byte $54,%11001100 + !byte $42,%11000001 + !byte $26,%10000011 + !byte $0A,%10010000 + !byte $58,%00010001 + !byte $42,%11000110 + !byte $18,%10001000 + !byte $04,%00101101 + !byte $46,%01101011 + !byte $4E,%00000101 + !byte $14,%10100001 + !byte $04,%00110010 + !byte $56,%10110010 + !byte $5A,%11000001 + !byte $18,%10000011 + !byte $28,%01110011 + !byte $56,%10101101 + !byte $5A,%11000110 + !byte $14,%10100110 + !byte $28,%01101110 + !byte $3E,%10110010 + !byte $40,%10100100 + !byte $28,%01100100 + !byte $08,%10101010 + !byte $58,%00001100 + !byte $4E,%00000000 + !byte $20,%10100101 + !byte $08,%10101111 + !byte $3E,%10101101 + !byte $3A,%11000110 + !byte $20,%10100000 + !byte $0C,%01110001 + !byte $40,%00010001 + !byte $40,%10101001 + !byte $00,%10001000 + !byte $18,%10010010 + !byte $4E,%00001111 + !byte $38,%00000001 + !byte $28,%01101001 + !byte $10,%01101110 + !byte $4E,%00001010 + !byte $38,%00000110 + !byte $2C,%10100001 + !byte $12,%11001011 + !byte $46,%01110000 + !byte $48,%10001000 + !byte $0C,%10000010 + !byte $10,%01110011 + !byte $40,%00001100 + !byte $58,%10001001 + !byte $0E,%01000010 + !byte $2A,%11010000 + !byte $58,%10010011 + !byte $50,%00000001 + !byte $2C,%10100110 + !byte $2A,%11001011 + !byte $58,%10001110 + !byte $36,%00100000 + !byte $00,%10000011 + !byte $12,%11010000 + !byte $36,%00101111 + !byte $58,%10000100 + !byte $1A,%01101000 + !byte $20,%10101111 + !byte $36,%00101010 + !byte $36,%00100101 + !byte $10,%01101001 + !byte $20,%10101010 + !byte $5E,%01101011 + !byte $50,%00000110 + !byte $22,%10100001 + !byte $00,%10010010 + !byte $4C,%00110010 + !byte $46,%01100001 + !byte $10,%01100100 + !byte $18,%10001101 + !byte $34,%00110010 + !byte $3E,%10100011 + !byte $06,%00000101 + !byte $06,%00001101 + !byte $5E,%01110000 + !byte $3E,%10101000 + !byte $1A,%01100011 + !byte $1E,%00010010 + !byte $34,%00101101 + !byte $48,%10000011 + !byte $02,%01101000 + !byte $1E,%00001101 + !byte $4C,%00101101 + !byte $30,%10001000 + !byte $06,%00000000 + !byte $06,%00010010 + !byte $38,%00001011 + !byte $56,%10101000 + !byte $08,%11000010 + !byte $00,%10001101 + !byte $38,%00010000 + !byte $56,%10100011 + !byte $22,%10100110 + !byte $16,%01101011 + !byte $50,%00010000 + !byte $36,%00000011 + !byte $08,%11000101 + !byte $28,%01001110 + !byte $3A,%11001011 + !byte $46,%01100110 + !byte $02,%01100011 + !byte $28,%01010011 + !byte $40,%10010011 + !byte $4E,%00100101 + !byte $08,%11000000 + !byte $0E,%01110010 + !byte $48,%10010010 + !byte $5E,%01100001 + !byte $08,%11000111 + !byte $1A,%01110010 + !byte $50,%00001011 + !byte $54,%11000111 + !byte $2A,%11000110 + !byte $0E,%01101101 + !byte $40,%10001110 + !byte $36,%00001000 + !byte $2A,%11000001 + !byte $06,%00001111 + !byte $44,%10001011 + !byte $4E,%00000011 + !byte $12,%11000001 + !byte $06,%00001010 + !byte $3A,%11010000 + !byte $30,%10000011 + !byte $12,%11000110 + !byte $2E,%01101011 + !byte $48,%10001101 + !byte $4E,%00001000 + !byte $28,%01001001 + !byte $16,%01110000 + !byte $3A,%10010001 + !byte $5E,%01100110 + !byte $28,%01000100 + !byte $1A,%01101101 + !byte $44,%10010000 + !byte $4E,%00100000 + !byte $20,%11000101 + !byte $2E,%01110000 + !byte $4E,%00101111 + !byte $40,%10000100 + !byte $20,%11000010 + !byte $26,%01110010 + !byte $5C,%10001011 + !byte $3C,%01100010 + !byte $20,%11000000 + !byte $22,%10101011 + !byte $30,%10010010 + !byte $40,%10001001 + !byte $1E,%00000101 + !byte $02,%01110010 + !byte $4E,%00101010 + !byte $36,%01000101 + !byte $16,%01100001 + !byte $10,%01001110 + !byte $30,%10001101 + !byte $58,%00000111 + !byte $0A,%10100001 + !byte $08,%11001111 + !byte $5C,%10010000 + !byte $36,%01000000 + !byte $0E,%01101000 + !byte $10,%01010011 + !byte $58,%01101110 + !byte $4A,%01101000 + !byte $20,%11000111 + !byte $26,%01101101 + !byte $36,%01001111 + !byte $58,%00000010 + !byte $1E,%00000000 + !byte $08,%11001010 + !byte $58,%01110011 + !byte $40,%00000111 + !byte $16,%01100110 + !byte $22,%10110000 + !byte $36,%01001010 + !byte $40,%00000010 + !byte $0E,%01100011 + !byte $02,%01101101 + !byte $52,%10001100 + !byte $32,%01101000 + !byte $2E,%01100001 + !byte $20,%11001111 + !byte $40,%01110011 + !byte $4A,%01100011 + !byte $0A,%10100110 + !byte $20,%11001010 + !byte $40,%01101110 + !byte $54,%11000010 + !byte $1C,%01001000 + !byte $28,%00010001 + !byte $4A,%01110010 + !byte $32,%01100011 + !byte $1C,%01000011 + !byte $1E,%00001111 + !byte $36,%00001101 + !byte $44,%10000001 + !byte $10,%01001001 + !byte $1E,%00001010 + !byte $36,%00010010 + !byte $58,%01101001 + !byte $10,%01000100 + !byte $14,%10001011 + !byte $4E,%00001101 + !byte $44,%10000110 + !byte $2E,%01100110 + !byte $28,%00001100 + !byte $3E,%10010010 + !byte $58,%01100100 + !byte $04,%01001000 + !byte $10,%00010001 + !byte $3E,%10001101 + !byte $4E,%01000101 + !byte $18,%10101000 + !byte $06,%00101111 + !byte $4E,%00010010 + !byte $5C,%10000001 + !byte $18,%10100011 + !byte $06,%00101010 + !byte $46,%01001011 + !byte $4E,%01000000 + !byte $04,%01000011 + !byte $18,%10110010 + !byte $4A,%01101101 + !byte $38,%00100110 + !byte $06,%00100101 + !byte $2C,%10001011 + !byte $4E,%01001111 + !byte $5C,%10000110 + !byte $26,%01101000 + !byte $10,%00001100 + !byte $56,%10001101 + !byte $38,%00100001 + !byte $06,%00100000 + !byte $14,%10010000 + !byte $32,%01110010 + !byte $50,%00100110 + !byte $26,%01100011 + !byte $28,%00101110 + !byte $56,%10010010 + !byte $50,%00100001 + !byte $00,%10101000 + !byte $0A,%10101011 + !byte $4E,%01001010 + !byte $40,%01100100 + !byte $00,%10100011 + !byte $2C,%10010000 + !byte $56,%00110001 + !byte $52,%00000010 + !byte $1E,%00100101 + !byte $08,%11001100 + !byte $32,%01101101 + !byte $40,%01101001 + !byte $1E,%00100000 + !byte $1C,%01010010 + !byte $46,%01010000 + !byte $48,%10101000 + !byte $08,%00000110 + !byte $18,%10101101 + !byte $3C,%10110001 + !byte $36,%01100000 + !byte $08,%00000001 + !byte $00,%10110010 + !byte $5E,%01001011 + !byte $36,%01100101 + !byte $28,%00101001 + !byte $28,%00110011 + !byte $38,%00101011 + !byte $52,%00000111 + !byte $28,%00100100 + !byte $1C,%01001101 + !byte $38,%00110000 + !byte $3E,%10000011 + !byte $14,%10000001 + !byte $0A,%10110000 + !byte $50,%00110000 + !byte $3E,%10001000 + !byte $20,%00000110 + !byte $04,%01010010 + !byte $50,%00101011 + !byte $48,%10100011 + !byte $20,%00000001 + !byte $04,%01001101 + !byte $42,%10101011 + !byte $30,%10101000 + !byte $14,%10000110 + !byte $2A,%11001110 + !byte $5A,%10101011 + !byte $46,%01000001 + !byte $1A,%10001000 + !byte $10,%00101110 + !byte $42,%10110000 + !byte $30,%10100011 + !byte $2C,%10000001 + !byte $1E,%00101111 + !byte $5A,%10110000 + !byte $56,%10000011 + !byte $06,%01000101 + !byte $1E,%00101010 + !byte $56,%00101100 + !byte $34,%01001000 + !byte $2C,%10000110 + !byte $08,%11010001 + !byte $5E,%01010000 + !byte $4C,%01001000 + !byte $2A,%11000100 + !byte $2A,%11010011 + !byte $36,%01101111 + !byte $56,%10001000 + !byte $1A,%10000011 + !byte $10,%00110011 + !byte $58,%01001110 + !byte $4C,%01000011 + !byte $06,%01000000 + !byte $20,%11001100 + !byte $58,%01010011 + !byte $46,%01000110 + !byte $10,%00101001 + !byte $00,%10101101 + !byte $36,%01101010 + !byte $34,%01000011 + !byte $10,%00100100 + !byte $16,%01001011 + !byte $48,%10110010 + !byte $4E,%01100101 + !byte $02,%10001000 + !byte $08,%00010000 + !byte $3E,%00110001 + !byte $5E,%01000001 + !byte $28,%00000111 + !byte $08,%00001011 + !byte $48,%10101101 + !byte $38,%11000010 + !byte $2A,%11001001 + !byte $20,%11010001 + !byte $40,%01001110 + !byte $58,%01001001 + !byte $02,%10000011 + !byte $20,%00001011 + !byte $30,%10110010 + !byte $4E,%01100000 + !byte $28,%00000010 + !byte $06,%01001010 + !byte $40,%01010011 + !byte $5E,%01000110 + !byte $10,%00000111 + !byte $20,%00010000 + !byte $4E,%01101111 + !byte $58,%01000100 + !byte $16,%01000001 + !byte $06,%01001111 + !byte $4E,%01101010 + !byte $42,%10100001 + !byte $18,%11001000 + !byte $12,%11001110 + !byte $3C,%10101100 + !byte $5A,%10100110 + !byte $06,%00100011 + !byte $16,%01010000 + !byte $30,%10101101 + !byte $5A,%10100001 + !byte $1E,%01000101 + !byte $12,%11010011 + !byte $4C,%01010010 + !byte $42,%10100110 + !byte $1E,%00100011 + !byte $2E,%01001011 + !byte $52,%00001100 + !byte $38,%11000111 + !byte $1E,%01000000 + !byte $1A,%10010010 + !byte $44,%01101011 + !byte $40,%01000100 + !byte $12,%11000100 + !byte $1A,%10001101 + !byte $44,%01110000 + !byte $40,%01001001 + !byte $06,%00101000 + !byte $2E,%01010000 + !byte $52,%10010001 + !byte $4A,%10001000 + !byte $10,%00000010 + !byte $0E,%01001101 + !byte $4C,%01001101 + !byte $50,%11000010 + !byte $1E,%00101000 + !byte $0E,%01010010 + !byte $34,%01010010 + !byte $36,%10000000 + !byte $12,%11001001 + !byte $02,%10010010 + !byte $3E,%00101100 + !byte $36,%10000101 + !byte $18,%11000011 + !byte $1E,%01001111 + !byte $34,%01001101 + !byte $50,%01000110 + !byte $16,%01000110 + !byte $2A,%10110011 + !byte $5C,%01101011 + !byte $50,%01000001 + !byte $2E,%01000001 + !byte $2A,%10101110 + !byte $5C,%01110000 + !byte $4A,%10000011 + !byte $22,%11000001 + !byte $02,%10001101 + !byte $52,%00010001 + !byte $38,%01000001 + !byte $00,%11001000 + !byte $1E,%01001010 + !byte $5A,%11001110 + !byte $38,%01000110 + !byte $2E,%01000110 + !byte $12,%10101011 + !byte $5A,%11010011 + !byte $32,%10001000 + !byte $2A,%10100100 + !byte $2A,%10110000 + !byte $36,%10001111 + !byte $50,%11000111 + !byte $00,%11000011 + !byte $2A,%10101011 + !byte $46,%00101011 + !byte $32,%10000011 + !byte $2A,%10101001 + !byte $12,%10110000 + !byte $36,%10001010 + !byte $56,%00100111 + !byte $0E,%01001000 + !byte $28,%00010011 + !byte $4A,%10010010 + !byte $44,%01100001 + !byte $22,%11000110 + !byte $28,%00001110 + !byte $58,%00110011 + !byte $44,%01100110 + !byte $06,%01100000 + !byte $18,%11010010 + !byte $3E,%01110010 + !byte $3A,%00000010 + !byte $06,%01100101 + !byte $26,%01010010 + !byte $58,%00101110 + !byte $4E,%10000101 + !byte $28,%00001001 + !byte $18,%11001101 + !byte $3E,%01101101 + !byte $5A,%11000100 + !byte $28,%00000100 + !byte $26,%01001101 + !byte $46,%00110000 + !byte $48,%11001000 + !byte $0E,%01000011 + !byte $10,%00001110 + !byte $50,%01001011 + !byte $4E,%10000000 + !byte $08,%00100001 + !byte $10,%00010011 + !byte $50,%01010000 + !byte $5A,%11001001 + !byte $1C,%01101000 + !byte $00,%11010010 + !byte $4A,%10001101 + !byte $5C,%01100001 + !byte $20,%00100001 + !byte $12,%10101110 + !byte $38,%01010000 + !byte $5C,%01100110 + !byte $08,%00100110 + !byte $1E,%00101101 + !byte $5E,%00101011 + !byte $30,%11001000 + !byte $20,%00100110 + !byte $06,%00101101 + !byte $38,%01001011 + !byte $48,%11000011 + !byte $1C,%01100011 + !byte $06,%00110010 + !byte $32,%10010010 + !byte $3A,%00000111 + !byte $10,%00000100 + !byte $1E,%00110010 + !byte $5E,%00110000 + !byte $46,%00100001 + !byte $10,%00001001 + !byte $06,%01101010 + !byte $40,%00101110 + !byte $3C,%10100111 + !byte $04,%01101000 + !byte $12,%10110011 + !byte $40,%00110011 + !byte $58,%00101001 + !byte $1E,%01100101 + !byte $00,%11001101 + !byte $4E,%10001111 + !byte $58,%00100100 + !byte $04,%01100011 + !byte $06,%01101111 + !byte $32,%10001101 + !byte $42,%11000100 + !byte $2A,%10100110 + !byte $14,%01101011 + !byte $56,%01110010 + !byte $56,%00100010 + !byte $1E,%01100000 + !byte $14,%01110000 + !byte $4E,%10001010 + !byte $46,%00100110 + !byte $12,%10100001 + !byte $1E,%01101111 + !byte $42,%11001110 + !byte $30,%11000011 + !byte $12,%10100110 + !byte $2C,%01101011 + !byte $42,%11010011 + !byte $34,%00000101 + !byte $2A,%10100001 + !byte $22,%11001011 + !byte $56,%01101101 + !byte $34,%00000000 + !byte $12,%10100100 + !byte $08,%00101011 + !byte $58,%11010000 + !byte $3E,%01101000 + !byte $12,%10101001 + !byte $2C,%01110000 + !byte $38,%11001100 + !byte $40,%00100100 + !byte $26,%01001000 + !byte $08,%00110000 + !byte $48,%11010010 + !byte $3E,%00100111 + !byte $0A,%10100010 + !byte $2A,%10001110 + !byte $40,%11010000 + !byte $5E,%00100001 + !byte $1A,%10101000 + !byte $20,%00110000 + !byte $58,%11001011 + !byte $36,%00100011 + !byte $26,%01000011 + !byte $20,%00101011 + !byte $48,%11001101 + !byte $40,%00101001 + !byte $24,%01100111 + !byte $2A,%10010011 + !byte $38,%11010001 + !byte $3E,%01100011 + !byte $1A,%10100011 + !byte $16,%00101011 + !byte $40,%11001011 + !byte $36,%00101000 + !byte $0A,%11000001 + !byte $1C,%01110010 + !byte $34,%00001111 + !byte $4E,%00101000 + !byte $02,%10101000 + !byte $1E,%01101010 + !byte $5A,%10101110 + !byte $4E,%00100011 + !byte $14,%01100001 + !byte $22,%11010000 + !byte $30,%11010010 + !byte $5E,%00100110 + !byte $14,%01100110 + !byte $16,%00110000 + !byte $34,%00001010 + !byte $36,%10100000 + !byte $2A,%10000100 + !byte $1C,%01101101 + !byte $5A,%10110011 + !byte $42,%11001001 + !byte $18,%00001001 + !byte $04,%01110010 + !byte $50,%11001100 + !byte $56,%01101000 + !byte $0A,%11000110 + !byte $04,%01101101 + !byte $30,%11001101 + !byte $36,%10100101 + !byte $02,%10100011 + !byte $1A,%10110010 + !byte $42,%10001011 + !byte $4C,%00000101 + !byte $2C,%01100001 + !byte $2E,%00101011 + !byte $3A,%00001100 + !byte $56,%01100011 + !byte $2A,%10001001 + !byte $26,%00110001 + !byte $42,%10010000 + !byte $4C,%00000000 + !byte $16,%00100001 + !byte $24,%10010001 + !byte $4C,%00001111 + !byte $3E,%00100010 + !byte $18,%00000100 + !byte $12,%10001110 + !byte $5A,%10001011 + !byte $5A,%10101001 + !byte $06,%10000000 + !byte $2E,%00110000 + !byte $42,%10101110 + !byte $4E,%10100101 + !byte $2C,%01100110 + !byte $12,%10010011 + !byte $36,%10101111 + !byte $5A,%10100100 + !byte $06,%10000101 + !byte $1A,%10101101 + !byte $5A,%10010000 + !byte $4C,%01101000 + !byte $00,%00001001 + !byte $28,%11001101 + !byte $4C,%00001010 + !byte $58,%11000110 + !byte $16,%00100110 + !byte $10,%11001101 + !byte $36,%10101010 + !byte $4E,%10100000 + !byte $0A,%10100111 + !byte $02,%10110010 + !byte $50,%11010001 + !byte $4C,%01100011 + !byte $12,%10000100 + !byte $18,%00010011 + !byte $42,%10110011 + !byte $34,%01101000 + !byte $00,%00000100 + !byte $06,%10001010 + !byte $58,%00010011 + !byte $3C,%10100010 + !byte $2E,%00100001 + !byte $06,%10001111 + !byte $58,%00001110 + !byte $58,%11000001 + !byte $1E,%10000101 + !byte $28,%11010010 + !byte $44,%01001011 + !byte $4A,%10101000 + !byte $1E,%10000000 + !byte $02,%10101101 + !byte $36,%00101101 + !byte $34,%00100101 + !byte $12,%10001001 + !byte $10,%11010010 + !byte $44,%01010000 + !byte $34,%01100011 + !byte $04,%00000101 + !byte $18,%00001110 + !byte $4E,%10101111 + !byte $40,%11000110 + !byte $2E,%00100110 + !byte $00,%00010011 + !byte $4E,%10101010 + !byte $34,%00100000 + !byte $04,%00000000 + !byte $26,%00101100 + !byte $36,%00110010 + !byte $4A,%10100011 + !byte $28,%11000011 + !byte $0A,%11001011 + !byte $4E,%00101101 + !byte $42,%10100100 + !byte $28,%11001000 + !byte $1E,%10001111 + !byte $46,%00001011 + !byte $48,%00001001 + !byte $10,%11000011 + !byte $1E,%10001010 + !byte $40,%00001110 + !byte $40,%11000001 + !byte $10,%11001000 + !byte $00,%00001110 + !byte $3A,%00010001 + !byte $42,%10101001 + !byte $20,%01000110 + !byte $2A,%01101110 + !byte $5C,%01001011 + !byte $50,%01100110 + !byte $20,%01000001 + !byte $04,%00001111 + !byte $40,%00010011 + !byte $50,%01100001 + !byte $08,%00000011 + !byte $04,%00001010 + !byte $4E,%00110010 + !byte $32,%10101000 + !byte $22,%10100010 + !byte $2A,%01110011 + !byte $5C,%01010000 + !byte $42,%10000001 + !byte $1C,%00000101 + !byte $0A,%11010000 + !byte $46,%00010000 + !byte $58,%00001001 + !byte $18,%00101001 + !byte $12,%01101110 + !byte $34,%00101111 + !byte $38,%01100001 + !byte $2A,%01100100 + !byte $0E,%00110010 + !byte $34,%00101010 + !byte $5A,%10000110 + !byte $08,%01000001 + !byte $16,%00001011 + !byte $4C,%01110010 + !byte $48,%00000100 + !byte $08,%01000110 + !byte $0E,%00110001 + !byte $4C,%01101101 + !byte $32,%10100011 + !byte $1C,%00000000 + !byte $0E,%00101101 + !byte $5A,%10001110 + !byte $42,%10000110 + !byte $2A,%01101001 + !byte $28,%11010000 + !byte $34,%01101101 + !byte $58,%00000100 + !byte $1A,%11001000 + !byte $28,%11001011 + !byte $34,%01110010 + !byte $38,%01100110 + !byte $08,%00001000 + !byte $12,%01110011 + !byte $5E,%00001011 + !byte $4C,%00100101 + !byte $20,%00000011 + !byte $14,%01001011 + !byte $4A,%10110010 + !byte $5A,%10000001 + !byte $1C,%10001000 + !byte $1C,%00001111 + !byte $5A,%10010011 + !byte $30,%00001001 + !byte $06,%01000011 + !byte $1C,%00001010 + !byte $5E,%00010000 + !byte $44,%01000001 + !byte $06,%10100101 + !byte $10,%11010000 + !byte $4A,%10101101 + !byte $4C,%00100000 + !byte $1E,%01000011 + !byte $20,%01010000 + !byte $32,%10110010 + !byte $44,%01000110 + !byte $06,%01001000 + !byte $20,%01001011 + !byte $48,%00010011 + !byte $40,%00001001 + !byte $06,%10100000 + !byte $2A,%10001011 + !byte $4C,%00101111 + !byte $40,%00000100 + !byte $12,%01100100 + !byte $12,%10001011 + !byte $32,%10101101 + !byte $46,%00000001 + !byte $1E,%01001000 + !byte $2A,%10010000 + !byte $50,%01101011 + !byte $5C,%01000001 + !byte $12,%01101001 + !byte $12,%10010000 + !byte $48,%00001110 + !byte $30,%00000100 + !byte $1C,%10000011 + !byte $08,%01001011 + !byte $42,%10001110 + !byte $46,%00000110 + !byte $04,%00100101 + !byte $08,%01010000 + !byte $54,%10110001 + !byte $5C,%01000110 + !byte $04,%10000011 + !byte $2C,%01001011 + !byte $30,%00010011 + !byte $5A,%10000100 + !byte $04,%10001000 + !byte $10,%11001011 + !byte $42,%10010011 + !byte $5A,%10001001 + !byte $20,%00001000 + !byte $14,%01010000 + !byte $50,%01110000 + !byte $36,%11000101 + !byte $04,%00100000 + !byte $2C,%01010000 + !byte $4C,%00101010 + !byte $5E,%00000001 + !byte $1A,%11000011 + !byte $18,%00110011 + !byte $38,%01101011 + !byte $36,%11000000 + !byte $02,%11001000 + !byte $2E,%00001011 + !byte $38,%01110000 + !byte $5E,%00000110 + !byte $1E,%10100000 + !byte $0E,%00101100 + !byte $30,%00001110 + !byte $34,%01000101 + !byte $1E,%10100101 + !byte $0A,%10101100 + !byte $3E,%01010010 + !byte $42,%10000100 + !byte $00,%00101001 + !byte $16,%00010000 + !byte $3E,%01001101 + !byte $34,%01000000 + !byte $02,%11000011 + !byte $06,%10101111 + !byte $36,%11001111 + !byte $4E,%11000101 + !byte $18,%00100100 + !byte $18,%00101110 + !byte $36,%11001010 + !byte $4E,%11000000 + !byte $16,%00000001 + !byte $06,%10101010 + !byte $34,%01001111 + !byte $42,%10001001 + !byte $16,%00000110 + !byte $2E,%00010000 + !byte $34,%01001010 + !byte $4C,%01000101 + !byte $22,%10100111 + !byte $2C,%11001110 + !byte $4E,%11001111 + !byte $48,%00101001 + !byte $0E,%00101000 + !byte $1A,%11010010 + !byte $5A,%01101110 + !byte $4C,%01000000 + !byte $00,%00100100 + !byte $04,%00101111 + !byte $4E,%11001010 + !byte $3E,%01001000 + !byte $26,%00100111 + !byte $1A,%11001101 + !byte $56,%01010010 + !byte $48,%00100100 + !byte $2E,%00000001 + !byte $04,%00101010 + !byte $58,%11001101 + !byte $4A,%11001000 + !byte $14,%01000001 + !byte $00,%00110011 + !byte $58,%11010010 + !byte $3E,%01000011 + !byte $14,%01000110 + !byte $08,%00001101 + !byte $46,%11001010 + !byte $30,%00101001 + !byte $1C,%00100101 + !byte $26,%00110010 + !byte $40,%11001101 + !byte $4A,%11000011 + !byte $28,%11000110 + !byte $2A,%01001110 + !byte $4C,%01001111 + !byte $5A,%01100100 + !byte $2C,%01000001 + !byte $02,%11010010 + !byte $56,%01001101 + !byte $30,%00100100 + !byte $12,%10000001 + !byte $1C,%10010010 + !byte $40,%11010010 + !byte $5A,%01101001 + !byte $12,%10000110 + !byte $1C,%10001101 + !byte $5A,%01110011 + !byte $52,%00100010 + !byte $1C,%00100000 + !byte $1E,%10101111 + !byte $4C,%01001010 + !byte $46,%11000000 + !byte $2A,%10000110 + !byte $1E,%10101010 + !byte $46,%11001111 + !byte $32,%11001000 + !byte $2A,%10000001 + !byte $10,%10101101 + !byte $54,%10101100 + !byte $40,%11000011 + !byte $0E,%00100011 + !byte $04,%10010010 + !byte $44,%00101011 + !byte $58,%11001000 + !byte $28,%11000001 + !byte $06,%01001101 + !byte $48,%00110011 + !byte $32,%11000011 + !byte $2C,%01000110 + !byte $10,%10110010 + !byte $5E,%11001010 + !byte $58,%11000011 + !byte $2C,%11000100 + !byte $28,%10110010 + !byte $5E,%11001111 + !byte $40,%11001000 + !byte $10,%11000110 + !byte $28,%10101101 + !byte $44,%00110000 + !byte $4C,%10001000 + !byte $2C,%11001001 + !byte $1E,%01001101 + !byte $42,%01101110 + !byte $46,%11000101 + !byte $26,%00100010 + !byte $06,%01010010 + !byte $5C,%00101011 + !byte $4C,%10000011 + !byte $2E,%00000110 + !byte $1E,%01010010 + !byte $42,%01110011 + !byte $34,%10001000 + !byte $10,%11000001 + !byte $04,%10001101 + !byte $48,%00101110 + !byte $56,%01001000 + !byte $10,%10100011 + !byte $2A,%01010011 + !byte $5C,%00110000 + !byte $34,%01100101 + !byte $2A,%01000100 + !byte $26,%00101101 + !byte $42,%01110000 + !byte $42,%01100100 + !byte $10,%10101000 + !byte $1C,%00101111 + !byte $4A,%11010010 + !byte $34,%10000011 + !byte $2A,%01001001 + !byte $08,%00010010 + !byte $42,%01101011 + !byte $34,%01100000 + !byte $28,%10100011 + !byte $02,%11001101 + !byte $5A,%01101011 + !byte $4C,%01100101 + !byte $28,%10101000 + !byte $2C,%11010011 + !byte $30,%00110011 + !byte $5E,%11000000 + !byte $12,%01000100 + !byte $24,%10001100 + !byte $5A,%01110000 + !byte $44,%00100001 + !byte $04,%01000101 + !byte $1C,%00101010 + !byte $4A,%11001101 + !byte $42,%01101001 + !byte $22,%00000010 + !byte $12,%01001110 + !byte $30,%00101110 + !byte $56,%01000011 + !byte $04,%01000000 + !byte $20,%00001101 + !byte $32,%11010010 + !byte $44,%00100110 + !byte $18,%01001001 + !byte $00,%00101110 + !byte $58,%10110000 + !byte $5E,%11000101 + !byte $26,%00101000 + !byte $12,%01010011 + !byte $34,%01101111 + !byte $36,%01000011 + !byte $12,%01001001 + !byte $0A,%10110001 + !byte $58,%10101011 + !byte $36,%00000001 + !byte $14,%11000100 + !byte $14,%11001110 + !byte $4C,%10010010 + !byte $36,%00000110 + !byte $1C,%01000101 + !byte $20,%00010010 + !byte $5C,%11001110 + !byte $36,%01001000 + !byte $06,%11000101 + !byte $14,%11010011 + !byte $34,%01101010 + !byte $4E,%00000110 + !byte $18,%01000100 + !byte $16,%11001010 + !byte $4C,%10001101 + !byte $50,%10000001 + !byte $06,%11000000 + !byte $04,%01001111 + !byte $32,%11001101 + !byte $4E,%01001000 + !byte $14,%11001001 + !byte $18,%01010011 + !byte $5C,%11010011 + !byte $4E,%01000011 + !byte $0E,%00100111 + !byte $04,%01001010 + !byte $40,%10110000 + !byte $5C,%00100001 + !byte $20,%01100001 + !byte $2C,%10101110 + !byte $34,%10010010 + !byte $38,%00000011 + !byte $1E,%11000101 + !byte $18,%01001110 + !byte $56,%00010001 + !byte $5C,%00100110 + !byte $26,%00100011 + !byte $2C,%10110011 + !byte $40,%10101011 + !byte $42,%01100001 + !byte $1A,%00001001 + !byte $16,%11001111 + !byte $4C,%01101010 + !byte $50,%10000110 + !byte $08,%01100001 + !byte $2E,%11001010 + !byte $34,%10001101 + !byte $4E,%00000001 + !byte $00,%01001001 + !byte $1C,%01001010 + !byte $4C,%01101111 + !byte $42,%01100110 + !byte $1E,%11000000 + !byte $1C,%01001111 + !byte $36,%00010000 + !byte $38,%10000001 + !byte $20,%01100110 + !byte $22,%10101100 + !byte $5A,%01010011 + !byte $4C,%01100000 + !byte $00,%01000100 + !byte $06,%11001010 + !byte $5A,%01001110 + !byte $52,%00100111 + !byte $08,%01100110 + !byte $06,%11001111 + !byte $36,%00001011 + !byte $5A,%01100110 + !byte $16,%11000000 + !byte $2E,%11001111 + !byte $4E,%00010000 + !byte $38,%10000110 + !byte $1A,%00000100 + !byte $14,%00101011 + !byte $4E,%00001011 + !byte $5C,%11001001 + !byte $1C,%01000000 + !byte $1A,%00010011 + !byte $44,%11001110 + !byte $5A,%01100001 + !byte $22,%00000111 + !byte $1E,%11001111 + !byte $50,%10001011 + !byte $38,%00001000 + !byte $02,%00001001 + !byte $1E,%11001010 + !byte $36,%01001101 + !byte $5C,%11000100 + !byte $02,%00000100 + !byte $00,%01010011 + !byte $44,%11010011 + !byte $48,%01001001 + !byte $2C,%10100100 + !byte $2A,%00101110 + !byte $46,%10101010 + !byte $54,%10100111 + !byte $16,%11000101 + !byte $14,%00110000 + !byte $36,%01010010 + !byte $32,%00000101 + !byte $1C,%10101000 + !byte $2A,%00110011 + !byte $50,%10010000 + !byte $32,%00000000 + !byte $1C,%10100011 + !byte $00,%01001110 + !byte $56,%00001100 + !byte $48,%01000100 + !byte $0E,%00100010 + !byte $2C,%00110000 + !byte $4E,%01010010 + !byte $58,%10100110 + !byte $2C,%10101001 + !byte $2C,%00101011 + !byte $4E,%01001101 + !byte $5A,%01000100 + !byte $2E,%11000000 + !byte $14,%10101110 + !byte $46,%10101111 + !byte $44,%11000100 + !byte $04,%10101000 + !byte $20,%01101011 + !byte $42,%01001110 + !byte $50,%00000011 + !byte $04,%10100011 + !byte $20,%01110000 + !byte $42,%01010011 + !byte $30,%01001001 + !byte $14,%00100001 + !byte $1A,%00001110 + !byte $48,%01010011 + !byte $44,%11001001 + !byte $2E,%11000101 + !byte $14,%10110011 + !byte $32,%00001111 + !byte $58,%10100001 + !byte $14,%10100100 + !byte $02,%00010011 + !byte $5E,%10101010 + !byte $5A,%01001001 + !byte $04,%01100101 + !byte $12,%00101110 + !byte $32,%00001010 + !byte $46,%10100000 + !byte $14,%00100110 + !byte $08,%01101011 + !byte $48,%01001110 + !byte $40,%10100110 + !byte $04,%01100000 + !byte $12,%00110011 + !byte $40,%10110010 + !byte $4A,%00001001 + !byte $2A,%00100100 + !byte $02,%00001110 + !byte $58,%10110010 + !byte $34,%10000101 + !byte $14,%10101001 + !byte $22,%00001100 + !byte $58,%10101101 + !byte $30,%01000100 + !byte $2A,%00101001 + !byte $08,%01110000 + !byte $5E,%10101111 + !byte $40,%10100001 + !byte $2C,%00100001 + !byte $1C,%10110010 + !byte $40,%10101101 + !byte $4A,%00000101 + !byte $18,%01101001 + !byte $12,%01101011 + !byte $38,%10001011 + !byte $42,%01000100 + !byte $0A,%00000010 + !byte $12,%01110000 + !byte $3E,%00010001 + !byte $50,%00001000 + !byte $12,%00100100 + !byte $2A,%01110000 + !byte $38,%10010000 + !byte $4A,%00000100 + !byte $12,%00101001 + !byte $10,%10010010 + !byte $30,%01010011 + !byte $34,%10000000 + !byte $2C,%00100110 + !byte $2A,%01101011 + !byte $5C,%10101110 + !byte $42,%01001001 + !byte $06,%01100011 + !byte $1C,%10101101 + !byte $44,%00001011 + !byte $4A,%00000000 + !byte $06,%01101000 + !byte $28,%10010010 + !byte $52,%00101100 + !byte $46,%10100101 + !byte $1C,%01100101 + !byte $10,%10001101 + !byte $44,%00010000 + !byte $32,%00001001 + !byte $1E,%01100011 + !byte $22,%10110001 + !byte $4A,%00001111 + !byte $32,%00000100 + !byte $1E,%01101000 + !byte $04,%10110010 + !byte $5C,%10110011 + !byte $4C,%10000101 + !byte $24,%01100010 + !byte $04,%01101111 + !byte $30,%01001110 + !byte $5E,%10100000 + !byte $1C,%01100000 + !byte $28,%10001101 + !byte $5C,%00001011 + !byte $4C,%10000000 + !byte $18,%01100100 + !byte $04,%10101101 + !byte $4A,%00010011 + !byte $5E,%10100101 + !byte $02,%00000101 + !byte $04,%01101010 + !byte $34,%10001111 + !byte $5C,%10100100 + !byte $00,%01101001 + !byte $2C,%10001110 + !byte $4A,%00001010 + !byte $3A,%10100010 + !byte $06,%00000001 + !byte $22,%00010001 + !byte $34,%10001010 + !byte $40,%10101000 + !byte $06,%00000110 + !byte $16,%10101010 + !byte $38,%00001101 + !byte $58,%10101000 + !byte $00,%01100100 + !byte $2C,%10010011 + !byte $5C,%00010000 + !byte $40,%10100011 + !byte $12,%01100001 + !byte $18,%01110011 + !byte $4A,%00001110 + !byte $58,%10100011 + !byte $0A,%00000111 + !byte $1C,%01101111 + !byte $3E,%00110010 + !byte $44,%00000001 + !byte $1A,%00101001 + !byte $18,%01101110 + !byte $3E,%00001100 + !byte $32,%00100000 + !byte $2C,%10000100 + !byte $1C,%01101010 + !byte $44,%10101110 + !byte $32,%00100101 + !byte $02,%00000000 + !byte $16,%10101111 + !byte $38,%00010010 + !byte $5C,%10101001 + !byte $10,%10001000 + !byte $14,%10001110 + !byte $4C,%10001111 + !byte $44,%00000110 + !byte $2A,%01100110 + !byte $14,%10010011 + !byte $32,%00010011 + !byte $4C,%10101000 + !byte $2A,%01100001 + !byte $2E,%10101010 + !byte $44,%10110011 + !byte $54,%10100010 + !byte $12,%01100110 + !byte $00,%01110011 + !byte $4C,%10001010 + !byte $36,%00100110 + !byte $1E,%00000110 + !byte $06,%01101101 + !byte $3E,%00101101 + !byte $56,%00000111 + !byte $1E,%00000001 + !byte $02,%00001111 + !byte $32,%00001110 + !byte $36,%00100001 + !byte $10,%10000011 + !byte $28,%10110000 + !byte $5A,%00110011 + !byte $4C,%10100011 + !byte $2C,%10001001 + !byte $1E,%01101101 + !byte $5A,%00101110 + !byte $4E,%00100110 + !byte $1A,%00100100 + !byte $02,%00001010 + !byte $42,%01001011 + !byte $34,%10101000 + !byte $16,%10100000 + !byte $0E,%00010010 + !byte $32,%00101111 + !byte $48,%01101001 + !byte $28,%10001000 + !byte $28,%10101011 + !byte $52,%00110001 + !byte $4E,%00100001 + !byte $28,%10000011 + !byte $1E,%01110010 + !byte $42,%01010000 + !byte $3A,%00100010 + !byte $02,%00100100 + !byte $00,%01101110 + !byte $5A,%01010000 + !byte $5C,%00000001 + !byte $02,%00101001 + !byte $06,%01110010 + !byte $50,%00001101 + !byte $34,%10100011 + !byte $1A,%00000101 + !byte $2E,%10101111 + !byte $32,%00101010 + !byte $5C,%00000110 + !byte $16,%10100101 + !byte $06,%00001011 + !byte $48,%01110011 + !byte $44,%10100100 + !byte $14,%10000100 + !byte $06,%00010000 + !byte $5A,%01001011 + !byte $44,%10101001 + !byte $1A,%00000000 + !byte $1A,%00110011 + !byte $46,%10001010 + !byte $4A,%00100101 + !byte $08,%00100011 + !byte $1E,%00001011 + !byte $4C,%10110010 + !byte $48,%01100100 + !byte $14,%10001001 + !byte $1A,%00101110 + !byte $46,%10001111 + !byte $56,%00000010 + !byte $2E,%10100000 + !byte $1E,%00010000 + !byte $42,%00101110 + !byte $30,%01101001 + !byte $04,%10000101 + !byte $2A,%00001110 + !byte $42,%00110011 + !byte $4A,%00100000 + !byte $24,%10000111 + !byte $14,%00001011 + !byte $56,%00110010 + !byte $30,%01100100 + !byte $08,%00101000 + !byte $10,%10110000 + !byte $36,%00110000 + !byte $46,%10000101 + !byte $04,%10000000 + !byte $0E,%00001101 + !byte $4C,%10101101 + !byte $5A,%00100100 + !byte $2E,%10100101 + !byte $2A,%00010011 + !byte $50,%00010010 + !byte $46,%10000000 + !byte $18,%10001001 + !byte $1A,%00001111 + !byte $36,%00101011 + !byte $34,%10100101 + !byte $18,%10000100 + !byte $10,%10101011 + !byte $4E,%00101011 + !byte $5A,%00101001 + !byte $1C,%11000011 + !byte $1A,%00001010 + !byte $34,%10110010 + !byte $34,%10100000 + !byte $1C,%11001000 + !byte $14,%00010000 + !byte $4E,%00110000 + !byte $3A,%10100111 + !byte $20,%10000001 + !byte $12,%00001110 + !byte $48,%01101110 + !byte $42,%01000001 + !byte $1C,%10000101 + !byte $02,%00110011 + !byte $34,%10101101 + !byte $3E,%00101000 + !byte $02,%00100101 + !byte $2C,%00001011 + !byte $5E,%10001010 + !byte $42,%01000110 + !byte $04,%11001000 + !byte $02,%00101110 + !byte $5C,%10001110 + !byte $42,%00100100 + !byte $20,%00100011 + !byte $12,%00010011 + !byte $4A,%00101111 + !byte $4A,%00101001 + !byte $20,%10000110 + !byte $2C,%00010000 + !byte $54,%01010001 + !byte $5A,%01000001 + !byte $2A,%00000100 + !byte $0A,%00001100 + !byte $4A,%00101010 + !byte $3A,%00100111 + !byte $14,%00000001 + !byte $04,%10001111 + !byte $56,%00101101 + !byte $5A,%01000110 + !byte $2A,%00001001 + !byte $18,%10010011 + !byte $5C,%10010011 + !byte $42,%00101001 + !byte $1C,%10000000 + !byte $04,%10001010 + !byte $5E,%10001111 + !byte $3E,%00000111 + !byte $04,%11000011 + !byte $2C,%01110011 + !byte $30,%01110011 + !byte $3E,%00100011 + !byte $28,%10100110 + !byte $2C,%01101110 + !byte $30,%01101110 + !byte $4C,%10100101 + !byte $02,%00100000 + !byte $1C,%10001111 + !byte $44,%10001110 + !byte $4A,%00100100 + !byte $12,%00000100 + !byte $02,%00101111 + !byte $34,%10101111 + !byte $5E,%10000000 + !byte $14,%00000110 + !byte $1C,%11010010 + !byte $44,%11001010 + !byte $4C,%10100000 + !byte $00,%10001001 + !byte $18,%10001110 + !byte $44,%10010011 + !byte $36,%01100011 + !byte $12,%00001001 + !byte $16,%10001010 + !byte $34,%10101010 + !byte $5C,%10000100 + !byte $20,%00101000 + !byte $1C,%10001010 + !byte $4A,%00110011 + !byte $5E,%10000101 + !byte $28,%10100001 + !byte $26,%00010010 + !byte $44,%11001111 + !byte $36,%01101000 + !byte $08,%10000001 + !byte $14,%01101110 + !byte $4C,%10101111 + !byte $5C,%10001001 + !byte $00,%10000100 + !byte $00,%10010011 + !byte $58,%10010000 + !byte $50,%10100001 + !byte $08,%10000110 + !byte $02,%00101010 + !byte $5C,%11001010 + !byte $32,%01000000 + !byte $10,%10100110 + !byte $0A,%00010001 + !byte $4A,%00101110 + !byte $32,%01000101 + !byte $2C,%00000001 + !byte $2E,%11001110 + !byte $40,%10010010 + !byte $4E,%01100011 + !byte $2C,%00000110 + !byte $08,%00101101 + !byte $4C,%10101010 + !byte $4E,%01101000 + !byte $0E,%00001000 + !byte $16,%10001111 + !byte $58,%10010010 + !byte $3E,%00000010 + !byte $2C,%01100100 + !byte $1C,%11001101 + !byte $58,%10001011 + !byte $32,%00100100 + !byte $1A,%00100101 + !byte $14,%01110011 + !byte $40,%10001101 + !byte $32,%00101001 + !byte $10,%10100001 + !byte $04,%11010010 + !byte $32,%01001111 + !byte $50,%10100110 + !byte $2C,%01101001 + !byte $2E,%11010011 + !byte $5C,%11001111 + !byte $44,%10000100 + !byte $1A,%00100000 + !byte $04,%11001101 + !byte $58,%10001101 + !byte $48,%10001001 + !byte $1A,%01001001 + !byte $1A,%00101111 + !byte $32,%01001010 + !byte $44,%10001001 + !byte $1A,%01000100 + !byte $20,%10001011 + !byte $32,%00110011 + !byte $44,%11000000 + !byte $2E,%11000100 + !byte $08,%00110010 + !byte $32,%00101110 + !byte $56,%00101000 + !byte $16,%10000000 + !byte $2E,%10001010 + !byte $40,%10010000 + !byte $4A,%01000101 + !byte $14,%01100100 + !byte $26,%00001101 + !byte $40,%10001011 + !byte $4A,%01000000 + !byte $16,%10000101 + !byte $00,%10001110 + !byte $36,%01101101 + !byte $48,%10000100 + !byte $2E,%11001001 + !byte $2E,%10001111 + !byte $4A,%01001111 + !byte $44,%11000101 + !byte $0E,%00000011 + !byte $0C,%01101100 + !byte $4E,%01101101 + !byte $38,%10100001 + !byte $14,%01101001 + !byte $20,%10010000 + !byte $36,%01110010 + !byte $56,%00100011 + !byte $06,%00100001 + !byte $12,%01010000 + !byte $48,%10010011 + !byte $5C,%11000000 + !byte $06,%00100110 + !byte $16,%11001110 + !byte $5A,%00001110 + !byte $30,%10001001 + !byte $1E,%00100001 + !byte $2A,%01010000 + !byte $46,%01101010 + !byte $5C,%11000101 + !byte $02,%01001001 + !byte $1A,%00101010 + !byte $46,%01101111 + !byte $30,%10000100 + !byte $1E,%00100110 + !byte $12,%01001011 + !byte $4A,%01001010 + !byte $38,%10100110 + !byte $02,%01000100 + !byte $2A,%01001011 + !byte $5A,%00010011 + !byte $40,%10001000 + !byte $2E,%10000000 + !byte $10,%01110010 + !byte $48,%10001110 + !byte $4C,%11001000 + !byte $18,%10101001 + !byte $1A,%01010011 + !byte $4E,%01110010 + !byte $40,%10000011 + !byte $18,%10100100 + !byte $20,%00101101 + !byte $5E,%01101010 + !byte $46,%01100000 + !byte $04,%10100101 + !byte $10,%01101101 + !byte $50,%10101011 + !byte $58,%10001000 + !byte $16,%11000100 + !byte $08,%10001011 + !byte $5C,%01101110 + !byte $4C,%11000011 + !byte $2E,%10000101 + !byte $16,%11010011 + !byte $42,%00001110 + !byte $46,%01100101 + !byte $06,%10000011 + !byte $20,%00110010 + !byte $42,%00010011 + !byte $34,%11001000 + !byte $04,%10100000 + !byte $28,%01110010 + !byte $5C,%01110011 + !byte $36,%01000001 + !byte $06,%10001000 + !byte $1A,%01001110 + !byte $5E,%01101111 + !byte $58,%10000110 + !byte $16,%11001001 + !byte $26,%00010001 + !byte $3A,%00101100 + !byte $4E,%01000001 + !byte $1E,%10000011 + !byte $28,%01101101 + !byte $5E,%11001110 + !byte $34,%11000011 + !byte $02,%01000101 + !byte $08,%10010000 + !byte $30,%10010011 + !byte $36,%01000110 + !byte $1E,%10001000 + !byte $02,%01010011 + !byte $50,%10110000 + !byte $4E,%01000110 + !byte $02,%01000000 + !byte $02,%01001110 + !byte $30,%10001110 + !byte $58,%10000011 + !byte $12,%01000110 + !byte $18,%10110011 + !byte $5E,%11010011 + !byte $58,%10000001 + !byte $1C,%10100101 + !byte $1E,%00110000 + !byte $54,%01001100 + !byte $5A,%00000100 + !byte $12,%01000001 + !byte $2A,%11001101 + !byte $3A,%10101100 + !byte $5A,%00001001 + !byte $00,%10101001 + !byte $06,%00101011 + !byte $42,%00110000 + !byte $34,%11000101 + !byte $2A,%01000001 + !byte $2A,%11010010 + !byte $44,%01101110 + !byte $34,%11000000 + !byte $2A,%01000110 + !byte $1E,%00101011 + !byte $44,%01110011 + !byte $40,%10000110 + !byte $1C,%10100000 + !byte $06,%00110000 + !byte $5A,%00101011 + !byte $40,%10000001 + !byte $10,%01101000 + !byte $14,%11001010 + !byte $42,%00101011 + !byte $32,%01100101 + !byte $00,%10100100 + !byte $18,%10101110 + !byte $30,%00001111 + !byte $4A,%01001001 + !byte $1A,%01000000 + !byte $14,%11001111 + !byte $5A,%00110000 + !byte $5E,%01100000 + !byte $1A,%01000101 + !byte $12,%11001101 + !byte $4C,%11001101 + !byte $5C,%01101001 + !byte $2E,%10100100 + !byte $04,%10101111 + !byte $4C,%11010010 + !byte $5C,%01100100 + !byte $26,%00001000 + !byte $2C,%01001110 + !byte $46,%11001110 + !byte $42,%00000100 + !byte $10,%01100011 + !byte $04,%10101010 + !byte $32,%01101111 + !byte $5E,%01100101 + !byte $1C,%00001001 + !byte $2C,%01010011 + !byte $34,%11010010 + !byte $32,%01100000 + !byte $14,%11000000 + !byte $26,%00001100 + !byte $4E,%01010000 + !byte $4C,%11000101 + !byte $1C,%00000100 + !byte $12,%11010010 + !byte $38,%10101011 + !byte $52,%10100010 + !byte $2C,%01000100 + !byte $02,%01001111 + !byte $46,%11010011 + !byte $5E,%11000100 + !byte $14,%11000101 + !byte $2C,%11001111 + !byte $4E,%01001011 + !byte $42,%00001001 + !byte $28,%01101000 + !byte $2E,%10101110 + !byte $34,%11001101 + !byte $30,%00000101 + !byte $04,%00001001 + !byte $02,%01001010 + !byte $34,%11001111 + !byte $4C,%11000000 + !byte $2A,%11000011 + !byte $2E,%10110011 + !byte $44,%10101010 + !byte $5E,%11001001 + !byte $04,%00000100 + !byte $1C,%10101111 + !byte $36,%01001011 + !byte $4A,%01000100 + !byte $12,%11001000 + !byte $2C,%11001010 + !byte $4A,%01010011 + !byte $30,%00000000 + !byte $2A,%11001000 + !byte $16,%01101010 + !byte $36,%01010000 + !byte $44,%01100100 + !byte $12,%11000011 + !byte $00,%10110011 + !byte $34,%11001010 + !byte $32,%01001001 + !byte $1A,%01101001 + !byte $06,%10001101 + !byte $44,%10101111 + !byte $48,%10101001 + !byte $28,%01100011 + !byte $1C,%10101010 + !byte $4A,%01001110 + !byte $32,%01000100 + !byte $16,%01100000 + !byte $14,%01001110 + !byte $38,%10110000 + !byte $44,%01101001 + !byte $2C,%01001001 + !byte $1E,%10010010 + !byte $4C,%11001111 + !byte $4A,%01100101 + !byte $2C,%11000000 + !byte $1E,%10001101 + !byte $32,%01101010 + !byte $46,%11000100 + !byte $26,%00000011 + !byte $06,%10010010 + !byte $4C,%11001010 + !byte $4A,%01100000 + !byte $1A,%01100100 + !byte $1A,%01001111 + !byte $3A,%00110001 + !byte $48,%00000101 + !byte $2C,%11000101 + !byte $16,%01101111 + !byte $48,%10110011 + !byte $48,%10100100 + !byte $16,%01100101 + !byte $00,%10101110 + !byte $5C,%10101010 + !byte $42,%00100001 + !byte $14,%01000100 + !byte $14,%01010011 + !byte $46,%01001010 + !byte $38,%00100011 + !byte $14,%01001001 + !byte $16,%10101110 + !byte $32,%01010011 + !byte $42,%00100110 + !byte $2E,%10101001 + !byte $1A,%01001010 + !byte $48,%10101110 + !byte $5A,%00100110 + !byte $0A,%11000010 + !byte $16,%10110011 + !byte $30,%00001010 + !byte $46,%11001001 + !byte $18,%11001001 + !byte $2E,%01101111 + !byte $4A,%01101010 + !byte $5A,%00100001 + !byte $16,%10100100 + !byte $2E,%01101010 + !byte $46,%01001111 + !byte $48,%00000000 + !byte $02,%01101001 + !byte $1C,%00010011 + !byte $4A,%01101111 + !byte $30,%10101001 + !byte $18,%11000100 + !byte $1C,%00001110 + !byte $5C,%10101111 + !byte $44,%10100000 + !byte $16,%10101001 + !byte $1A,%01110011 + !byte $48,%00001111 + !byte $30,%10100100 + !byte $2E,%01100000 + !byte $04,%00001110 + !byte $32,%01001110 + !byte $38,%00101000 + !byte $02,%01100100 + !byte $04,%00010011 + !byte $48,%00001010 + !byte $44,%10100101 + !byte $00,%00000101 + !byte $0E,%00010001 + !byte $3A,%10110001 + !byte $46,%01000000 + !byte $2E,%01100101 + !byte $1A,%01101110 + !byte $5E,%01001010 + !byte $46,%01000101 + !byte $00,%00000000 + !byte $18,%11010011 + !byte $5E,%01001111 + !byte $5C,%10100000 + !byte $02,%01100101 + !byte $28,%10010000 + !byte $5E,%10101110 + !byte $5C,%10100101 + !byte $00,%11001001 + !byte $18,%11001110 + !byte $5E,%10110011 + !byte $52,%10100111 + !byte $26,%00000111 + !byte $28,%10001011 + !byte $30,%10110011 + !byte $50,%00100011 + !byte $02,%01100000 + !byte $02,%01110011 + !byte $5C,%01001110 + !byte $36,%10000011 + !byte $04,%11000101 + !byte $02,%01101110 + !byte $30,%10101110 + !byte $30,%00100101 + !byte $18,%00000000 + !byte $00,%00001111 + !byte $5C,%01010011 + !byte $5E,%01000000 + !byte $00,%11000100 + !byte $0E,%00001100 + !byte $46,%10110011 + !byte $5E,%10100100 + !byte $18,%00000101 + !byte $00,%00001010 + !byte $46,%10101110 + !byte $30,%00100000 + !byte $04,%11000000 + !byte $2E,%10001110 + !byte $56,%11010000 + !byte $5E,%01000101 + !byte $0A,%11000111 + !byte $10,%10010000 + !byte $44,%01010011 + !byte $50,%00101000 + !byte $1A,%01100000 + !byte $2E,%10010011 + !byte $5A,%11010010 + !byte $36,%10001000 + !byte $24,%10000010 + !byte $10,%10001011 + !byte $5A,%11001101 + !byte $5E,%10101001 + !byte $1A,%01100101 + !byte $00,%11010011 + !byte $44,%01001110 + !byte $4E,%10001000 + !byte $1C,%11000000 + !byte $02,%01101111 + !byte $42,%11010010 + !byte $4E,%10000011 + !byte $1C,%11000101 + !byte $00,%11001110 + !byte $42,%11001101 + !byte $32,%10000101 + !byte $06,%01000001 + !byte $2A,%00110000 + !byte $38,%00101101 + !byte $5C,%01000100 + !byte $1E,%01000001 + !byte $02,%01101010 + !byte $40,%01110010 + !byte $32,%10000000 + !byte $1E,%01000110 + !byte $12,%00110000 + !byte $40,%01101101 + !byte $4C,%00001001 + !byte $26,%00000010 + !byte $2A,%00101011 + !byte $30,%00101111 + !byte $4C,%00000100 + !byte $06,%01000110 + !byte $12,%00101011 + !byte $58,%01110010 + !byte $5C,%01001001 + !byte $08,%01000011 + !byte $18,%00001111 + !byte $30,%00101010 + !byte $48,%00100101 + !byte $20,%10100001 + !byte $2C,%00101110 + !byte $3E,%00010010 + !byte $4A,%01100100 + !byte $20,%10100110 + !byte $14,%10101111 + !byte $56,%11001011 + !byte $34,%00001001 + !byte $2E,%10001001 + !byte $2C,%00110011 + !byte $48,%11010011 + !byte $4A,%01101001 + !byte $22,%00100010 + !byte $14,%10101010 + !byte $46,%00101010 + !byte $46,%10100100 + !byte $28,%10000110 + !byte $18,%00001010 + !byte $38,%00110010 + !byte $34,%00000100 + !byte $2E,%10000100 + !byte $16,%01001111 + !byte $48,%11001110 + !byte $46,%10101001 + !byte $16,%01000000 + !byte $16,%10001110 + !byte $46,%00101111 + !byte $48,%00100000 + !byte $16,%01000101 + !byte $04,%11001111 + !byte $58,%01101101 + !byte $48,%11000100 + !byte $1A,%10001001 + !byte $2C,%10101010 + !byte $32,%10001111 + !byte $34,%00000110 + !byte $1A,%10000100 + !byte $16,%01001010 + !byte $58,%01110000 + !byte $4A,%10000101 + !byte $08,%01001000 + !byte $1A,%01101111 + !byte $4A,%01110011 + !byte $44,%01000100 + !byte $1C,%00100100 + !byte $04,%11001010 + !byte $32,%10001010 + !byte $32,%01101001 + !byte $14,%10100000 + !byte $1A,%01101010 + !byte $44,%10001111 + !byte $48,%11001001 + !byte $28,%10000001 + !byte $16,%10010011 + !byte $48,%00101111 + !byte $34,%00000001 + !byte $14,%10100101 + !byte $14,%00101110 + !byte $4A,%01101110 + !byte $44,%01001001 + !byte $1C,%00101001 + !byte $2C,%10101111 + !byte $3E,%00001101 + !byte $4A,%10000000 + !byte $16,%10000100 + !byte $1C,%11001111 + !byte $44,%10001010 + !byte $5A,%11001000 + !byte $08,%10100001 + !byte $2E,%01001010 + !byte $36,%10001101 + !byte $5A,%11000011 + !byte $12,%00100110 + !byte $1C,%11001010 + !byte $4C,%00010011 + !byte $32,%01100100 + !byte $2C,%00100100 + !byte $14,%00110011 + !byte $4C,%00001110 + !byte $4C,%00000110 + !byte $06,%10100011 + !byte $2E,%01001111 + !byte $58,%01101011 + !byte $42,%11000011 + !byte $06,%10101000 + !byte $2A,%10110010 + !byte $42,%00010000 + !byte $30,%11001001 + !byte $12,%00100001 + !byte $2A,%10101101 + !byte $42,%00001011 + !byte $4C,%00000001 + !byte $1E,%10101000 + !byte $12,%10101101 + !byte $36,%10010010 + !byte $42,%11001000 + !byte $2C,%00101001 + !byte $12,%10110010 + !byte $48,%00101010 + !byte $30,%11000100 + !byte $1E,%10100011 + !byte $1E,%01001011 + !byte $3C,%10010001 + !byte $46,%00100101 + !byte $00,%00100101 + !byte $1E,%01010000 + !byte $4A,%10001111 + !byte $46,%00100000 + !byte $2A,%00100110 + !byte $06,%01010000 + !byte $4E,%10001101 + !byte $4E,%01100001 + !byte $2A,%00100001 + !byte $06,%01001011 + !byte $4E,%10010010 + !byte $40,%01101000 + !byte $10,%10000110 + !byte $1A,%10001110 + !byte $5A,%00010000 + !byte $54,%01000111 + !byte $04,%00100100 + !byte $1A,%10010011 + !byte $5A,%00001011 + !byte $36,%01100001 + !byte $16,%10001001 + !byte $10,%01010010 + !byte $34,%00001110 + !byte $36,%01100110 + !byte $2C,%10100101 + !byte $1C,%00110011 + !byte $40,%01110000 + !byte $4E,%01100110 + !byte $20,%01000011 + !byte $1C,%00101110 + !byte $40,%01101011 + !byte $44,%10000101 + !byte $00,%00100000 + !byte $00,%00101111 + !byte $34,%00010011 + !byte $44,%10000000 + !byte $04,%00101001 + !byte $0A,%11001100 + !byte $50,%00101101 + !byte $40,%01100011 + !byte $14,%00100100 + !byte $02,%10010011 + !byte $32,%01101110 + !byte $5E,%00100000 + !byte $2C,%10100000 + !byte $20,%10101011 + !byte $5C,%10001111 + !byte $58,%01101000 + !byte $08,%10100110 + !byte $10,%01001101 + !byte $34,%00001011 + !byte $42,%00000001 + !byte $10,%10000001 + !byte $04,%00110011 + !byte $5C,%10001010 + !byte $42,%00000110 + !byte $02,%10000100 + !byte $08,%01001101 + !byte $32,%01110011 + !byte $5C,%10000000 + !byte $2E,%01000101 + !byte $00,%00101010 + !byte $4A,%10001010 + !byte $56,%11000110 + !byte $02,%10001001 + !byte $1E,%10101101 + !byte $34,%00010000 + !byte $30,%01000101 + !byte $20,%01001000 + !byte $1E,%10110010 + !byte $5E,%00101111 + !byte $58,%01100011 + !byte $14,%00101001 + !byte $06,%10101101 + !byte $5E,%10010011 + !byte $30,%01000000 + !byte $2E,%01000000 + !byte $06,%10110010 + !byte $5E,%10001110 + !byte $58,%01100110 + !byte $22,%00100111 + !byte $20,%10110000 + !byte $3E,%11010000 + !byte $5A,%00000001 + !byte $0E,%00000111 + !byte $2E,%01101110 + !byte $4C,%00010000 + !byte $5A,%00000110 + !byte $02,%10000101 + !byte $28,%01010010 + !byte $30,%11001110 + !byte $50,%11000001 + !byte $18,%00100101 + !byte $04,%00101110 + !byte $5E,%00101010 + !byte $5E,%10000100 + !byte $22,%11000010 + !byte $08,%01010010 + !byte $30,%11010011 + !byte $58,%01100001 + !byte $12,%10101000 + !byte $28,%01001101 + !byte $50,%00110010 + !byte $5E,%10001001 + !byte $2A,%10101000 + !byte $16,%00101010 + !byte $4C,%00001011 + !byte $40,%01100110 + !byte $02,%10000000 + !byte $02,%10001110 + !byte $56,%00010010 + !byte $5C,%10000101 + !byte $2A,%10100011 + !byte $02,%10001111 + !byte $3E,%11001011 + !byte $56,%11000001 + !byte $12,%10100011 + !byte $18,%00101111 + !byte $46,%10001110 + !byte $3E,%00001000 + !byte $18,%00100000 + !byte $2E,%01110011 + !byte $5C,%00101110 + !byte $48,%01000101 + !byte $0E,%00000010 + !byte $18,%00101010 + !byte $5C,%00110011 + !byte $5E,%00100101 + !byte $1A,%10000101 + !byte $16,%00101111 + !byte $46,%10010011 + !byte $40,%01100001 + !byte $1A,%10000000 + !byte $02,%10001010 + !byte $30,%01001010 + !byte $32,%10100101 + !byte $16,%00100000 + !byte $20,%01001101 + !byte $52,%10101100 + !byte $4A,%10001001 + !byte $04,%00000110 + !byte $0A,%11010001 + !byte $30,%01001111 + !byte $4A,%10000100 + !byte $04,%00000001 + !byte $08,%10101011 + !byte $4E,%01110000 + !byte $50,%11000110 + !byte $2E,%01100100 + !byte $16,%01110011 + !byte $4E,%01101011 + !byte $48,%01000000 + !byte $1A,%10101001 + !byte $14,%10001111 + !byte $56,%00001101 + !byte $46,%10000100 + !byte $16,%00100101 + !byte $16,%01101110 + !byte $36,%01101011 + !byte $46,%10001001 + !byte $10,%01001000 + !byte $08,%10110000 + !byte $44,%00101110 + !byte $32,%10100000 + !byte $2E,%01101001 + !byte $2E,%00101010 + !byte $46,%00001010 + !byte $5C,%00100100 + !byte $22,%11000111 + !byte $14,%10001010 + !byte $36,%01110000 + !byte $3E,%00000011 + !byte $1A,%10100100 + !byte $1A,%10001111 + !byte $44,%00110011 + !byte $32,%10001001 + !byte $1C,%00000110 + !byte $20,%01010010 + !byte $46,%00001111 + !byte $5C,%00101001 + !byte $10,%01000011 + !byte $1A,%10001010 + !byte $48,%01001111 + !byte $46,%00000000 + !byte $1C,%00000001 + !byte $0E,%11010001 + !byte $4A,%10010011 + !byte $4C,%00101001 + !byte $00,%01000101 + !byte $2E,%00101111 + !byte $48,%01001010 + !byte $4A,%10100101 + !byte $16,%01100100 + !byte $2C,%00001110 + !byte $4A,%10001110 + !byte $38,%11000001 + !byte $14,%10000000 + !byte $2C,%10001010 + !byte $44,%01101111 + !byte $4C,%00100100 + !byte $00,%01000000 + !byte $2C,%00010011 + !byte $44,%01101010 + !byte $46,%00000101 + !byte $16,%01101001 + !byte $2C,%10001111 + !byte $32,%10101111 + !byte $32,%10000100 + !byte $28,%01001000 + !byte $04,%00010000 + !byte $5E,%00001010 + !byte $4A,%10100000 + !byte $14,%10000101 + !byte $1A,%10110011 + !byte $32,%10101010 + !byte $3E,%11000110 + !byte $2E,%00100000 + !byte $12,%00001011 + !byte $5A,%10101101 + !byte $44,%00100100 + !byte $02,%10101001 + !byte $1A,%10101110 + !byte $5A,%10110010 + !byte $34,%00101001 + !byte $1C,%01001001 + !byte $14,%00001110 + !byte $5E,%00001111 + !byte $44,%00101001 + !byte $0A,%00100010 + !byte $12,%00010000 + !byte $42,%10101101 + !byte $34,%00100100 + !byte $02,%10100100 + !byte $14,%00010011 + !byte $3C,%01010001 + !byte $38,%11000110 + !byte $2E,%00100101 + !byte $2A,%00001011 + !byte $42,%10110010 + !byte $44,%01100000 + !byte $1C,%01000100 + !byte $04,%00001011 + !byte $4C,%00110011 + !byte $54,%01000010 + !byte $18,%01000101 + !byte $2A,%00010000 + !byte $32,%10010011 + !byte $44,%01100101 + !byte $28,%01000011 + !byte $1C,%00001011 + !byte $4A,%10101111 + !byte $3E,%11000001 + !byte $2C,%10000101 + !byte $00,%01001111 + !byte $5E,%01101110 + !byte $34,%00100110 + !byte $2C,%10000000 + !byte $1C,%00010000 + !byte $5C,%01101010 + !byte $5E,%00000000 + !byte $2C,%00000100 + !byte $0E,%11001100 + !byte $32,%10001110 + !byte $34,%00100001 + !byte $04,%01001001 + !byte $00,%01001010 + !byte $4A,%10101010 + !byte $36,%10100011 + !byte $2C,%00001001 + !byte $02,%10110011 + !byte $4C,%00101110 + !byte $4E,%10100011 + !byte $04,%01000100 + !byte $22,%00101100 + !byte $5E,%01110011 + !byte $56,%00001000 + !byte $18,%01000000 + !byte $1C,%01010011 + !byte $5C,%01101111 + !byte $5E,%00000101 + !byte $02,%10100101 + !byte $16,%00001010 + !byte $50,%11001011 + !byte $36,%10101000 + !byte $14,%00000100 + !byte $1C,%01001110 + !byte $42,%11001010 + !byte $4E,%10101000 + !byte $12,%00000001 + !byte $18,%01001111 + !byte $52,%10110001 + !byte $30,%01100101 + !byte $12,%00000110 + !byte $02,%10101110 + !byte $42,%11001111 + !byte $4C,%00100110 + !byte $06,%01100001 + !byte $28,%01110000 + !byte $46,%01101110 + !byte $5E,%01100100 + !byte $1E,%01100110 + !byte $28,%01101011 + !byte $34,%00110011 + !byte $4C,%00100001 + !byte $1E,%01100001 + !byte $16,%00001111 + !byte $34,%00101110 + !byte $30,%01100000 + !byte $2A,%00000110 + !byte $2E,%01001110 + !byte $5A,%11001111 + !byte $5A,%10100011 + !byte $06,%01100110 + !byte $2E,%01010011 + !byte $5A,%11001010 + !byte $5A,%10101000 + !byte $1E,%11001000 + !byte $18,%01001010 + !byte $50,%11010000 + !byte $5C,%01100000 + !byte $2A,%00000001 + !byte $04,%01010011 + !byte $46,%01110011 + !byte $42,%10101000 + !byte $14,%00001001 + !byte $22,%11001100 + !byte $30,%01101010 + !byte $42,%10100011 + !byte $02,%10100000 + !byte $10,%01110000 + !byte $30,%01101111 + !byte $5C,%01100101 + !byte $1E,%11000011 + !byte $2A,%10001101 + !byte $34,%00101011 + !byte $56,%00000011 + !byte $1A,%10100101 + !byte $2A,%10010010 + !byte $34,%00110000 + !byte $5E,%01101001 + !byte $16,%00000000 + !byte $04,%01001110 + !byte $4E,%10110010 + !byte $42,%11000000 + !byte $06,%11001000 + !byte $2E,%00001010 + !byte $36,%10110010 + !byte $42,%11000101 + !byte $06,%11000011 + !byte $12,%10001101 + !byte $4C,%00110000 + !byte $48,%01100101 + !byte $0A,%00100111 + !byte $10,%01101011 + !byte $36,%10101101 + !byte $4A,%10101001 + !byte $1A,%11001001 + !byte $12,%10010010 + !byte $4E,%10101101 + !byte $4A,%10100100 + !byte $16,%00000101 + !byte $02,%10101111 + !byte $3C,%10001100 + !byte $46,%01100100 + !byte $1A,%10100000 + !byte $2E,%00001111 + !byte $5C,%00001110 + !byte $48,%01100000 + !byte $1A,%11000100 + !byte $1A,%11010011 + !byte $38,%11001011 + !byte $38,%01000011 + !byte $2E,%01000100 + !byte $26,%11010001 + !byte $4C,%00101011 + !byte $5A,%11000000 + !byte $2E,%01001001 + !byte $22,%00110001 + !byte $44,%01001010 + !byte $46,%01101001 + !byte $2E,%00000000 + !byte $14,%01101010 + !byte $4A,%10110011 + !byte $32,%10101001 + !byte $00,%01100101 + !byte $02,%10101010 + !byte $5C,%00010011 + !byte $5A,%11000101 + !byte $14,%01100000 + !byte $16,%01001110 + !byte $4A,%10101110 + !byte $32,%11000101 + !byte $00,%01100000 + !byte $14,%01101111 + !byte $48,%01101111 + !byte $38,%01001000 + !byte $02,%11001001 + !byte $16,%01010011 + !byte $40,%01010010 + !byte $32,%10100100 + !byte $28,%01100110 + !byte $1E,%11010010 + !byte $58,%01010000 + !byte $32,%11000000 + !byte $02,%11000100 + !byte $1E,%01101011 + !byte $58,%01001011 + !byte $4C,%01001001 + !byte $14,%01100101 + !byte $06,%01101011 + !byte $40,%01001101 + !byte $52,%01000010 + !byte $16,%01000100 + !byte $1E,%01110000 + !byte $40,%01010000 + !byte $4C,%01000100 + !byte $28,%01100001 + !byte $1E,%11001101 + !byte $40,%01001011 + !byte $4A,%11000101 + !byte $0E,%11000111 + !byte $06,%01110000 + !byte $58,%01010010 + !byte $5C,%00000100 + !byte $2E,%00000101 + !byte $06,%11010010 + !byte $48,%01101010 + !byte $44,%01000000 + !byte $12,%10000011 + !byte $06,%11001101 + !byte $44,%01001111 + !byte $44,%01000101 + !byte $10,%01100110 + !byte $1A,%11001110 + !byte $44,%00001110 + !byte $50,%01000011 + !byte $10,%01100001 + !byte $1A,%10101010 + !byte $38,%11010000 + !byte $5C,%00001001 + !byte $2A,%10001000 + !byte $1A,%10101111 + !byte $44,%00010011 + !byte $4E,%10000001 + !byte $2A,%10000011 + !byte $2C,%01101010 + !byte $58,%01001101 + !byte $4E,%10000110 + !byte $08,%01100011 + !byte $22,%11010001 + !byte $32,%10110011 + !byte $34,%01001001 + !byte $1C,%01101001 + !byte $2C,%01101111 + !byte $5C,%01001010 + !byte $36,%10000001 + !byte $12,%10001000 + !byte $26,%11001100 + !byte $32,%10101110 + !byte $36,%10000110 + !byte $04,%00100001 + !byte $00,%01101111 + !byte $5C,%01001111 + !byte $50,%01001000 + !byte $04,%00100110 + !byte $00,%01101010 + !byte $32,%11001111 + !byte $4A,%11000000 + !byte $1C,%01100100 + !byte $02,%11010011 + !byte $4C,%01010011 + !byte $44,%00000100 + !byte $18,%01100101 + !byte $26,%11010000 + !byte $5E,%01001110 + !byte $40,%01000110 + !byte $16,%01001001 + !byte $2C,%11001101 + !byte $32,%11001010 + !byte $58,%01000110 + !byte $2C,%01100000 + !byte $02,%11001110 + !byte $5E,%01010011 + !byte $34,%01000100 + !byte $18,%01100000 + !byte $2C,%11010010 + !byte $4A,%11001111 + !byte $40,%01000001 + !byte $08,%01101000 + !byte $12,%11001010 + !byte $4C,%01001110 + !byte $44,%00001001 + !byte $1C,%00100110 + !byte $1C,%01110011 + !byte $3C,%01001100 + !byte $30,%10000101 + !byte $1C,%00100001 + !byte $1C,%01101110 + !byte $38,%01001101 + !byte $58,%01000001 + !byte $20,%01100011 + !byte $26,%11001011 + !byte $38,%01010010 + !byte $30,%10000000 + !byte $2C,%01100101 + !byte $18,%01101111 + !byte $46,%01001110 + !byte $4A,%11001001 + !byte $04,%01100100 + !byte $14,%11001101 + !byte $42,%10101111 + !byte $5C,%01000000 + !byte $04,%01101001 + !byte $12,%11001111 + !byte $4A,%11001010 + !byte $40,%01001000 + !byte $20,%01101000 + !byte $2A,%11001111 + !byte $42,%10101010 + !byte $5C,%01000101 + !byte $20,%11000001 + !byte $2A,%11001010 + !byte $34,%01010011 + !byte $5E,%01001001 + !byte $0E,%11000010 + !byte $04,%00101011 + !byte $34,%01001110 + !byte $4A,%11000100 + !byte $02,%11000101 + !byte $14,%11010010 + !byte $30,%10001111 + !byte $5E,%01000100 + !byte $2C,%11000011 + !byte $18,%01101010 + !byte $4A,%11010011 + !byte $40,%01000011 + !byte $12,%11000000 + !byte $04,%00110000 + !byte $46,%01010011 + !byte $48,%10000101 + !byte $02,%11000000 + !byte $0A,%00101100 + !byte $56,%10110000 + !byte $58,%01001000 + !byte $12,%11000101 + !byte $1C,%00110000 + !byte $4A,%11001110 + !byte $58,%01000011 + !byte $20,%11000110 + !byte $08,%01101101 + !byte $5A,%10101010 + !byte $46,%01000100 + !byte $2C,%11001000 + !byte $04,%01110011 + !byte $30,%10001010 + !byte $48,%10000000 + !byte $14,%11000011 + !byte $2E,%00101110 + !byte $4E,%10001011 + !byte $42,%10100000 + !byte $1A,%11000101 + !byte $14,%01001010 + !byte $5A,%10010010 + !byte $32,%11001001 + !byte $2A,%11000000 + !byte $1C,%00101011 + !byte $5A,%10001101 + !byte $42,%10100101 + !byte $14,%11001000 + !byte $2E,%00110011 + !byte $5A,%10101111 + !byte $32,%11000100 + !byte $2A,%11000101 + !byte $04,%01101110 + !byte $4E,%10010000 + !byte $34,%01000001 + !byte $00,%10000101 + !byte $14,%01001111 + !byte $50,%01001101 + !byte $34,%01000110 + !byte $1E,%00001001 + !byte $08,%01110010 + !byte $44,%00101010 + !byte $46,%01001001 + !byte $08,%11000001 + !byte $10,%00110010 + !byte $42,%10001101 + !byte $4E,%11000011 + !byte $1A,%11000000 + !byte $16,%00101110 + !byte $36,%10001011 + !byte $4E,%11001000 + !byte $14,%01000000 + !byte $20,%01101101 + !byte $42,%10010010 + !byte $36,%11001000 + !byte $1E,%00000100 + !byte $02,%11001111 + !byte $56,%10101011 + !byte $36,%11000011 + !byte $14,%01000101 + !byte $20,%01110010 + !byte $36,%10010000 + !byte $4C,%01000110 + !byte $00,%10000000 + !byte $10,%00101101 + !byte $48,%10001111 + !byte $5A,%10100000 + !byte $08,%11000110 + !byte $2C,%01001010 + !byte $44,%00101111 + !byte $4C,%01000001 + !byte $26,%11000111 + !byte $02,%11001010 + !byte $50,%01010010 + !byte $44,%00100101 + !byte $2E,%00100100 + !byte $16,%00110011 + !byte $48,%10001010 + !byte $44,%00100000 + !byte $06,%00000100 + !byte $28,%00110010 + !byte $32,%11010011 + !byte $5A,%10100101 + !byte $06,%00001001 + !byte $0E,%11010000 + !byte $32,%11001110 + !byte $52,%01000111 + !byte $26,%11000110 + !byte $2C,%01001111 + !byte $5C,%11001101 + !byte $4C,%01101001 + !byte $1C,%10001001 + !byte $1A,%11001111 + !byte $5C,%00101111 + !byte $32,%00000110 + !byte $2E,%00101001 + !byte $00,%10001111 + !byte $5C,%00101010 + !byte $4C,%01100100 + !byte $1C,%10000100 + !byte $28,%00101101 + !byte $5C,%11010010 + !byte $5A,%10000011 + !byte $16,%00100100 + !byte $1E,%00010011 + !byte $4E,%11010010 + !byte $5A,%10001000 + !byte $18,%10000101 + !byte $1A,%11001010 + !byte $4E,%11001101 + !byte $42,%10000011 + !byte $2C,%01000000 + !byte $1E,%00001110 + !byte $3E,%10110000 + !byte $42,%10001000 + !byte $16,%00101001 + !byte $0E,%11001011 + !byte $36,%11010010 + !byte $32,%00000001 + !byte $26,%11000001 + !byte $0A,%00110001 + !byte $36,%11001101 + !byte $34,%01101001 + !byte $2C,%01000101 + !byte $00,%10001010 + !byte $44,%11001101 + !byte $3A,%11000010 + !byte $18,%10000000 + !byte $20,%11001011 + !byte $34,%01010000 + !byte $30,%10100101 + !byte $04,%10001001 + !byte $1C,%10010011 + !byte $4C,%01110011 + !byte $56,%10100110 + !byte $06,%10000001 + !byte $1C,%10001110 + !byte $34,%01001011 + !byte $5C,%00100000 + !byte $04,%10000100 + !byte $28,%01010000 + !byte $4C,%01101110 + !byte $4A,%00000110 + !byte $1E,%10000110 + !byte $06,%00010011 + !byte $4C,%01010000 + !byte $4A,%00000001 + !byte $1E,%10000001 + !byte $06,%00001110 + !byte $5E,%00101110 + !byte $34,%01100100 + !byte $06,%10000110 + !byte $28,%01001011 + !byte $3E,%10101011 + !byte $5C,%00100101 + !byte $26,%11000010 + !byte $10,%01010000 + !byte $44,%11010010 + !byte $5C,%11000011 + !byte $10,%00101000 + !byte $18,%10001111 + !byte $4C,%01001011 + !byte $30,%10100000 + !byte $0A,%00000011 + !byte $10,%01001011 + !byte $5E,%00110011 + !byte $5C,%11001000 + !byte $10,%00100011 + !byte $2A,%01101101 + !byte $58,%00110000 + !byte $56,%10100001 + !byte $14,%00100000 + !byte $20,%11010000 + !byte $40,%00101011 + !byte $44,%11001000 + !byte $0C,%01100111 + !byte $18,%10001010 + !byte $40,%00110000 + !byte $3C,%01000111 + !byte $04,%01000110 + !byte $12,%10101111 + !byte $58,%00101011 + !byte $44,%11000011 + !byte $04,%01000001 + !byte $12,%10101010 + !byte $32,%00010000 + !byte $44,%00000000 + !byte $0E,%11000110 + !byte $2A,%01110010 + !byte $46,%00101110 + !byte $48,%10100101 + !byte $12,%10100000 + !byte $12,%01101101 + !byte $42,%10001111 + !byte $3E,%10100110 + !byte $10,%01000110 + !byte $12,%01110010 + !byte $42,%10001010 + !byte $42,%10000000 + !byte $10,%01000001 + !byte $14,%00101010 + !byte $32,%00001011 + !byte $5E,%00100100 + !byte $02,%00000110 + !byte $14,%00101111 + !byte $34,%01110011 + !byte $3A,%11000111 + !byte $28,%00101000 + !byte $2A,%10101010 + !byte $4A,%00010000 + !byte $5E,%00101001 + !byte $28,%01000001 + !byte $04,%10010011 + !byte $44,%00001111 + !byte $48,%10100000 + !byte $28,%01000110 + !byte $08,%11001011 + !byte $34,%01101110 + !byte $40,%00100001 + !byte $1C,%01000110 + !byte $2C,%10101101 + !byte $44,%00001010 + !byte $40,%00100110 + !byte $28,%00100011 + !byte $2A,%10101111 + !byte $46,%00110011 + !byte $46,%00100100 + !byte $1C,%01000001 + !byte $04,%10001110 + !byte $5A,%10001010 + !byte $58,%00100110 + !byte $12,%10100101 + !byte $2C,%10110010 + !byte $30,%10101111 + !byte $58,%00100001 + !byte $1C,%10101001 + !byte $08,%11010000 + !byte $4A,%00001011 + !byte $46,%00101001 + !byte $02,%00000001 + !byte $2E,%00001110 + !byte $5A,%10001111 + !byte $3E,%10100001 + !byte $2A,%10100000 + !byte $14,%10110010 + !byte $30,%10101010 + !byte $42,%10000101 + !byte $2A,%10100101 + !byte $2C,%00101010 + !byte $54,%10010001 + !byte $4C,%10001001 + !byte $2A,%01100011 + !byte $14,%10101101 + !byte $3E,%11010001 + !byte $50,%00000010 + !byte $0A,%00001000 + !byte $2C,%00101111 + !byte $48,%10101111 + !byte $5A,%10000000 + !byte $1A,%00000110 + !byte $06,%10001011 + !byte $5C,%00001010 + !byte $44,%00000101 + !byte $1C,%10100100 + !byte $06,%10010000 + !byte $5C,%00001111 + !byte $5A,%10000101 + !byte $0E,%11000001 + !byte $1E,%10001011 + !byte $48,%10101010 + !byte $4C,%10000100 + !byte $00,%10100101 + !byte $2E,%00010011 + !byte $3E,%11001100 + !byte $38,%01100011 + !byte $2A,%01101000 + !byte $1E,%10010000 + !byte $4C,%10010011 + !byte $4E,%00001001 + !byte $12,%01100011 + !byte $04,%01010000 + !byte $4C,%10001110 + !byte $3C,%10000111 + !byte $14,%00100101 + !byte $16,%00001110 + !byte $5E,%00001110 + !byte $3A,%01000010 + !byte $1E,%00101001 + !byte $1C,%10110011 + !byte $40,%00110010 + !byte $38,%01101000 + !byte $00,%10100000 + !byte $04,%01001011 + !byte $56,%11010001 + !byte $5C,%00000000 + !byte $08,%10000011 + !byte $1C,%10101110 + !byte $3A,%11001100 + !byte $36,%00001001 + !byte $12,%01101000 + !byte $1C,%01001011 + !byte $4E,%00010011 + !byte $4E,%00000100 + !byte $2C,%00100000 + !byte $02,%00010000 + !byte $40,%00101101 + !byte $36,%00000100 + !byte $2C,%10100011 + !byte $1C,%01010000 + !byte $34,%10010011 + !byte $5C,%00000101 + !byte $08,%10001000 + !byte $16,%00010011 + !byte $5C,%10101101 + !byte $50,%00000111 + !byte $1E,%00100100 + !byte $02,%00001011 + !byte $42,%01101010 + !byte $30,%11000101 + !byte $2C,%00100101 + !byte $1E,%00110011 + !byte $4E,%00001110 + !byte $34,%10000100 + !byte $2C,%10101000 + !byte $14,%00001010 + !byte $58,%00110010 + !byte $34,%10001001 + !byte $1A,%00000001 + !byte $00,%10101111 + !byte $38,%01101101 + !byte $50,%01100011 + !byte $06,%00101001 + !byte $1A,%00010000 + !byte $42,%01101111 + !byte $50,%01101000 + !byte $18,%10100101 + !byte $1E,%00101110 + !byte $5A,%01101101 + !byte $38,%00000010 + !byte $06,%00100100 + !byte $00,%10101010 + !byte $36,%00010011 + !byte $32,%00100110 + !byte $2E,%00000100 + !byte $14,%00001111 + !byte $5A,%01110010 + !byte $4E,%10100001 + !byte $14,%10100011 + !byte $04,%10110011 + !byte $52,%01001100 + !byte $34,%01100110 + !byte $20,%10001000 + !byte $1A,%00001011 + !byte $42,%01101101 + !byte $4E,%10100110 + !byte $2E,%00001001 + !byte $0A,%00001101 + !byte $38,%01110010 + !byte $36,%10100001 + !byte $20,%10000011 + !byte $18,%10101111 + !byte $42,%01110010 + !byte $36,%10100110 + !byte $14,%10101000 + !byte $06,%00110011 + !byte $36,%00001110 + !byte $34,%01100001 + !byte $18,%10100000 + !byte $12,%10001010 + !byte $5C,%10110010 + !byte $4C,%01100110 + !byte $04,%10100100 + !byte $08,%10001101 + !byte $58,%00101101 + !byte $42,%01100000 + !byte $04,%10101001 + !byte $18,%10101010 + !byte $5E,%00010011 + !byte $32,%00100001 + !byte $16,%00000100 + !byte $12,%10001111 + !byte $44,%10101101 + !byte $38,%00000111 + !byte $14,%00000000 + !byte $08,%10010010 + !byte $44,%10110010 + !byte $4C,%01100001 + !byte $16,%00001001 + !byte $06,%00101110 + !byte $56,%11001100 + !byte $3C,%01000010 + !byte $14,%00000101 + !byte $20,%10010010 + !byte $34,%10001110 + !byte $4A,%00100110 + !byte $12,%10000000 + !byte $2C,%00001010 + !byte $30,%11001111 + !byte $30,%11000000 + !byte $22,%00000011 + !byte $20,%10001101 + !byte $5A,%01101111 + !byte $4A,%00100001 + !byte $1C,%11001001 + !byte $2C,%00001111 + !byte $5A,%01101010 + !byte $5E,%00000100 + !byte $12,%10000101 + !byte $04,%10101110 + !byte $48,%11001111 + !byte $42,%01100101 + !byte $1C,%11000100 + !byte $2A,%10001010 + !byte $50,%01101101 + !byte $48,%11000101 + !byte $2C,%00000000 + !byte $2A,%10001111 + !byte $46,%00001110 + !byte $46,%00000100 + !byte $2C,%00000101 + !byte $0A,%00010010 + !byte $40,%00010000 + !byte $4C,%10101001 + !byte $00,%11000101 + !byte $28,%00101011 + !byte $50,%01110010 + !byte $48,%11000000 + !byte $22,%00001000 + !byte $10,%00101011 + !byte $46,%00010011 + !byte $3E,%11000111 + !byte $2A,%10000000 + !byte $1C,%11010011 + !byte $40,%00001011 + !byte $5E,%00001001 + !byte $00,%11000000 + !byte $10,%00110000 + !byte $30,%11001010 + !byte $4C,%10100100 + !byte $04,%11001001 + !byte $28,%00110000 + !byte $32,%00110000 + !byte $5C,%10100011 + !byte $2A,%10000101 + !byte $1C,%11001110 + !byte $58,%00010000 + !byte $5C,%10101000 + !byte $1E,%01000100 + !byte $2E,%11001101 + !byte $4A,%00110000 + !byte $3A,%01000111 + !byte $1E,%01001001 + !byte $2E,%11010010 + !byte $58,%00001011 + !byte $44,%10100011 + !byte $04,%11000100 + !byte $00,%11001111 + !byte $50,%00001100 + !byte $40,%00101000 + !byte $02,%00100110 + !byte $04,%11010011 + !byte $32,%00101011 + !byte $5A,%01100011 + !byte $28,%00100001 + !byte $16,%11001101 + !byte $34,%01110000 + !byte $5A,%01100000 + !byte $10,%00100001 + !byte $26,%10110000 + !byte $4C,%01110000 + !byte $42,%01100011 + !byte $18,%11000101 + !byte $2C,%10001101 + !byte $4C,%10110011 + !byte $5A,%01101000 + !byte $18,%11000000 + !byte $04,%11001110 + !byte $34,%01101011 + !byte $5A,%01100101 + !byte $02,%00100001 + !byte $00,%11001010 + !byte $3A,%11010001 + !byte $52,%11000010 + !byte $28,%00100110 + !byte $16,%11010010 + !byte $4E,%10101011 + !byte $42,%01101000 + !byte $1A,%00100110 + !byte $2C,%10010010 + !byte $4E,%10110000 + !byte $40,%00000001 + !byte $10,%00100110 + !byte $12,%01101010 + !byte $4C,%10101110 + !byte $40,%00000110 + !byte $06,%01000100 + !byte $1E,%01010011 + !byte $56,%10010000 + !byte $58,%00101000 + !byte $1A,%00100001 + !byte $26,%10101011 + !byte $36,%10101011 + !byte $58,%00000001 + !byte $04,%01100001 + !byte $14,%10001101 + !byte $4C,%01101011 + !byte $40,%00100011 + !byte $2E,%11000011 + !byte $1E,%01001110 + !byte $36,%10110000 + !byte $4E,%00101001 + !byte $06,%01001001 + !byte $14,%10010010 + !byte $50,%00010001 + !byte $58,%00100011 + !byte $04,%01100110 + !byte $12,%01101111 + !byte $4A,%00101011 + !byte $34,%10101001 + !byte $1C,%01100110 + !byte $02,%00110000 + !byte $34,%10110011 + !byte $58,%00000110 + !byte $1C,%01100001 + !byte $22,%00001101 + !byte $42,%01001111 + !byte $4E,%00100100 + !byte $2E,%11001000 + !byte $18,%11001111 + !byte $56,%10001011 + !byte $44,%10101000 + !byte $1E,%10100001 + !byte $2A,%01001101 + !byte $42,%01001010 + !byte $34,%10100100 + !byte $12,%01100000 + !byte $2A,%01010010 + !byte $38,%00001100 + !byte $3E,%11000010 + !byte $06,%10100001 + !byte $12,%01001101 + !byte $54,%10001100 + !byte $46,%00001001 + !byte $16,%11000011 + !byte $06,%01010011 + !byte $48,%11001010 + !byte $36,%00101001 + !byte $1E,%10100110 + !byte $02,%00101011 + !byte $34,%10101110 + !byte $36,%00100100 + !byte $2C,%10000011 + !byte $12,%01010010 + !byte $3E,%10010000 + !byte $52,%11000111 + !byte $06,%10100110 + !byte $06,%01001110 + !byte $4E,%00110011 + !byte $42,%01000000 + !byte $12,%01100101 + !byte $18,%11001010 + !byte $3E,%10001011 + !byte $56,%11000111 + !byte $2C,%10001000 + !byte $1A,%00110000 + !byte $52,%01010001 + !byte $42,%01000101 + !byte $20,%10100011 + !byte $2A,%01101010 + !byte $4E,%00101110 + !byte $4C,%11001001 + !byte $08,%10100011 + !byte $04,%01110000 + !byte $38,%00010001 + !byte $30,%00000110 + !byte $16,%11001000 + !byte $22,%00010010 + !byte $5A,%01001010 + !byte $4C,%11000100 + !byte $20,%10101000 + !byte $04,%01101011 + !byte $36,%00110011 + !byte $56,%10000110 + !byte $08,%10101000 + !byte $10,%00010010 + !byte $5A,%01001111 + !byte $56,%10000001 + !byte $20,%00000010 + !byte $1A,%00101011 + !byte $36,%00101110 + !byte $30,%00000001 + !byte $14,%10000011 + !byte $0E,%10110000 + !byte $4C,%11010011 + !byte $56,%11000010 + !byte $2A,%01100000 + !byte $2A,%01101111 + !byte $5E,%11001101 + !byte $48,%00000110 + !byte $26,%10100110 + !byte $10,%00001101 + !byte $5E,%11010010 + !byte $32,%01000110 + !byte $14,%10001000 + !byte $1C,%01110000 + !byte $4C,%11001110 + !byte $5A,%01000000 + !byte $26,%10100001 + !byte $0E,%10101011 + !byte $46,%11001101 + !byte $34,%11001001 + !byte $1E,%01101001 + !byte $1C,%01101011 + !byte $40,%11001010 + !byte $5A,%01000101 + !byte $2A,%01100101 + !byte $28,%00010010 + !byte $30,%00010000 + !byte $38,%10000011 + !byte $20,%00000111 + !byte $28,%00001101 + !byte $40,%11001111 + !byte $3E,%10000110 + !byte $1E,%01100100 + !byte $20,%10101101 + !byte $46,%11010010 + !byte $38,%10001000 + !byte $2A,%01000011 + !byte $08,%10110010 + !byte $5C,%10010010 + !byte $48,%00000001 + !byte $12,%01000011 + !byte $20,%10110010 + !byte $5C,%10001101 + !byte $32,%01000001 + !byte $2A,%01001000 + !byte $08,%10101101 + !byte $58,%11001111 + !byte $5E,%11000011 + !byte $12,%01001000 + !byte $1E,%10101011 + !byte $30,%00001011 + !byte $3E,%10000001 + !byte $08,%00000010 + !byte $10,%00001011 + !byte $58,%11001010 + !byte $50,%10000011 + !byte $00,%00000110 + !byte $10,%00010000 + !byte $42,%00101010 + !byte $34,%11000100 + !byte $00,%00000001 + !byte $1E,%10110000 + !byte $44,%10001101 + !byte $4A,%01000110 + !byte $12,%01000000 + !byte $06,%10110000 + !byte $48,%00010000 + !byte $50,%10001000 + !byte $06,%01101001 + !byte $1E,%01110011 + !byte $34,%11001110 + !byte $3C,%10000010 + !byte $06,%01100100 + !byte $28,%00001011 + !byte $42,%00101111 + !byte $5E,%11001000 + !byte $08,%00000111 + !byte $06,%10101011 + !byte $54,%00110001 + !byte $4A,%01000001 + !byte $18,%00000110 + !byte $1E,%01101110 + !byte $34,%11010011 + !byte $40,%11000000 + !byte $10,%00000001 + !byte $12,%01001010 + !byte $44,%10010010 + !byte $40,%11000101 + !byte $0E,%10100110 + !byte $0E,%10110001 + !byte $52,%11001100 + !byte $4E,%01001001 + !byte $18,%00000001 + !byte $28,%00010000 + !byte $48,%00001011 + !byte $4E,%01000100 + !byte $10,%00000110 + !byte $12,%01001111 + !byte $32,%01001011 + !byte $46,%11000011 + !byte $0E,%10100001 + !byte $2E,%10101101 + !byte $32,%01010000 + !byte $42,%00100000 + !byte $02,%01000001 + !byte $00,%00010000 + !byte $38,%10001101 + !byte $34,%10000110 + !byte $02,%01000110 + !byte $06,%01110011 + !byte $38,%10010010 + !byte $46,%11001000 + !byte $10,%00001000 + !byte $06,%01101110 + !byte $4E,%01010011 + !byte $34,%10000001 + !byte $28,%00000001 + !byte $00,%00001011 + !byte $4A,%01010000 + !byte $42,%00100101 + !byte $12,%01000101 + !byte $2E,%10110010 + !byte $3A,%01001100 + !byte $58,%11000101 + !byte $28,%00000110 + !byte $16,%10101101 + !byte $50,%10001101 + !byte $5C,%10000011 + !byte $10,%00000011 + !byte $2A,%01001010 + !byte $50,%10010010 + !byte $4C,%10000110 + !byte $22,%01000010 + !byte $2A,%01001111 + !byte $5A,%00101010 + !byte $58,%11000000 + !byte $1A,%01000110 + !byte $18,%00010000 + !byte $5A,%01010010 + !byte $5C,%10001000 + !byte $2E,%10100011 + !byte $16,%10110010 + !byte $5A,%01001101 + !byte $4C,%10000001 + !byte $2A,%01000000 + !byte $20,%00001100 + !byte $42,%01001101 + !byte $36,%01001001 + !byte $0A,%00100011 + !byte $0E,%10101100 + !byte $5A,%00101111 + !byte $36,%01000100 + !byte $28,%00001000 + !byte $18,%00001011 + !byte $4A,%01001011 + !byte $44,%10000011 + !byte $1A,%01000001 + !byte $02,%01010000 + !byte $42,%01010010 + !byte $5A,%00100000 + !byte $1E,%10001001 + !byte $02,%01001011 + !byte $52,%11010001 + !byte $44,%10001000 + !byte $1E,%10000100 + !byte $12,%00101010 + !byte $4E,%01001110 + !byte $5A,%00100101 + !byte $2A,%01000101 + !byte $20,%00010001 + !byte $54,%00101100 + !byte $30,%00100110 + !byte $28,%00000011 + !byte $2C,%01101101 + !byte $36,%01010011 + !byte $30,%00100001 + !byte $2E,%10101000 + !byte $2C,%01110010 + !byte $36,%01001110 + !byte $5A,%01001000 + !byte $16,%10100011 + !byte $08,%00001100 + !byte $42,%00001010 + !byte $4E,%11000001 + !byte $0C,%01100010 + !byte $12,%00101111 + !byte $34,%10010000 + !byte $42,%00000000 + !byte $0A,%00101000 + !byte $14,%01101101 + !byte $34,%10001011 + !byte $4E,%11000110 + !byte $20,%11001000 + !byte $1E,%10010011 + !byte $42,%00001111 + !byte $5A,%01000011 + !byte $20,%11000011 + !byte $14,%01110010 + !byte $4C,%10010000 + !byte $36,%11000001 + !byte $08,%11000011 + !byte $1A,%01010000 + !byte $4C,%10001011 + !byte $42,%01000011 + !byte $16,%10101000 + !byte $1E,%10001110 + !byte $5E,%10101101 + !byte $42,%00000101 + !byte $04,%10000001 + !byte $26,%10110001 + !byte $40,%10101111 + !byte $42,%01001000 + !byte $04,%10000110 + !byte $1A,%01001011 + !byte $40,%10101010 + !byte $36,%11000110 + !byte $08,%11001000 + !byte $10,%11001010 + !byte $56,%01110000 + !byte $4E,%01101001 + !byte $1C,%10000110 + !byte $08,%00010001 + !byte $5E,%10110010 + !byte $4E,%01100100 + !byte $12,%00100000 + !byte $10,%11001111 + !byte $56,%01101011 + !byte $48,%00100110 + !byte $06,%10000100 + !byte $2A,%00101010 + !byte $46,%10101101 + !byte $48,%00100001 + !byte $12,%00100101 + !byte $2A,%00101111 + !byte $40,%00010010 + !byte $40,%10100000 + !byte $1C,%10000001 + !byte $20,%11001101 + !byte $30,%00110000 + !byte $40,%10100101 + !byte $06,%10001001 + !byte $06,%10010011 + !byte $58,%10101111 + !byte $5A,%00000101 + !byte $2C,%01100011 + !byte $06,%10001110 + !byte $58,%10101010 + !byte $5E,%10100011 + !byte $00,%00100110 + !byte $20,%11010010 + !byte $40,%00001101 + !byte $5A,%00000000 + !byte $2C,%01101000 + !byte $28,%11001111 + !byte $58,%00010010 + !byte $36,%01101001 + !byte $22,%01000111 + !byte $28,%11001010 + !byte $3E,%01110000 + !byte $5E,%10101000 + !byte $14,%01100011 + !byte $08,%11001101 + !byte $5A,%00001111 + !byte $36,%01100100 + !byte $00,%00100001 + !byte $08,%11010010 + !byte $3E,%01101011 + !byte $32,%01100110 + !byte $10,%11000101 + !byte $26,%10010000 + !byte $46,%10110010 + !byte $58,%10100101 + !byte $2A,%00100000 + !byte $26,%10001011 + !byte $4E,%01110011 + !byte $58,%10100000 + !byte $10,%11000000 + !byte $26,%10101100 + !byte $5A,%00001010 + !byte $38,%10100011 + !byte $14,%01101000 + !byte $0A,%00101101 + !byte $30,%00101011 + !byte $38,%10101000 + !byte $1E,%10101001 + !byte $04,%10010000 + !byte $4E,%01101110 + !byte $54,%10000111 + !byte $22,%00100011 + !byte $0A,%00110010 + !byte $48,%00110000 + !byte $46,%10100011 + !byte $18,%00100110 + !byte $1C,%10010000 + !byte $3A,%01010001 + !byte $50,%10101000 + !byte $2A,%00100101 + !byte $04,%10001011 + !byte $58,%00001101 + !byte $32,%01100001 + !byte $28,%11000000 + !byte $12,%00001010 + !byte $48,%00101011 + !byte $56,%01100110 + !byte $1E,%10100100 + !byte $00,%00110000 + !byte $36,%01110011 + !byte $50,%10100011 + !byte $28,%11000101 + !byte $24,%01010001 + !byte $5C,%01101101 + !byte $56,%01100001 + !byte $18,%00100001 + !byte $1C,%10001011 + !byte $5C,%01110010 + !byte $3A,%00000011 + !byte $22,%00101000 + !byte $12,%00001111 + !byte $4E,%11010000 + !byte $3E,%01100110 + !byte $0A,%01000010 + !byte $1E,%10110011 + !byte $4E,%11001011 + !byte $4A,%01100110 + !byte $12,%00000000 + !byte $2A,%00110010 + !byte $36,%01101110 + !byte $46,%10101000 + !byte $12,%00000101 + !byte $2A,%00101101 + !byte $36,%11001011 + !byte $54,%00100111 + !byte $0E,%10100111 + !byte $12,%00101101 + !byte $44,%01101101 + !byte $4A,%01100001 + !byte $26,%10000110 + !byte $12,%00110010 + !byte $36,%11010000 + !byte $3E,%01100001 + !byte $06,%10101001 + !byte $1E,%10101110 + !byte $50,%10110010 + !byte $3A,%00001000 + !byte $06,%10100100 + !byte $00,%00101011 + !byte $38,%10101101 + !byte $4E,%10001001 + !byte $02,%01100110 + !byte $0E,%10010000 + !byte $50,%10101101 + !byte $4E,%10000100 + !byte $26,%10000001 + !byte $18,%00110000 + !byte $38,%10110010 + !byte $40,%00001000 + !byte $06,%11000001 + !byte $2E,%10001101 + !byte $40,%10001010 + !byte $54,%00100010 + !byte $1E,%11000110 + !byte $0E,%10001011 + !byte $44,%01110010 + !byte $5C,%01100011 + !byte $1E,%11000001 + !byte $2E,%10010010 + !byte $32,%01110000 + !byte $40,%00000011 + !byte $06,%11000110 + !byte $16,%10001101 + !byte $32,%01101011 + !byte $58,%00001000 + !byte $2E,%10000011 + !byte $18,%00101011 + !byte $40,%10001111 + !byte $40,%10000000 + !byte $02,%01100001 + !byte $2A,%00001010 + !byte $4A,%01110000 + !byte $40,%10000101 + !byte $1A,%01100110 + !byte $16,%10010010 + !byte $4E,%10010011 + !byte $30,%01000110 + !byte $20,%00000100 + !byte $10,%10101010 + !byte $4A,%01101011 + !byte $5C,%01101000 + !byte $20,%00001001 + !byte $06,%10110011 + !byte $58,%10001010 + !byte $58,%00000011 + !byte $16,%10000011 + !byte $2A,%00001111 + !byte $58,%10001111 + !byte $44,%01100011 + !byte $2E,%10001000 + !byte $22,%00101101 + !byte $4E,%10001110 + !byte $50,%00100010 + !byte $2A,%00000000 + !byte $06,%10101110 + !byte $5E,%10001101 + !byte $48,%01000110 + !byte $08,%00000100 + !byte $10,%10101111 + !byte $3A,%00001101 + !byte $30,%01000001 + !byte $0E,%10000110 + !byte $22,%00110010 + !byte $36,%10010011 + !byte $44,%01101000 + !byte $1E,%11001001 + !byte $20,%00001110 + !byte $30,%01010000 + !byte $36,%10001001 + !byte $1A,%01100001 + !byte $02,%01110000 + !byte $5E,%10010010 + !byte $36,%10000100 + !byte $0E,%10000001 + !byte $28,%10101010 + !byte $36,%10001110 + !byte $34,%10100110 + !byte $08,%00001001 + !byte $20,%00010011 + !byte $3A,%00010010 + !byte $4C,%10100110 + !byte $1E,%11000100 + !byte $02,%01101011 + !byte $46,%10001101 + !byte $34,%10100001 + !byte $12,%00100011 + !byte $28,%10101111 + !byte $46,%10010010 + !byte $58,%10000101 + !byte $2A,%00101000 + !byte $1E,%11001110 + !byte $30,%01001011 + !byte $58,%10000000 + !byte $2A,%00100011 + !byte $1E,%11010011 + !byte $40,%01101111 + !byte $4C,%10100001 + !byte $12,%00101000 + !byte $08,%00010011 + !byte $5A,%00110010 + !byte $50,%00100111 + !byte $2A,%00000101 + !byte $1A,%01101011 + !byte $40,%01101010 + !byte $48,%01000001 + !byte $10,%10100000 + !byte $08,%00001110 + !byte $56,%01010000 + !byte $4E,%10100100 + !byte $0E,%10100010 + !byte $1A,%01110000 + !byte $5A,%00101101 + !byte $4E,%10101001 + !byte $10,%10100101 + !byte $1E,%11001011 + !byte $42,%00101101 + !byte $38,%00100010 + !byte $16,%10001000 + !byte $2C,%01001101 + !byte $48,%01010000 + !byte $50,%11000011 + !byte $0A,%01000111 + !byte $06,%11001011 + !byte $56,%01001011 + !byte $5E,%10000011 + !byte $00,%01000110 + !byte $1E,%11010000 + !byte $42,%00110010 + !byte $50,%11001000 + !byte $26,%10100111 + !byte $06,%11010000 + !byte $3E,%01001011 + !byte $38,%11001000 + !byte $28,%10100000 + !byte $2C,%01010010 + !byte $3E,%01010000 + !byte $38,%11000011 + !byte $00,%01000001 + !byte $22,%01001100 + !byte $48,%01001011 + !byte $38,%00100111 + !byte $06,%11001001 + !byte $14,%01001101 + !byte $4E,%10110011 + !byte $52,%00000011 + !byte $28,%10100101 + !byte $24,%01001100 + !byte $4E,%10101110 + !byte $40,%01100000 + !byte $06,%11000100 + !byte $06,%11001110 + !byte $3E,%10110001 + !byte $5E,%10001000 + !byte $18,%01000110 + !byte $06,%11010011 + !byte $34,%10101011 + !byte $46,%10000011 + !byte $18,%01000001 + !byte $14,%01010010 + !byte $34,%10110000 + !byte $40,%01100101 + !byte $04,%10100110 + !byte $00,%01010000 + !byte $4C,%10110000 + !byte $56,%01000110 + !byte $04,%10100001 + !byte $10,%10001111 + !byte $4C,%10101011 + !byte $56,%01000001 + !byte $1C,%10100110 + !byte $10,%10001010 + !byte $50,%11010010 + !byte $36,%10101001 + !byte $20,%00101001 + !byte $00,%01001011 + !byte $58,%01101010 + !byte $52,%00001000 + !byte $20,%00100100 + !byte $10,%11010001 + !byte $3C,%00110001 + !byte $3E,%01000110 + !byte $0A,%01000011 + !byte $18,%01010000 + !byte $58,%01101111 + !byte $32,%10000110 + !byte $2C,%01001000 + !byte $26,%01110000 + !byte $50,%11001101 + !byte $3E,%01000001 + !byte $2C,%01000011 + !byte $26,%01101011 + !byte $38,%11001101 + !byte $46,%10001000 + !byte $10,%10000000 + !byte $20,%00110011 + !byte $38,%11010010 + !byte $36,%10100100 + !byte $10,%10000101 + !byte $18,%01001011 + !byte $3E,%10101100 + !byte $5A,%00100011 + !byte $1C,%10100001 + !byte $2E,%01101101 + !byte $36,%10101110 + !byte $32,%10000001 + !byte $0A,%01001000 + !byte $28,%11010001 + !byte $56,%10110001 + !byte $4A,%10000110 + !byte $14,%01000011 + !byte $20,%00101110 + !byte $40,%01001010 + !byte $58,%01100000 + !byte $26,%10100010 + !byte $10,%11001100 + !byte $36,%10110011 + !byte $5A,%00101000 + !byte $08,%00100100 + !byte $28,%10001010 + !byte $50,%00101100 + !byte $42,%00100011 + !byte $08,%00101001 + !byte $16,%01101101 + !byte $5C,%01001101 + !byte $42,%00101000 + !byte $14,%01001000 + !byte $28,%10001111 + !byte $3C,%00101100 + !byte $58,%01100101 + !byte $28,%10000101 + !byte $0E,%01110000 + !byte $40,%01001111 + !byte $4E,%11001001 + !byte $28,%10000000 + !byte $2E,%01110010 + !byte $4E,%11010011 + !byte $54,%10000010 + !byte $02,%10000110 + !byte $0E,%01101011 + !byte $44,%01001101 + !byte $4A,%10000001 + !byte $26,%01100110 + !byte $04,%10110000 + !byte $5C,%01010010 + !byte $4E,%11000100 + !byte $26,%01100001 + !byte $28,%11001100 + !byte $32,%10010000 + !byte $40,%01000000 + !byte $02,%10000001 + !byte $04,%10101011 + !byte $4E,%11001110 + !byte $40,%01000101 + !byte $22,%01000011 + !byte $08,%00110011 + !byte $32,%10001011 + !byte $30,%01100110 + !byte $2E,%01100011 + !byte $08,%00101110 + !byte $44,%01010010 + !byte $30,%01100001 + !byte $1A,%10000110 + !byte $16,%01110010 + !byte $4A,%10010000 + !byte $36,%11001001 + !byte $2E,%01101000 + !byte $1C,%10110000 + !byte $52,%00001101 + !byte $50,%00001001 + !byte $20,%00100010 + !byte $0A,%01001101 + !byte $50,%00110001 + !byte $48,%01100110 + !byte $22,%01001000 + !byte $22,%01010001 + !byte $52,%00010010 + !byte $50,%00000100 + !byte $0E,%01100001 + !byte $1C,%10101011 + !byte $56,%10101100 + !byte $36,%11000100 + !byte $16,%01100011 + !byte $0A,%01010010 + !byte $38,%00101100 + !byte $38,%00001001 + !byte $0E,%01100110 + !byte $10,%01101010 + !byte $58,%01001010 + !byte $5C,%01000011 + !byte $1A,%10000001 + !byte $0A,%01001100 + !byte $4A,%10001011 + !byte $4E,%00000010 + !byte $20,%00100111 + !byte $10,%01101111 + !byte $58,%01001111 + !byte $36,%00000010 + !byte $16,%01101000 + !byte $02,%10010000 + !byte $36,%11010011 + !byte $36,%00000111 + !byte $20,%01001001 + !byte $02,%10001011 + !byte $5E,%01101101 + !byte $4E,%00000111 + !byte $00,%01100110 + !byte $20,%01010011 + !byte $36,%11001110 + !byte $38,%00000100 + !byte $10,%01100000 + !byte $22,%01001101 + !byte $30,%01110000 + !byte $5C,%01001000 + !byte $10,%01100101 + !byte $1A,%10010000 + !byte $3E,%00101011 + !byte $58,%01000000 + !byte $08,%00100010 + !byte $28,%01101010 + !byte $5E,%01110010 + !byte $44,%01000011 + !byte $20,%01000100 + !byte $28,%01101111 + !byte $56,%00101011 + !byte $58,%01000101 + !byte $24,%01000111 + !byte $12,%00001101 + !byte $56,%00110000 + !byte $48,%01100001 + !byte $10,%11000111 + !byte $22,%01010010 + !byte $50,%00001110 + !byte $44,%01001000 + !byte $00,%01100001 + !byte $20,%01001110 + !byte $50,%00010011 + !byte $40,%00100000 + !byte $08,%00100111 + !byte $12,%00010010 + !byte $3E,%00110000 + !byte $3C,%00100111 + !byte $18,%01100110 + !byte $2A,%00010010 + !byte $38,%00110001 + !byte $3E,%00100001 + !byte $10,%11000010 + !byte $2A,%00001101 + !byte $46,%01101101 + !byte $5E,%01100011 + !byte $08,%01000100 + !byte $1A,%10001011 + !byte $40,%00101010 + !byte $3E,%10100111 + !byte $18,%01100001 + !byte $00,%01110000 + !byte $30,%01101011 + !byte $56,%00100110 + !byte $08,%01001001 + !byte $10,%01001010 + !byte $40,%00101111 + !byte $3E,%00100110 + !byte $28,%11000111 + !byte $08,%01010011 + !byte $48,%01110000 + !byte $56,%00100001 + !byte $28,%01100000 + !byte $00,%01101011 + !byte $46,%01110010 + !byte $5E,%01101000 + !byte $28,%11000010 + !byte $10,%01001111 + !byte $38,%00010011 + !byte $3A,%00100011 + !byte $28,%01100101 + !byte $08,%01001110 + !byte $38,%00001110 + !byte $40,%00100101 + !byte $10,%01000000 + !byte $18,%01110000 + !byte $48,%01101011 + !byte $46,%01100011 + !byte $10,%01000101 + !byte $2C,%00101101 + !byte $40,%11010001 + !byte $34,%11000110 + !byte $20,%01101001 + !byte $0A,%01010001 + !byte $58,%11010001 + !byte $3A,%00101000 + !byte $06,%00000010 + !byte $18,%01101011 + !byte $58,%00101010 + !byte $3C,%00100010 + !byte $20,%01100100 + !byte $14,%00101101 + !byte $58,%00101111 + !byte $46,%01101000 + !byte $1E,%00000010 + !byte $26,%01001011 + !byte $40,%11001100 + !byte $34,%11000001 + !byte $06,%00000111 + !byte $26,%01010000 + !byte $40,%00001010 + !byte $4C,%11000110 + !byte $1E,%00000111 + !byte $2C,%00110010 + !byte $4E,%00001100 + !byte $58,%00100000 + !byte $24,%01000010 + !byte $0E,%01010000 + !byte $4E,%00010001 + !byte $50,%00101001 + !byte $12,%00001000 + !byte $0E,%01001011 + !byte $58,%11001100 + !byte $4C,%11000001 + !byte $2A,%00000011 + !byte $14,%00110010 + !byte $54,%00010001 + !byte $50,%00100100 + !byte $12,%00000011 + !byte $20,%00101100 + !byte $40,%00001111 + !byte $58,%00100101 + !byte $2A,%00001000 + !byte $20,%01110011 + !byte $36,%00001100 + !byte $3E,%10100010 + !byte $26,%01000110 + !byte $28,%01001010 + !byte $36,%00010001 + !byte $56,%10100111 + !byte $0A,%01100011 + !byte $20,%01101110 + !byte $50,%00110011 + !byte $40,%00000101 + !byte $26,%01000001 + !byte $28,%01001111 + !byte $50,%00101110 + !byte $40,%00000000 + !byte $0A,%01101000 + !byte $2E,%01001101 + !byte $3A,%00101101 + !byte $32,%10100110 + !byte $0E,%01000001 + !byte $16,%01001101 + !byte $54,%00001100 + !byte $38,%00100100 + !byte $08,%01100100 + !byte $2E,%01010010 + !byte $3E,%00010000 + !byte $38,%00101001 + !byte $0E,%01000110 + !byte $10,%00101010 + !byte $3E,%00001011 + !byte $32,%10100001 + !byte $08,%01101001 + !byte $20,%00110001 + !byte $3A,%00110010 + !byte $4A,%10100110 + !byte $04,%11000110 + !byte $08,%00101100 + !byte $5A,%00010010 + !byte $4A,%10100001 + !byte $28,%01000101 + !byte $10,%00101111 + !byte $5A,%00001101 + !byte $30,%10000110 + !byte $1C,%11000110 + !byte $16,%01010010 + !byte $42,%00001101 + !byte $56,%10100010 + !byte $28,%01000000 + !byte $08,%01110011 + !byte $56,%00010000 + !byte $3E,%00000001 + !byte $04,%11000001 + !byte $08,%01101110 + !byte $56,%00001011 + !byte $3E,%00000110 + !byte $10,%00100000 + !byte $08,%00110001 + !byte $34,%11001011 + !byte $48,%10000110 + !byte $2C,%00101000 + !byte $0A,%01101101 + !byte $42,%00010010 + !byte $58,%00000101 + !byte $2C,%00100011 + !byte $1E,%00001100 + !byte $38,%00101110 + !byte $58,%00000000 + !byte $14,%00100011 + !byte $0A,%01110010 + !byte $34,%11010000 + !byte $30,%10000001 + !byte $10,%00100101 + !byte $1E,%00010001 + !byte $4C,%11010000 + !byte $40,%11000111 + !byte $22,%01101000 + !byte $20,%10001110 + !byte $38,%00110011 + !byte $52,%00100011 + !byte $1C,%11000001 + !byte $20,%10010011 + !byte $58,%00001111 + !byte $52,%00101000 + !byte $02,%10100110 + !byte $28,%00101111 + !byte $58,%00001010 + !byte $56,%00000001 + !byte $22,%01100011 + !byte $28,%00101010 + !byte $4C,%11001011 + !byte $56,%00000110 + !byte $02,%10100001 + !byte $06,%00010001 + !byte $5C,%00101101 + !byte $48,%10000001 + !byte $14,%00101000 + !byte $06,%00001100 + !byte $44,%00101101 + !byte $58,%11000111 + !byte $2E,%01000011 + !byte $22,%01101101 + !byte $32,%10110000 + !byte $40,%11000010 + !byte $1A,%10100110 + !byte $10,%00001111 + !byte $5C,%00110010 + !byte $50,%01000100 + !byte $16,%01000011 + !byte $10,%00001010 + !byte $4A,%10110000 + !byte $50,%01001001 + !byte $00,%10000110 + !byte $04,%11010000 + !byte $32,%10101011 + !byte $58,%11000010 + !byte $20,%10001001 + !byte $22,%01110010 + !byte $5E,%01001101 + !byte $54,%00000111 + !byte $2E,%01001000 + !byte $04,%11001011 + !byte $5E,%01010010 + !byte $5A,%00001000 + !byte $20,%10000100 + !byte $1C,%11010000 + !byte $30,%10010000 + !byte $5A,%00000011 + !byte $1A,%10100001 + !byte $1C,%11001011 + !byte $4A,%10101011 + !byte $38,%01000100 + !byte $00,%10000001 + !byte $02,%10110000 + !byte $46,%01001101 + !byte $42,%00000011 + !byte $18,%10000110 + !byte $1A,%10110000 + !byte $44,%00110010 + !byte $38,%01001001 + !byte $16,%01001000 + !byte $02,%10101011 + !byte $48,%10010000 + !byte $42,%00001000 + !byte $28,%00100000 + !byte $26,%00101011 + !byte $50,%01010011 + !byte $54,%00000010 + !byte $10,%00000000 + !byte $0E,%00110000 + !byte $30,%10001011 + !byte $5C,%00100011 + !byte $28,%00100101 + !byte $26,%00110000 + !byte $50,%01001110 + !byte $44,%00100011 + !byte $08,%10000100 + !byte $0E,%00101011 + !byte $46,%01010010 + !byte $5C,%00101000 + !byte $08,%10001001 + !byte $00,%10010000 + !byte $48,%10001011 + !byte $5E,%01000011 + !byte $18,%10000001 + !byte $08,%10010011 + !byte $52,%00101101 + !byte $46,%01000011 + !byte $10,%00000101 + !byte $00,%10001011 + !byte $3E,%11001010 + !byte $44,%00101000 + !byte $20,%10101001 + !byte $1A,%10101011 + !byte $3E,%11001111 + !byte $5E,%01001000 + !byte $0E,%00100001 + !byte $08,%10001110 + !byte $52,%00110010 + !byte $3E,%11000101 + !byte $20,%10100100 + !byte $18,%10010000 + !byte $38,%01001110 + !byte $3E,%11000000 + !byte $0E,%00100110 + !byte $20,%10110011 + !byte $38,%01010011 + !byte $50,%01100100 + !byte $26,%00100110 + !byte $20,%10101110 + !byte $56,%11001111 + !byte $46,%01001000 + !byte $26,%00100001 + !byte $28,%00001010 + !byte $56,%11001010 + !byte $50,%01101001 + !byte $28,%00000000 + !byte $18,%10001011 + !byte $50,%01110011 + !byte $56,%11000101 + !byte $0A,%10000011 + !byte $28,%00001111 + !byte $50,%01101110 + !byte $56,%11000000 + !byte $0A,%10001000 + !byte $08,%10101110 + !byte $3E,%10101111 + !byte $3A,%01000011 + !byte $28,%00000101 + !byte $08,%10110011 + !byte $3E,%10101010 + !byte $3A,%01001000 + !byte $20,%11000100 + !byte $20,%11010011 + !byte $38,%01110011 + !byte $50,%10001001 + !byte $20,%11001001 + !byte $0A,%10001101 + !byte $38,%01101110 + !byte $38,%01100100 + !byte $08,%10100100 + !byte $2E,%00101101 + !byte $3C,%00010001 + !byte $38,%01101001 + !byte $08,%10101001 + !byte $20,%11001110 + !byte $56,%10101010 + !byte $30,%10100110 + !byte $22,%10000011 + !byte $0A,%10010010 + !byte $50,%10010011 + !byte $48,%10100110 + !byte $22,%10001000 + !byte $0E,%00001011 + !byte $50,%10001110 + !byte $50,%10000100 + !byte $00,%10100110 + !byte $16,%00101101 + !byte $56,%10101111 + !byte $3E,%10100000 + !byte $0E,%00000001 + !byte $2E,%00110010 + !byte $3A,%01001101 + !byte $30,%10100001 + !byte $08,%11000100 + !byte $0E,%00010000 + !byte $3A,%01010010 + !byte $48,%10100001 + !byte $0E,%00000110 + !byte $16,%00110010 + !byte $3C,%00001100 + !byte $32,%11000110 + !byte $08,%11001001 + !byte $2C,%00001101 + !byte $30,%10110000 + !byte $3E,%10100101 + !byte $2E,%00100011 + !byte $22,%10010010 + !byte $5E,%00101101 + !byte $4A,%11000110 + !byte $00,%10100001 + !byte $26,%00010000 + !byte $48,%10110000 + !byte $32,%11000001 + !byte $26,%00000110 + !byte $22,%10001101 + !byte $5E,%00110010 + !byte $4A,%11000001 + !byte $18,%10100110 + !byte $14,%00001101 + !byte $32,%11010000 + !byte $34,%00000111 + !byte $26,%00000001 + !byte $14,%00010010 + !byte $30,%10101011 + !byte $4C,%00000010 + !byte $02,%11000110 + !byte $2C,%00010010 + !byte $3E,%10001111 + !byte $4C,%00000111 + !byte $16,%00100011 + !byte $26,%00001011 + !byte $5C,%00001101 + !byte $52,%01000011 + !byte $18,%10100001 + !byte $12,%11010001 + !byte $50,%10110011 + !byte $56,%10100000 + !byte $02,%11000001 + !byte $2A,%11010001 + !byte $3E,%10001010 + !byte $34,%00000010 + !byte $2E,%00101000 + !byte $2A,%11001100 + !byte $48,%10101011 + !byte $56,%10100101 + !byte $16,%00101000 + !byte $12,%11001100 + !byte $46,%00101101 + !byte $52,%01001000 + !byte $2C,%00000011 + !byte $08,%11010011 + !byte $38,%10010011 + !byte $4E,%00100010 + !byte $1A,%11000110 + !byte $08,%11001110 + !byte $52,%01001101 + !byte $38,%10000100 + !byte $1A,%11000001 + !byte $10,%10110001 + !byte $46,%00110010 + !byte $38,%10001001 + !byte $04,%00000111 + !byte $28,%10110001 + !byte $38,%10001110 + !byte $4E,%00100111 + !byte $2C,%00001000 + !byte $10,%10101100 + !byte $4A,%11010000 + !byte $36,%00100010 + !byte $14,%00000011 + !byte $00,%10110000 + !byte $52,%01010010 + !byte $50,%10101001 + !byte $14,%00001000 + !byte $0E,%11001010 + !byte $50,%10101110 + !byte $36,%00100111 + !byte $04,%00000010 + !byte $18,%10110000 + !byte $32,%11001011 + !byte $50,%10100100 + !byte $1C,%00000111 + !byte $00,%10101011 + !byte $5C,%00010010 + !byte $3E,%10000000 + !byte $0A,%10101000 + !byte $28,%10101100 + !byte $44,%00001101 + !byte $50,%01000010 + !byte $22,%10100011 + !byte $0E,%11001111 + !byte $44,%00010010 + !byte $3C,%00000111 + !byte $0A,%10100011 + !byte $0E,%10010001 + !byte $54,%11010000 + !byte $3C,%00000010 + !byte $22,%10101000 + !byte $18,%10101011 + !byte $4A,%11001011 + !byte $3E,%10000101 + !byte $1C,%00000010 + !byte $02,%11010000 + !byte $56,%10001010 + !byte $5E,%00100011 + !byte $0E,%11000000 + !byte $26,%11001111 + !byte $34,%00010001 + !byte $5E,%00101000 + !byte $0E,%11000101 + !byte $1A,%11010000 + !byte $4C,%00010001 + !byte $38,%01000010 + !byte $2A,%11000010 + !byte $22,%10101101 + !byte $4C,%00001100 + !byte $50,%01000111 + !byte $12,%11000010 + !byte $02,%11001011 + !byte $34,%00001100 + !byte $46,%00100011 + !byte $12,%11000111 + !byte $22,%10110010 + !byte $56,%10001111 + !byte $50,%11001001 + !byte $2A,%11000111 + !byte $26,%11001010 + !byte $5A,%11001100 + !byte $38,%10100100 + !byte $06,%00100010 + !byte $0A,%10101101 + !byte $54,%11001011 + !byte $38,%10101001 + !byte $1E,%00100111 + !byte $0A,%10110010 + !byte $42,%11010001 + !byte $56,%10000101 + !byte $26,%11000101 + !byte $1A,%11001011 + !byte $5A,%11010001 + !byte $46,%00101000 + !byte $1E,%00100010 + !byte $04,%00010001 + !byte $42,%11001100 + !byte $50,%11000100 + !byte $06,%00100111 + !byte $26,%10010001 + !byte $3E,%01101010 + !byte $56,%10000000 + !byte $26,%11000000 + !byte $04,%00001100 + !byte $3E,%01101111 + !byte $5C,%00000011 + !byte $10,%10100111 + !byte $1C,%00010001 + !byte $50,%11010011 + !byte $3A,%01100011 + !byte $0E,%10100000 + !byte $0E,%10101010 + !byte $50,%11001110 + !byte $3A,%01101000 + !byte $0E,%10100101 + !byte $1C,%00001100 + !byte $38,%10101110 + !byte $3E,%01100000 + !byte $22,%11000011 + !byte $0E,%10101111 + !byte $38,%10110011 + !byte $5C,%00001000 + !byte $0A,%11000011 + !byte $0E,%10001100 + !byte $4E,%00101100 + !byte $44,%00000011 + !byte $22,%11001000 + !byte $24,%00110001 + !byte $4E,%00110001 + !byte $3E,%01100101 + !byte $20,%01000010 + !byte $26,%10101010 + !byte $36,%00101100 + !byte $54,%11000110 + !byte $10,%10100010 + !byte $2E,%00001101 + !byte $36,%00110001 + !byte $38,%01000111 + !byte $28,%10100111 + !byte $26,%10101111 + !byte $40,%10110001 + !byte $44,%00001000 + !byte $0A,%11001000 + !byte $16,%00001101 + !byte $3A,%01101101 + !byte $54,%11000001 + !byte $00,%11000110 + !byte $22,%11010010 + !byte $3A,%01110010 + !byte $52,%01100010 + !byte $28,%10100010 + !byte $22,%11001101 + !byte $56,%01101111 + !byte $52,%01100011 + !byte $08,%01000010 + !byte $0E,%10001010 + !byte $56,%01101010 + !byte $38,%11000100 + !byte $18,%11000110 + !byte $0C,%01010001 + !byte $58,%10110001 + !byte $38,%11001001 + !byte $26,%10100000 + !byte $06,%00101100 + !byte $58,%10101100 + !byte $52,%01101000 + !byte $26,%10100101 + !byte $0A,%11001101 + !byte $40,%10101100 + !byte $30,%11000110 + !byte $00,%11000001 + !byte $0A,%11010010 + !byte $3E,%01001111 + !byte $56,%01100101 + !byte $0E,%10000000 + !byte $2E,%00010010 + !byte $3E,%01001010 + !byte $3E,%01000000 + !byte $0E,%10000101 + !byte $24,%00101100 + !byte $38,%11010011 + !byte $5A,%11000111 + !byte $20,%01000111 + !byte $16,%00010010 + !byte $38,%11001110 + !byte $56,%01100000 + !byte $08,%01000111 + !byte $1E,%00101100 + !byte $52,%01101101 + !byte $42,%11000010 + !byte $18,%11000001 + !byte $06,%00110001 + !byte $52,%01110010 + !byte $42,%11000111 + !byte $2E,%00000011 + !byte $1E,%00110001 + !byte $3E,%00101010 + !byte $48,%11000110 + !byte $16,%00000011 + !byte $26,%10001100 + !byte $3C,%11010000 + !byte $5A,%11000010 + !byte $22,%00000100 + !byte $0E,%10001111 + !byte $56,%01001111 + !byte $3E,%01000101 + !byte $02,%00000111 + !byte $00,%11010000 + !byte $56,%01001010 + !byte $30,%11000001 + !byte $22,%00001001 + !byte $00,%11001011 + !byte $30,%11010000 + !byte $48,%11000001 + !byte $26,%10000000 + !byte $26,%10001111 + !byte $50,%01001100 + !byte $3E,%00100000 + !byte $02,%00000010 + !byte $2C,%11001100 + !byte $5E,%00001101 + !byte $32,%00000111 + !byte $16,%00001000 + !byte $14,%11001100 + !byte $48,%11010000 + !byte $4A,%00000111 + !byte $2E,%00001000 + !byte $18,%11010000 + !byte $3E,%00101111 + !byte $56,%01000000 + !byte $0A,%00000100 + !byte $26,%10001010 + !byte $30,%11001011 + !byte $56,%01000101 + !byte $0A,%00001001 + !byte $2C,%11010001 + !byte $5E,%00010010 + !byte $32,%00000010 + !byte $24,%00100111 + !byte $0E,%01101010 + !byte $3C,%11001011 + !byte $3E,%00100101 + !byte $0E,%01100000 + !byte $14,%11010001 + !byte $48,%11001011 + !byte $4A,%00000010 + !byte $0E,%01100101 + !byte $22,%00010011 + !byte $46,%00001101 + !byte $3A,%10000011 + !byte $1A,%00000111 + !byte $0E,%01101111 + !byte $46,%00010010 + !byte $3A,%10001000 + !byte $26,%10000101 + !byte $22,%00001110 + !byte $38,%01001100 + !byte $52,%10001000 + !byte $1A,%00000010 + !byte $0C,%01001100 + !byte $50,%01010001 + !byte $5E,%00000011 + !byte $24,%00100010 + !byte $18,%11001011 + !byte $54,%10110000 + !byte $58,%10100111 + !byte $0E,%01000101 + !byte $0A,%00001110 + !byte $56,%00101010 + !byte $52,%10000011 + !byte $22,%00100100 + !byte $0A,%00010011 + !byte $3E,%10010001 + !byte $40,%10100111 + !byte $22,%00101001 + !byte $02,%00010001 + !byte $3E,%00001010 + !byte $3C,%11000110 + !byte $0E,%01000000 + !byte $26,%01101010 + !byte $3E,%00001111 + !byte $40,%10100010 + !byte $0E,%10000111 + !byte $0E,%01001010 + !byte $56,%00101111 + !byte $56,%00100101 + !byte $2C,%11000010 + !byte $0E,%01001111 + !byte $54,%10101011 + !byte $3E,%00000000 + !byte $14,%11000010 + !byte $26,%01101111 + !byte $32,%00010001 + !byte $58,%10100010 + !byte $2C,%11000111 + !byte $02,%00001100 + !byte $3A,%10001101 + !byte $56,%00100000 + !byte $26,%01100000 + !byte $1A,%00010001 + !byte $3A,%10010010 + !byte $3C,%11000001 + !byte $14,%11000111 + !byte $22,%00101110 + !byte $4A,%00010001 + !byte $3E,%00000101 + !byte $26,%01100101 + !byte $22,%00110011 + !byte $38,%01010001 + !byte $3A,%01100010 + !byte $04,%00100111 + !byte $20,%01001100 + !byte $52,%10010010 + !byte $5E,%00001000 + !byte $0A,%00101001 + !byte $1A,%00001100 + !byte $52,%10001101 + !byte $46,%00000011 + !byte $0A,%00100100 + !byte $08,%01001100 + !byte $56,%10010001 + !byte $54,%10100110 + !byte $1C,%00100111 + !byte $0E,%00101010 + !byte $5C,%11001100 + !byte $4C,%00100111 + !byte $04,%00100010 + !byte $0E,%00101111 + !byte $32,%00001100 + !byte $34,%00100111 + !byte $0C,%01000111 + !byte $20,%01010001 + !byte $4A,%00001100 + !byte $4C,%00100010 + !byte $1C,%00100010 + !byte $2A,%10101100 + !byte $44,%11001100 + !byte $34,%00100010 + !byte $0E,%00100000 + !byte $0A,%00101110 + !byte $5C,%11010001 + !byte $46,%00001000 + !byte $22,%01001001 + !byte $0A,%00110011 + !byte $56,%00001010 + !byte $54,%10100001 + !byte $22,%01000100 + !byte $2A,%10110001 + !byte $44,%11010001 + !byte $56,%00000101 + !byte $0E,%00100101 + !byte $26,%01001010 + !byte $3E,%10001100 + !byte $52,%01100111 + !byte $26,%10000111 + !byte $12,%10101100 + !byte $56,%00001111 + !byte $56,%00000000 + !byte $26,%01000000 + !byte $12,%10110001 + !byte $56,%10001100 + !byte $3A,%10100011 + !byte $26,%01000101 + !byte $26,%01001111 + !byte $3C,%10110000 + !byte $52,%10101000 + !byte $00,%00000111 + !byte $08,%01010001 + !byte $3A,%10110010 + !byte $52,%10100011 + !byte $0C,%01000010 + !byte $22,%01010011 + !byte $52,%10110010 + !byte $3A,%10101000 + !byte $0A,%01000100 + !byte $22,%01001110 + !byte $52,%10101101 + !byte $30,%00000111 + !byte $00,%00000010 + !byte $0E,%00001010 + !byte $3A,%10101101 + !byte $5C,%11000010 + !byte $0A,%01001001 + !byte $0E,%00001111 + !byte $3C,%10101011 + !byte $5C,%11000111 + !byte $18,%00000111 + !byte $2E,%11001100 + !byte $34,%00110001 + !byte $44,%11000010 + !byte $18,%00000010 + !byte $16,%11001100 + !byte $4C,%00110001 + !byte $48,%00000111 + !byte $0E,%10000010 + !byte $0A,%01001110 + !byte $34,%00101100 + !byte $30,%00000010 + !byte $0E,%00000101 + !byte $04,%00110001 + !byte $4C,%00101100 + !byte $44,%11000111 + !byte $22,%01100100 + !byte $26,%00101111 + !byte $30,%00010001 + !byte $3C,%10100110 + !byte $0E,%00000000 + !byte $26,%00101010 + !byte $54,%10010000 + !byte $48,%00000010 + !byte $22,%01101001 + !byte $0A,%01010011 + !byte $54,%10001011 + !byte $3C,%10100001 + !byte $26,%00100000 + !byte $2E,%11010001 + !byte $5A,%10101100 + !byte $52,%11001000 + !byte $26,%00100101 + !byte $04,%00101100 + !byte $42,%10101100 + !byte $3A,%11001000 + !byte $22,%01100010 + !byte $22,%01101110 + !byte $42,%10110001 + !byte $52,%11000011 + !byte $26,%10000010 + !byte $1C,%00110001 + !byte $5A,%10110001 + !byte $3A,%11000011 + !byte $0A,%01100100 + !byte $1C,%00101100 + !byte $48,%00010001 + !byte $54,%10000110 + !byte $12,%10100111 + !byte $16,%11010001 + !byte $30,%00001100 + !byte $3A,%01100111 + !byte $12,%10100010 + !byte $22,%01110011 + !byte $52,%11010010 + !byte $54,%10000001 + !byte $0A,%01101001 + !byte $00,%00010001 + !byte $5E,%11001100 + !byte $4E,%01000010 + !byte $22,%10001001 + !byte $00,%00001100 + !byte $52,%11001101 + !byte $36,%01000010 + !byte $22,%10000100 + !byte $18,%00010001 + !byte $5E,%11010001 + !byte $4E,%01000111 + !byte $2A,%10100111 + !byte $26,%00001010 + !byte $48,%00001100 + !byte $36,%01000111 + !byte $2A,%10100010 + !byte $26,%00001111 + !byte $3A,%11010010 + !byte $52,%00001001 + !byte $16,%11000010 + !byte $0A,%01110011 + !byte $46,%11001100 + !byte $52,%00000100 + !byte $0A,%01100010 + !byte $22,%10010011 + !byte $3A,%11001101 + !byte $4A,%00100111 + !byte $16,%11000111 + !byte $22,%10001110 + !byte $46,%11010001 + !byte $3E,%10000111 + !byte $2E,%11000111 + !byte $0A,%01101110 + !byte $52,%00010011 + !byte $4A,%00100010 + !byte $26,%00000000 + !byte $24,%00010001 + !byte $52,%00001110 + !byte $5E,%11000010 + !byte $02,%00100111 + !byte $18,%00001100 + !byte $3C,%10001011 + !byte $32,%00100010 + !byte $26,%00000101 + !byte $24,%00001100 + !byte $3C,%10010000 + !byte $32,%00100111 + !byte $2E,%11000010 + !byte $0A,%10010011 + !byte $54,%01110000 + !byte $56,%10000111 + !byte $06,%01000010 + !byte $0A,%10001110 + !byte $54,%01101011 + !byte $46,%11000010 + !byte $0A,%10000100 + !byte $22,%10110011 + !byte $3A,%00001110 + !byte $5A,%10100010 + !byte $06,%01000111 + !byte $22,%10101110 + !byte $3A,%00010011 + !byte $3C,%10000001 + !byte $0A,%10001001 + !byte $14,%10110001 + !byte $4A,%00110001 + !byte $3C,%10000110 + !byte $1A,%00100111 + !byte $14,%10101100 + !byte $4A,%00101100 + !byte $5A,%10100111 + !byte $22,%10101001 + !byte $02,%00110001 + !byte $52,%00110011 + !byte $3A,%00000100 + !byte $22,%10100100 + !byte $22,%11010011 + !byte $52,%00101110 + !byte $42,%10100010 + !byte $1E,%01000010 + !byte $2C,%10101100 + !byte $32,%00110001 + !byte $3A,%00001001 + !byte $02,%00100010 + !byte $2C,%10110001 + !byte $32,%00101100 + !byte $52,%00100100 + !byte $1E,%01000111 + !byte $22,%11001110 + !byte $4E,%01001100 + !byte $5E,%11000111 + !byte $24,%00000111 + !byte $0A,%10101110 + !byte $5C,%10101100 + !byte $42,%10100111 + !byte $1A,%00100010 + !byte $0A,%10110011 + !byte $4E,%01010001 + !byte $52,%00101001 + !byte $22,%11001001 + !byte $02,%00101100 + !byte $3C,%01110000 + !byte $54,%01100001 + !byte $0A,%10100100 + !byte $10,%10010001 + !byte $5C,%10110001 + !byte $54,%01100110 + !byte $0A,%10101001 + !byte $1A,%00110001 + !byte $3C,%01101011 + !byte $3E,%10000010 + !byte $22,%11000100 + !byte $28,%10010001 + !byte $3A,%00110011 + !byte $46,%11000111 + !byte $24,%00000010 + !byte $10,%10001100 + !byte $52,%01010011 + !byte $56,%10000010 + !byte $22,%01100111 + !byte $1A,%00101100 + !byte $52,%01001110 + !byte $3A,%00100100 + !byte $00,%00100111 + !byte $0C,%00110001 + !byte $36,%01001100 + !byte $3A,%00101001 + !byte $0A,%11000100 + !byte $0A,%11001110 + !byte $36,%01010001 + !byte $52,%01001001 + !byte $0A,%11001001 + !byte $0A,%11010011 + !byte $3A,%00101110 + !byte $52,%01000100 + !byte $0A,%01100111 + !byte $28,%10001100 + !byte $44,%10101100 + !byte $48,%00100111 + !byte $14,%10100010 + !byte $06,%01001100 + !byte $44,%10110001 + !byte $30,%00100111 + !byte $2C,%10100010 + !byte $0C,%00101100 + !byte $54,%01010000 + !byte $3C,%01100110 + !byte $00,%00100010 + !byte $1E,%01001100 + !byte $52,%01110011 + !byte $3C,%01100001 + !byte $18,%00100111 + !byte $06,%01010001 + !byte $54,%01001011 + !byte $48,%00100010 + !byte $18,%00100010 + !byte $1E,%01010001 + !byte $52,%01101110 + !byte $30,%00100010 + !byte $14,%10100111 + !byte $2E,%10101100 + !byte $3C,%01010000 + !byte $52,%01101001 + !byte $2C,%10100111 + !byte $16,%10101100 + !byte $3C,%01001011 + !byte $52,%01100100 + !byte $0C,%00100111 + !byte $24,%11010000 + !byte $30,%00110001 + !byte $3A,%01000100 + !byte $0C,%00100010 + !byte $00,%00110001 + !byte $3A,%01010011 + !byte $3A,%01001001 + !byte $04,%01000010 + !byte $18,%00110001 + !byte $58,%10010001 + !byte $3C,%01000110 + !byte $04,%01000111 + !byte $2E,%10110001 + !byte $40,%10010001 + !byte $54,%01000110 + !byte $1C,%01000111 + !byte $24,%11001011 + !byte $48,%00110001 + !byte $54,%01000001 + !byte $1C,%01000010 + !byte $16,%10110001 + !byte $52,%01101100 + !byte $3C,%01000001 + !byte $24,%11000110 + !byte $00,%00101100 + !byte $3A,%01001110 + !byte $34,%01000111 + !byte $24,%11000001 + !byte $18,%00101100 + !byte $52,%10001110 + !byte $4C,%01000111 + !byte $16,%10100010 + !byte $04,%01010001 + !byte $40,%10001100 + !byte $34,%01000010 + !byte $2E,%10100010 + !byte $04,%01001100 + !byte $52,%10010011 + !byte $52,%10000100 + !byte $28,%10000111 + !byte $0C,%00010001 + !byte $30,%00101100 + !byte $52,%10001001 + !byte $10,%10000111 + !byte $0C,%00001100 + !byte $58,%10001100 + !byte $5C,%10100010 + !byte $10,%10000010 + !byte $1C,%01010001 + !byte $3A,%01101110 + !byte $44,%10100010 + !byte $16,%10100111 + !byte $12,%10010001 + !byte $3A,%01110011 + !byte $4C,%01000010 + !byte $02,%01000111 + !byte $1C,%01001100 + !byte $54,%00110000 + !byte $5C,%10100111 + !byte $2E,%10100111 + !byte $12,%10001100 + !byte $48,%00101100 + !byte $3A,%01101001 + !byte $02,%01000010 + !byte $2A,%10010001 + !byte $3C,%00101011 + !byte $44,%10100111 + !byte $28,%10000010 + !byte $2A,%10001100 + !byte $3C,%00110000 + !byte $52,%10100100 + !byte $0C,%00000111 + !byte $24,%10110000 + !byte $5E,%10101100 + !byte $3A,%01100100 + !byte $1A,%01000111 + !byte $24,%10101011 + !byte $46,%10101100 + !byte $52,%10101001 + !byte $0C,%00000010 + !byte $02,%01010001 + !byte $52,%10110011 + !byte $3C,%00100110 + !byte $1A,%01000010 + !byte $22,%01101100 + !byte $54,%00101011 + !byte $54,%00100110 + !byte $00,%01000111 + !byte $0A,%01101100 + !byte $5E,%10110001 + !byte $54,%00100001 + !byte $08,%01100010 + !byte $0C,%11010000 + !byte $52,%10101110 + !byte $3C,%00100001 + !byte $24,%10100001 + !byte $0C,%11001011 + !byte $46,%10110001 + !byte $3A,%10000100 + !byte $24,%10100110 + !byte $02,%01001100 + !byte $52,%11010011 + !byte $3A,%10001001 + !byte $00,%01000010 + !byte $14,%10001100 + !byte $3A,%10001110 + !byte $52,%11001001 + !byte $0C,%11000110 + !byte $14,%10010001 + !byte $3A,%01101100 + !byte $52,%11000100 + !byte $20,%01100010 + !byte $1A,%01010001 + !byte $3A,%10010011 + !byte $5E,%10100010 + !byte $18,%01000111 + !byte $00,%01010001 + !byte $52,%11001110 + !byte $3A,%10100100 + !byte $12,%10000010 + !byte $24,%10010000 + !byte $54,%00010000 + !byte $3C,%00000110 + !byte $12,%10000111 + !byte $24,%10001011 + !byte $34,%01010001 + !byte $54,%00000110 + !byte $0C,%11000001 + !byte $1A,%01001100 + !byte $4C,%01010001 + !byte $54,%00000001 + !byte $08,%01100111 + !byte $2C,%10001100 + !byte $54,%00001011 + !byte $3C,%00000001 + !byte $24,%10000110 + !byte $00,%01001100 + !byte $3C,%00001011 + !byte $3A,%10101001 + !byte $18,%01000010 + !byte $2C,%10010001 + !byte $3C,%00010000 + !byte $4A,%01000111 + !byte $20,%01100111 + !byte $0C,%10110000 + !byte $4C,%01001100 + !byte $46,%10100010 + !byte $24,%10000001 + !byte $0C,%10101011 + !byte $34,%01001100 + !byte $32,%01000111 + !byte $0C,%10100110 + !byte $16,%10001100 + !byte $3A,%10101110 + !byte $5E,%10100111 + !byte $2A,%10000111 + !byte $18,%01010001 + !byte $3A,%10110011 + !byte $4A,%01000010 + !byte $2A,%10000010 + !byte $16,%10010001 + !byte $3C,%11001111 + !byte $46,%10100111 + !byte $0C,%10100001 + !byte $0C,%10001011 + !byte $3C,%11001010 + !byte $32,%01000010 + !byte $0C,%10000001 + !byte $0C,%10010000 + !byte $54,%11001111 + !byte $3C,%11000000 + !byte $14,%10000010 + !byte $24,%01110000 + !byte $54,%11001010 + !byte $3C,%11000101 + !byte $0C,%10000110 + !byte $24,%01101011 + !byte $5A,%10010001 + !byte $58,%10000111 + !byte $24,%01100110 + !byte $18,%01001100 + !byte $5A,%10001100 + !byte $50,%01100010 + !byte $24,%01100001 + !byte $0C,%01110000 + !byte $3C,%10101111 + !byte $3A,%11000100 + !byte $0C,%01100001 + !byte $2E,%10010001 + !byte $4A,%01010001 + !byte $3A,%11001001 + !byte $2C,%10000010 + !byte $2E,%10001100 + !byte $3C,%10101010 + !byte $58,%10000010 + !byte $14,%10000111 + !byte $0C,%01101011 + !byte $3A,%11010011 + !byte $40,%10000111 + !byte $06,%01100010 + !byte $22,%01110001 + !byte $3A,%11001110 + !byte $54,%11000101 + !byte $0C,%01100110 + !byte $0A,%01110001 + !byte $54,%10101111 + !byte $54,%11000000 + !byte $2C,%10000111 + !byte $24,%01010000 + !byte $54,%10101010 + !byte $3C,%10100000 + !byte $1E,%01100010 + !byte $0C,%01010000 + !byte $42,%10010001 + !byte $48,%01000111 + !byte $06,%01100111 + !byte $24,%01001011 + !byte $42,%10001100 + !byte $3C,%10100101 + !byte $1E,%01100111 + !byte $0C,%01001011 + !byte $3C,%10001111 + !byte $40,%10000010 + !byte $0C,%01000001 + !byte $24,%00110000 + !byte $4A,%01001100 + !byte $38,%01100010 + !byte $0C,%01000110 + !byte $24,%00101011 + !byte $3C,%10001010 + !byte $54,%10100101 + !byte $24,%01000110 + !byte $0C,%00110000 + !byte $32,%01010001 + !byte $54,%10100000 + !byte $24,%01000001 + !byte $0C,%00101011 + !byte $54,%10001111 + !byte $50,%01100111 + !byte $16,%10000010 + !byte $24,%00010000 + !byte $54,%10001010 + !byte $48,%01000010 + !byte $2E,%10000010 + !byte $24,%00001011 + !byte $3C,%01101111 + !byte $3C,%10000101 + !byte $0C,%00100001 + !byte $0C,%00001011 + !byte $3C,%01101010 + !byte $3C,%10000000 + !byte $0C,%00100110 + !byte $0C,%00010000 + !byte $52,%01110001 + !byte $30,%01000111 + !byte $24,%00100110 + !byte $20,%01101100 + !byte $32,%01001100 + !byte $54,%10000000 + !byte $24,%00100001 + !byte $08,%01101100 + !byte $54,%01101111 + !byte $54,%10000101 + !byte $16,%10000111 + !byte $0C,%11001111 + !byte $5C,%10001100 + !byte $3C,%01100000 + !byte $2E,%10000111 + !byte $24,%11001111 + !byte $54,%01101010 + !byte $30,%01000010 + !byte $0C,%00000001 + !byte $24,%11001010 + !byte $48,%01010001 + !byte $3C,%01100101 + !byte $0C,%00000110 + !byte $0C,%11001010 + !byte $5C,%10010001 + !byte $38,%01100111 + !byte $24,%00000110 + !byte $24,%10101111 + !byte $3C,%01001010 + !byte $54,%01100101 + !byte $24,%00000001 + !byte $0C,%10101111 + !byte $3C,%01001111 + !byte $54,%01100000 + !byte $04,%01100111 + !byte $24,%10101010 + !byte $54,%01001111 + !byte $3C,%01000000 + !byte $04,%01100010 + !byte $0C,%10101010 + !byte $48,%01001100 + !byte $5A,%10000111 + !byte $1C,%01100111 + !byte $20,%01110001 + !byte $30,%01010001 + !byte $5A,%10000010 + !byte $1C,%01100010 + !byte $0C,%10001111 + !byte $54,%01001010 + !byte $3C,%01000101 + !byte $0C,%11000000 + !byte $24,%10001111 + !byte $3C,%00101010 + !byte $3C,%00100101 + !byte $24,%11000000 + !byte $08,%01110001 + !byte $3C,%00101111 + !byte $54,%01000101 + !byte $0C,%11000101 + !byte $24,%10001010 + !byte $44,%10001100 + !byte $54,%01000000 + !byte $24,%11000101 + !byte $0C,%10001010 + !byte $44,%10010001 + !byte $3C,%00100000 + !byte $0C,%10100000 + !byte $24,%01101111 + !byte $5E,%10001100 + !byte $42,%10000010 + !byte $24,%10100000 + !byte $1E,%01101100 + !byte $54,%00101111 + !byte $42,%10000111 + !byte $02,%01100010 + !byte $06,%01101100 + !byte $30,%01001100 + !byte $3C,%00000101 + !byte $02,%01100111 + !byte $0C,%01101111 + !byte $3C,%00001111 + !byte $54,%00100000 + !byte $1A,%01100111 + !byte $1E,%01110001 + !byte $54,%00101010 + !byte $3C,%00000000 + !byte $1A,%01100010 + !byte $24,%01101010 + !byte $3C,%00001010 + !byte $4E,%01100010 + !byte $0C,%10100101 + !byte $0C,%01101010 + !byte $3A,%01110001 + !byte $54,%00100101 + !byte $24,%10100101 + !byte $06,%01110001 + !byte $5E,%10010001 + !byte $5C,%10000010 + !byte $0C,%10000000 + !byte $24,%01001111 + !byte $46,%10001100 + !byte $36,%01100010 + !byte $24,%10000000 + !byte $24,%01001010 + !byte $54,%00001111 + !byte $4E,%01100111 + !byte $0C,%10000101 + !byte $0C,%01001010 + !byte $46,%10010001 + !byte $44,%10000010 + !byte $24,%10000101 + !byte $0C,%01001111 + !byte $54,%00001010 + !byte $36,%01100111 + !byte $00,%01100111 + !byte $1C,%01110001 + !byte $50,%01101100 + !byte $5C,%10000111 + !byte $18,%01100111 + !byte $1C,%01101100 + !byte $38,%01101100 + !byte $54,%00000000 + !byte $00,%01100010 + !byte $04,%01101100 + !byte $50,%01110001 + !byte $44,%10000111 + !byte $18,%01100010 + !byte $04,%01110001 + !byte $38,%01110001 + !byte $54,%00000101 + !byte $0C,%01100000 + !byte $24,%00101111 + !byte $4E,%01101100 + !byte $46,%10000010 + !byte $0C,%01100101 + !byte $24,%00101010 + !byte $36,%01101100 + !byte $5E,%10000010 + !byte $24,%01100101 + !byte $0C,%00101010 + !byte $4E,%01110001 + !byte $46,%10000111 + !byte $24,%01100000 + !byte $0C,%00101111 + !byte $36,%01110001 + !byte $5E,%10000111 + !byte $0C,%01000000 + !byte $1A,%01110001 + !byte $4C,%01110001 + !byte $34,%01100010 + !byte $0C,%01000101 + !byte $1A,%01101100 + !byte $4C,%01101100 + !byte $34,%01100111 + !byte $24,%01000101 + !byte $02,%01101100 + !byte $34,%01101100 + !byte $4C,%01100111 + !byte $24,%01000000 + !byte $02,%01110001 + !byte $34,%01110001 + !byte $4C,%01100010 + !byte $0C,%00100000 + !byte $24,%00001111 + !byte $4A,%01110001 + !byte $32,%01100111 + !byte $0C,%00100101 + !byte $24,%00001010 + !byte $4A,%01101100 + !byte $4A,%01100111 + !byte $24,%00100101 + !byte $0C,%00001010 + !byte $32,%01101100 + !byte $32,%01100010 + !byte $24,%00100000 + !byte $0C,%00001111 + !byte $32,%01110001 + !byte $4A,%01100010 + !byte $0C,%00000000 + !byte $18,%01110001 + !byte $48,%01110001 + !byte $30,%01100111 + !byte $0C,%00000101 + !byte $18,%01101100 + !byte $48,%01101100 + !byte $48,%01100111 + !byte $24,%00000101 + !byte $00,%01101100 + !byte $30,%01101100 + !byte $30,%01100010 + !byte $24,%00000000 + !byte $00,%01110001 + !byte $30,%01110001 + !byte $48,%01100010 diff --git a/src/fx/fx.hgr.precomputed.1bit.a b/src/fx/fx.hgr.precomputed.1bit.a new file mode 100644 index 0000000..da037eb --- /dev/null +++ b/src/fx/fx.hgr.precomputed.1bit.a @@ -0,0 +1,341 @@ +;license:MIT +;(c) 2019 by 4am +; +copymasks = $0200 ; $100 bytes but sparse, index is 0..6 but in high 3 bits, so $00, $20, $40, $60, $80, $A0, $C0 +mirror_copymasks = $0201 +hgrlo = $0300 ; $C0 bytes +hgrlomirror = $BD40 ; $C0 bytes +mirror_cols = $BE00 ; $28 bytes +hgr1hi = $BE40 ; $C0 bytes +hgr1himirror = $BF40 ; $C0 bytes +Coordinates1Bit= $8600 ; $3481 bytes ($3480 on disk + 1 byte EOF marker) +EndCoordinates1Bit=Coordinates1Bit+$3480 + + !source "src/fx/macros.a" + +!macro BUILD_MIRROR_COLS .mirror_cols { + ; build lookup table to get $27-y for y in $00..$27 + ldx #$28 + ldy #$00 +- tya + sta .mirror_cols-1, x + iny + dex + bne - +; X=0 +} + +!macro BUILD_SPARSE_BITMASKS .copymasks, .mirror_copymasks { + ; build sparse lookup tables for bitmasks + lda #%10000001 + sta .copymasks + sta .mirror_copymasks+$C0 + + lda #%10000010 + sta .copymasks+$20 + sta .mirror_copymasks+$A0 + + lda #%10000100 + sta .copymasks+$40 + sta .mirror_copymasks+$80 + + lda #%10001000 + sta .copymasks+$60 + sta .mirror_copymasks+$60 + + lda #%10010000 + sta .copymasks+$80 + sta .mirror_copymasks+$40 + + lda #%10100000 + sta .copymasks+$A0 + sta .mirror_copymasks+$20 + + lda #%11000000 + sta .copymasks+$C0 + sta .mirror_copymasks +} + +!macro ROW_X_TO_BASE_ADDRESSES { + lda hgrlo, x + sta Coordinates1Bit + sta $f1 + lda #<(EndCoordinates1Bit - 2) + sta $f2 + lda #>(EndCoordinates1Bit - 2) + sta $f3 + clc + !byte $24 +- sec +-- lda ($f0), y + pha + lda ($f2), y + sta ($f0), y + pla + sta ($f2), y + iny + bcc - + ldy #0 + !byte $24 +- clc + inc $f0 + bne + + inc $f1 ++ lda $f1 + eor #>(Coordinates1Bit + $1A40) + bne + + lda $f0 + eor #<(Coordinates1Bit + $1A40) + beq ++ ++ lda $f2 + bne + + dec $f3 ++ dec $f2 + bcs - + bcc -- ; always +++ +} + +!macro FX_RIPPLE_1BIT .target { + lda #2 ; <(Coordinates1Bit + 2) + sta $f0 + ldy #0 + sty $f1 + lda #$16 ; <(Coordinates1Bit + 22) + sta $f2 + sty $f3 + + lda #$1f + sta $ee + lda #$0d + sta $ef + + lda Coordinates1Bit + 2 + sta $e0 + lda Coordinates1Bit + 3 + sta $e1 + lda Coordinates1Bit + 22 + sta $e2 + lda Coordinates1Bit + 23 + sta $e3 + +--- ldx #4 +-- ldy $ee, x + lda $ef, x + jsr .target + sty $ee, x + sta $ef, x + sty $ec + clc + adc #>Coordinates1Bit + sta $ed + ldy #0 + !byte $24 +- sec + lda ($ec), y + pha + lda $de, x + sta ($ec), y + pla + sta $de, x + inx + iny + bcc - + dex + dex + dex + dex + bne -- + dec $ee + bne --- + dec $ef + bpl --- + bmi +++ ; always branches +aslmod4 jsr aslmod +aslmod3 jsr aslmod +aslmod2 jsr aslmod +aslmod cmp #$1A + bcc + + bne ++ + cpy #$40 + bcc + +++ iny ++ pha + tya + asl + tay + pla + rol + cmp #$34 + bcc + + bne ++ + cpy #$80 + bcc + +++ pha + tya + sbc #$80 + tay + pla + sbc #$34 ++ rts ++++ +} + +!macro FX_PRECOMPUTED_1BIT .coords { + +BUILD_HGR_LOOKUP_TABLES hgrlo, hgr1hi + +BUILD_HGR_MIRROR_LOOKUP_TABLES hgrlomirror, hgr1himirror + +BUILD_MIRROR_COLS mirror_cols + +BUILD_SPARSE_BITMASKS copymasks, mirror_copymasks + ldx #(end-start) ; copy InputLoop code to zero page +- lda start-1, x + sta $FF, x + dex + bne - + jmp InputLoop +start +!pseudopc 0 { +Exit1Bit rts +InputLoop + ldy #0 +input=*+1 + ldx .coords, y ; first value: HGR row (only 0..95 will be in input array) + bmi Exit1Bit ; if > 127 then we're done + +ROW_X_TO_BASE_ADDRESSES + +ROW_X_TO_MIRROR_ADDRESSES + + inc input + lda (input), y + +HIGH_3_LOW_5 input + + ; main 1x2 block in top-left quadrant +src1=*+1 + lda $FDFD, y + eor (Coordinates2Bit + sta $f1 + lda #<(Coordinates2Bit + $3C00 - 2) + sta $f2 + lda #>(Coordinates2Bit + $3C00 - 2) + sta $f3 + + ldx #$1E ; #$3C/2 + clc + !byte $24 +- sec +-- lda ($f0), y + pha + lda ($f2), y + sta ($f0), y + pla + sta ($f2), y + iny + bcc - + ldy #0 + !byte $24 +- clc + inc $f0 + bne + + inc $f1 + dex + beq ++ ++ lda $f2 + bne + + dec $f3 ++ dec $f2 + bcs - + bcc -- ; always branches +++ +} + +!macro FX_RIPPLE_2BIT { + ldy #0 + + ldx #$33 +- lda ptrtbl, x + sta $c0, x + dex + bpl - + + lda #$9b + sta $fe + iny + sty $ff + + ldx #6 +- lda Coordinates2Bit + 1, x + sta $7f, x + lda Coordinates2Bit + 9, x + sta $85, x + lda Coordinates2Bit + 17, x + sta $8b, x + lda Coordinates2Bit + 65, x + sta $9b, x + dex + bne - + lda Coordinates2Bit + 28 + sta $92 + lda Coordinates2Bit + 29 + sta $93 + ldx #4 +- lda Coordinates2Bit + 33, x + sta $93, x + lda Coordinates2Bit + 41, x + sta $97, x + lda Coordinates2Bit + 83, x + sta $a1, x + dex + bne - + ldx #2 +- lda Coordinates2Bit + 125, x + sta $a5, x + lda Coordinates2Bit + 131, x + sta $a7, x + lda Coordinates2Bit + 139, x + sta $a9, x + lda Coordinates2Bit + 169, x + sta $ab, x + lda Coordinates2Bit + 237, x + sta $ad, x + lda Coordinates2Bit + 2193, x + sta $af, x + lda Coordinates2Bit + 6581, x + sta $b1, x + dex + bne - + +--- ldx #$34 +-- lda $be, x + tay + ora $bf, x + beq + + lda $bf, x + jsr aslmod + sty $be, x + sta $bf, x + sty $fc + clc + adc #>Coordinates2Bit + sta $fd + ldy #0 + !byte $24 +- sec + lda ($fc), y + pha + lda $7e, x + sta ($fc), y + pla + sta $7e, x + inx + iny + bcc - + dex + dex ++ dex + dex + bne -- + ldy #1 + lda $fe + eor #<(411 - 2) + beq + + ldy #9 + eor #<(411 - 2) xor <(411 - 136) + bne ++ ++ +- ldx zerotbl, y + sta $0, x + sta $1, x + dey + bpl - +++ dec $fe + bne --- + dec $ff + bpl --- + bmi ++ ; always branches +aslmod + jsr + ++ cmp #$1E + bcc + + iny ++ pha + tya + asl + tay + pla + rol + cmp #$3C + bcc + + sbc #$3C ++ rts +ptrtbl !word 2, 4, 6, 10, 12, 14, 18, 20 + !word 22, 28, 34, 36, 42, 44, 66, 68 + !word 70, 84, 86, 126, 132, 140, 170, 238 + !word 2194, 6582 +zerotbl !byte $f0, $f2, $ca, $d2, $d8, $e0, $e2, $e6, $ea, $ee +++ +} + +!macro FX_PRECOMPUTED_2BIT .coords { + +BUILD_HGR_LOOKUP_TABLES hgrlo, hgr1hi + +BUILD_MIRROR_COLS mirror_cols + +BUILD_SPARSE_BITMASKS_2BIT copymasks, mirror_copymasks + ldx #(end-start-1) ; copy InputLoop code to zero page +- lda start, x + sta $0, x + dex + bpl - + jmp InputLoop +start +!pseudopc 0 { +Exit2Bit rts +InputLoop + ldy #0 +input=*+1 + ldx .coords, y ; first value: HGR row + 1 + beq Exit2Bit ; if 0 then we're done + +ROW_X_TO_2BIT_BASE_ADDRESSES + + inc Coordinates3Bit + sta $f1 + lda #<(Coordinates3Bit + $5000 - 2) + sta $f2 + lda #>(Coordinates3Bit + $5000 - 2) + sta $f3 + + ldx #$28 ; #$50/2 + clc + !byte $24 +- sec +-- lda ($f0), y + pha + lda ($f2), y + sta ($f0), y + pla + sta ($f2), y + iny + bcc - + ldy #0 + !byte $24 +- clc + inc $f0 + bne + + inc $f1 + dex + beq ++ ++ lda $f2 + bne + + dec $f3 ++ dec $f2 + bcs - + bcc -- ; always branches +++ +} + +!macro FX_RIPPLE_3BIT { + ldx #$1B +- lda ripplezp, x + sta $e0, x + dex + bpl - + +--- ldx #$0c +-- ldy $ee, x + lda $ef, x + jsr aslmod + sty $ee, x + sta $ef, x + sty $ec + clc + adc #>Coordinates3Bit + sta $ed + ldy #0 + !byte $24 +- sec + lda ($ec), y + pha + lda $de, x + sta ($ec), y + pla + sta $de, x + inx + iny + bcc - + dex + dex + dex + dex + bne -- + dec $ee + bne --- + dec $ef + bpl --- + bmi ++ ; always branches +aslmod + jsr + ++ cmp #$28 + bcc + + iny ++ pha + tya + asl + tay + pla + rol + cmp #$50 + bcc + + sbc #$50 ++ rts +ripplezp + !byte $1F,$F3,$20,$F3,$20,$14,$20,$D3 + !byte $1E,$F3,$1F,$54,$00,$00,$AA,$06 + !byte $02,$00,$04,$00,$06,$00,$0C,$00 + !byte $16,$00,$1A,$00 +++ +} + +!macro FX_PRECOMPUTED_3BIT .coords { + +BUILD_3BIT_HGR_LOOKUP_TABLES + +BUILD_EXTRA_COLS + +BUILD_SPARSE_BITMASKS_3BIT + ldx #(end-start-1) ; copy InputLoop code to zero page +- lda start, x + sta $0, x + dex + bpl - + jmp InputLoop +start +!pseudopc 0 { +Exit3Bit rts +InputLoop + ldy #0 +input=*+1 + lda .coords, y + bmi Exit3Bit ; if high bit is 1 then we're done + cmp #$40 + php + tax + +ROW_X_TO_3BIT_BASE_ADDRESSES + + inc masks + sta @basemaskaddr+1 + lda maskindex + asl + asl + asl + clc + adc @basemaskaddr + sta @basemaskaddr + bcc + + inc @basemaskaddr+1 ++ + ldx #7 + clc +@blockloop +@basemaskaddr=*+1 + lda $FDFD,x ; SMC + sta @copymask + ldy #39 +@colloop + lda ($26),y + eor ($3c),y +@copymask=*+1 + and #0 ; SMC + eor ($26),y + sta ($26),y + dey + bpl @colloop + +HGR_INC_WITHIN_BLOCK + dex + bpl @blockloop + +@skiprow + inc row + dec maskindex + bpl @maskloop + + lda #40 + jsr WaitForKeyWithTimeout + bmi @exit + + dec row + dec row + dec row + dec row + dec row + dec row + lda row + bmi @rowloop + cmp #24 + bcc @rowloop + +@exit jmp UnwaitForVBL + +masks + !byte %10000000 + !byte %10000000 + !byte %10000000 + !byte %10001000 + !byte %10001000 + !byte %10000000 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10010100 + !byte %10001000 + !byte %10001000 + !byte %10010100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10101010 + !byte %10011100 + !byte %10111110 + !byte %10011100 + !byte %10011100 + !byte %10101010 + !byte %10000000 + + !byte %10000000 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10000000 + + !byte %11010101 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %10111110 + !byte %11010101 + + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.soft.ud.in.a b/src/fx/fx.hgr.soft.ud.in.a new file mode 100644 index 0000000..d90cdfc --- /dev/null +++ b/src/fx/fx.hgr.soft.ud.in.a @@ -0,0 +1,160 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/SOFT.UD.IN",plain +*=$6000 + +maskindex = $fc +row = $fd + + !source "src/fx/macros.a" + !source "src/constants.a" + + lda #$FA + sta row +@rowloop + lda #6 + sta maskindex + jsr WaitForVBL +@maskloop + lda row + bmi @skiprow + cmp #12 + bcs @skiprow + jsr do + lda #23 + sec + sbc row + jsr do + +@skiprow + inc row + dec maskindex + bpl @maskloop + + lda #40 + jsr WaitForKeyWithTimeout + bmi @exit + + dec row + dec row + dec row + dec row + dec row + dec row + lda row + bmi @rowloop + cmp #12 + bcc @rowloop + +@exit jmp UnwaitForVBL + +do + asl + asl + asl + jsr HGRCalc + + lda #masks + sta @basemaskaddr+1 + lda maskindex + asl + asl + asl + clc + adc @basemaskaddr + sta @basemaskaddr + bcc + + inc @basemaskaddr+1 ++ + ldx #7 + clc +@blockloop +@basemaskaddr=*+1 + lda $FDFD,x ; SMC + sta @copymask + ldy #39 +@colloop + lda ($26),y + eor ($3c),y +@copymask=*+1 + and #0 ; SMC + eor ($26),y + sta ($26),y + dey + bpl @colloop + +HGR_INC_WITHIN_BLOCK + dex + bpl @blockloop + rts + +masks + !byte %10000000 + !byte %10000000 + !byte %10000000 + !byte %10001000 + !byte %10001000 + !byte %10000000 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10010100 + !byte %10001000 + !byte %10001000 + !byte %10010100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10101010 + !byte %10011100 + !byte %10111110 + !byte %10011100 + !byte %10011100 + !byte %10101010 + !byte %10000000 + + !byte %10000000 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10000000 + + !byte %11010101 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %10111110 + !byte %11010101 + + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.soft.ud.out.a b/src/fx/fx.hgr.soft.ud.out.a new file mode 100644 index 0000000..75eb4f3 --- /dev/null +++ b/src/fx/fx.hgr.soft.ud.out.a @@ -0,0 +1,163 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/SOFT.UD.OUT",plain +*=$6000 + +maskindex = $fc +row = $fd + + !source "src/fx/macros.a" + !source "src/constants.a" + + lda #$FA + sta row +@rowloop + lda #6 + sta maskindex + jsr WaitForVBL +@maskloop + lda row + bmi @skiprow + cmp #12 + bcs @skiprow + clc + adc #12 + jsr do + lda #11 + sec + sbc row + jsr do + +@skiprow + inc row + dec maskindex + bpl @maskloop + + lda #40 + jsr WaitForKeyWithTimeout + bmi @exit + + dec row + dec row + dec row + dec row + dec row + dec row + lda row + bmi @rowloop + cmp #12 + bcc @rowloop + +@exit jmp UnwaitForVBL + +do + asl + asl + asl + jsr HGRCalc + + lda #masks + sta @basemaskaddr+1 + lda maskindex + asl + asl + asl + clc + adc @basemaskaddr + sta @basemaskaddr + bcc + + inc @basemaskaddr+1 ++ + ldx #7 + clc +@blockloop +@basemaskaddr=*+1 + lda $FDFD,x ; SMC + sta @copymask + + ldy #39 +@colloop + lda ($26),y + eor ($3c),y +@copymask=*+1 + and #0 ; SMC + eor ($26),y + sta ($26),y + dey + bpl @colloop + +HGR_INC_WITHIN_BLOCK + dex + bpl @blockloop + rts + +masks + !byte %10000000 + !byte %10000000 + !byte %10000000 + !byte %10001000 + !byte %10001000 + !byte %10000000 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10010100 + !byte %10001000 + !byte %10001000 + !byte %10010100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10000000 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10011100 + !byte %10000000 + !byte %10000000 + + !byte %10000000 + !byte %10101010 + !byte %10011100 + !byte %10111110 + !byte %10011100 + !byte %10011100 + !byte %10101010 + !byte %10000000 + + !byte %10000000 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10111110 + !byte %10000000 + + !byte %11010101 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %11111111 + !byte %10111110 + !byte %10111110 + !byte %11010101 + + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES diff --git a/src/fx/fx.hgr.spiral.a b/src/fx/fx.hgr.spiral.a new file mode 100644 index 0000000..87e7b1d --- /dev/null +++ b/src/fx/fx.hgr.spiral.a @@ -0,0 +1,81 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/SPIRAL",plain +*=$6000 + + !source "src/constants.a" + + lda #$27 + sta $FB + lda #$17 + sta $FD + lda #$00 + sta $FA + sta $FC +@outerloop + lda $FC + sta $FE + lda $FA + sta $FF + lda #$00 + sta $F9 +@loop lda $FE + ldy $FF + jsr HGRBlockCopy + lda #$1F + jsr WaitForKeyWithTimeout + bmi @exit + ldx $F9 + bne @a + inc $FF + lda $FB + cmp $FF + bcs @loop + inc $FC + inc $F9 + lda $FC + sta $FE + lda $FB + sta $FF +@a dex + bne @b + inc $FE + lda $FD + cmp $FE + bcs @loop + dec $FB + inc $F9 + lda $FD + sta $FE + lda $FB + sta $FF +@b dex + bne @c + dec $FF + lda $FF + cmp $FA + bpl @loop + lda $FD + cmp $FC + beq @exit + dec $FD + inc $F9 + lda $FD + sta $FE + lda $FA + sta $FF +@c dex + bne @loop + dec $FE + lda $FE + cmp $FC + bpl @loop + inc $FA + bne @outerloop ; always branches +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.split.ud.intro.a b/src/fx/fx.hgr.split.ud.intro.a new file mode 100644 index 0000000..bf66463 --- /dev/null +++ b/src/fx/fx.hgr.split.ud.intro.a @@ -0,0 +1,128 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/SPLIT.UD.INTRO",plain +*=$6000 + + !source "src/fx/macros.a" + !source "src/constants.a" + +col1 = $FE +col2 = $FF + + lda #$00 + sta col1 + lda #$27 + sta col2 +@introloop + lda #$17 + ldy col1 + jsr HGRHalfBlockToWhite + lda #$18 + ldy col2 + jsr HGRHalfBlockToWhite + lda #$40 + jsr WaitForKeyWithTimeout + bpl + + jmp @exit ++ + inc col1 + dec col2 + bpl @introloop + +row1 = $FE +row2 = $FF + + lda #$16 + sta row1 + lda #$19 + sta row2 + +@outerloop + jsr WaitForVBL + lda row1 + bmi @skiptopwhite + asl + asl + jsr HGRCalc + ldx #$04 +@topwhite + ldy #$27 + lda #$7F +- sta ($26),y + dey + bpl - + +HGR_INC_WITHIN_BLOCK + dex + bne @topwhite +@skiptopwhite + inc row1 + + lda row1 + asl + asl + jsr HGRCalc + ldx #$04 +@topcopy + ldy #$27 +- lda ($3c),y + sta ($26),y + dey + bpl - + +HGR_INC_WITHIN_BLOCK + dex + bne @topcopy + + lda row2 + cmp #$30 + bcs @skipbottomwhite + lda row2 + asl + asl + jsr HGRCalc + ldx #$04 +@bottomwhite + ldy #$27 +- lda #$7F + sta ($26),y + dey + bpl - + +HGR_INC_WITHIN_BLOCK + dex + bne @bottomwhite +@skipbottomwhite + dec row2 + lda row2 + asl + asl + jsr HGRCalc + ldx #$04 +@bottomcopy + ldy #$27 +- lda ($3c),y + sta ($26),y + dey + bpl - + +HGR_INC_WITHIN_BLOCK + dex + bne @bottomcopy + + lda #$28 + jsr WaitForKeyWithTimeout + bmi @exit + + dec row1 + dec row1 + inc row2 + inc row2 + lda row1 + cmp #$FE + beq @exit + jmp @outerloop +@exit jmp UnwaitForVBL + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_CALC_ROUTINES + +HGR_WHITE_ROUTINES diff --git a/src/fx/fx.hgr.stagger.lr.a b/src/fx/fx.hgr.stagger.lr.a new file mode 100644 index 0000000..1a1e303 --- /dev/null +++ b/src/fx/fx.hgr.stagger.lr.a @@ -0,0 +1,44 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/STAGGER.LR",plain +*=$6000 + +row = $fd +col1 = $fe +col2 = $ff + + lda #$00 + sta col1 + lda #$27 + sta col2 +@outerloop + lda #$2E + sta row +@loop1 ldy col1 + lda row + jsr HGRHalfBlockCopy + iny + jsr HGRStaggerCopy + ldy col2 + lda row + jsr HGRHalfBlockCopy + dey + jsr HGRStaggerCopy + dec row + dec row + bpl @loop1 + lda #$40 + jsr WaitForKeyWithTimeout + bmi @exit + inc col1 + inc col1 + dec col2 + dec col2 + bpl @outerloop +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.stagger.lr.white.a b/src/fx/fx.hgr.stagger.lr.white.a new file mode 100644 index 0000000..e4a1b78 --- /dev/null +++ b/src/fx/fx.hgr.stagger.lr.white.a @@ -0,0 +1,74 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/STAGGERWHITE.LR",plain +*=$6000 + +row = $fd +col1 = $fe +col2 = $ff + + lda #$00 + sta col1 + lda #$27 + sta col2 +@outerloop1 + lda #$2E + sta row +@loop1 ldy col1 + lda row + jsr HGRHalfBlockToWhite + iny + jsr HGRStaggerToWhite + ldy col2 + lda row + jsr HGRHalfBlockToWhite + dey + jsr HGRStaggerToWhite + dec row + dec row + bpl @loop1 + lda #$40 + jsr WaitForKeyWithTimeout + bmi @exit + inc col1 + inc col1 + dec col2 + dec col2 + bpl @outerloop1 + + lda #$00 + sta col1 + lda #$27 + sta col2 +@outerloop2 + lda #$2E + sta row +@loop2 ldy col1 + lda row + jsr HGRHalfBlockCopy + iny + jsr HGRStaggerCopy + ldy col2 + lda row + jsr HGRHalfBlockCopy + dey + jsr HGRStaggerCopy + dec row + dec row + bpl @loop2 + lda #$40 + jsr WaitForKeyWithTimeout + bmi @exit + inc col1 + inc col1 + dec col2 + dec col2 + bpl @outerloop2 +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.stagger.ud.a b/src/fx/fx.hgr.stagger.ud.a new file mode 100644 index 0000000..17e3e07 --- /dev/null +++ b/src/fx/fx.hgr.stagger.ud.a @@ -0,0 +1,40 @@ +!cpu 6502 +!to "build/FX/STAGGER.UD",plain +*=$6000 + +row1 = $fe +row2 = $ff + + lda #$00 + sta row1 + lda #$2E + sta row2 + ldy #$27 +@loop1 lda row1 + jsr HGRHalfBlockCopy + dey + jsr HGRStaggerCopy + dey + bpl @loop1 + iny ; Y -> 0 +@loop2 lda row2 + jsr HGRHalfBlockCopy + iny + jsr HGRStaggerCopy + iny + cpy #$28 + bne @loop2 + lda #$40 + jsr WaitForKeyWithTimeout + bmi @exit + dey ; Y -> #$27 + inc row1 + inc row1 + dec row2 + dec row2 + bpl @loop1 +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.stagger.ud.white.a b/src/fx/fx.hgr.stagger.ud.white.a new file mode 100644 index 0000000..642fc08 --- /dev/null +++ b/src/fx/fx.hgr.stagger.ud.white.a @@ -0,0 +1,73 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/STAGGERWHITE.UD",plain +*=$6000 + +row1 = $fe +row2 = $ff + + lda #$00 + sta row1 + lda #$2E + sta row2 + ldy #$27 +@loop1 lda row1 + jsr HGRHalfBlockToWhite + dey + jsr HGRStaggerToWhite + dey + bpl @loop1 + iny ; Y -> 0 +@loop2 lda row2 + jsr HGRHalfBlockToWhite + iny + jsr HGRStaggerToWhite + iny + cpy #$28 + bne @loop2 + lda #$30 + jsr WaitForKeyWithTimeout + bmi @exit + dey ; Y -> #$27 + inc row1 + inc row1 + dec row2 + dec row2 + bpl @loop1 + + lda #$00 + sta row1 + lda #$2E + sta row2 + ldy #$27 +@loop3 lda row1 + jsr HGRHalfBlockCopy + dey + jsr HGRStaggerCopy + dey + bpl @loop3 + iny ; Y -> 0 +@loop4 lda row2 + jsr HGRHalfBlockCopy + iny + jsr HGRStaggerCopy + iny + cpy #$28 + bne @loop4 + lda #$30 + jsr WaitForKeyWithTimeout + bmi @exit + dey ; Y -> #$27 + inc row1 + inc row1 + dec row2 + dec row2 + bpl @loop3 +@exit rts + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_WHITE_ROUTINES + +HGR_HALF_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.star.a b/src/fx/fx.hgr.star.a new file mode 100644 index 0000000..7969607 --- /dev/null +++ b/src/fx/fx.hgr.star.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/STAR",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.hgr.star.bloom.a b/src/fx/fx.hgr.star.bloom.a new file mode 100644 index 0000000..7c6cbdd --- /dev/null +++ b/src/fx/fx.hgr.star.bloom.a @@ -0,0 +1,14 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/STAR.BLOOM",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_PRECOMPUTED_2BIT Coordinates + +Coordinates + !source "src/fx/fx.hgr.star.bloom.data.a" + !byte $00 diff --git a/src/fx/fx.hgr.star.bloom.data.a b/src/fx/fx.hgr.star.bloom.data.a new file mode 100644 index 0000000..c222926 --- /dev/null +++ b/src/fx/fx.hgr.star.bloom.data.a @@ -0,0 +1,7680 @@ + !byte $A5,%01000000 + !byte $01,%00100010 + !byte $B3,%00100010 + !byte $B3,%00000010 + !byte $1D,%00100000 + !byte $B7,%10100001 + !byte $B7,%10000001; + !byte $B7,%01100000 + !byte $BB,%10000001; + !byte $BB,%01100000 + !byte $29,%11100001 + !byte $BD,%11100001 + !byte $33,%00100000 + !byte $01,%10100011 + !byte $01,%00100100 + !byte $03,%01000000 + !byte $03,%11000001 + !byte $03,%00100000 + !byte $03,%00000000 + !byte $03,%11100001 + !byte $A7,%00000000 + !byte $7D,%01000000 + !byte $07,%01000000 + !byte $AD,%00000000 + !byte $0B,%11000001 + !byte $0B,%10000011; + !byte $0B,%01100010 + !byte $B1,%00100000 + !byte $0B,%01000000 + !byte $BF,%10000001; + !byte $BF,%01100000 + !byte $BB,%10100001 + !byte $11,%10100001 + !byte $13,%00000000 + !byte $05,%11000111 + !byte $15,%11100001 + !byte $89,%00000000 + !byte $BF,%11100011 + !byte $91,%00100000 + !byte $05,%10100101 + !byte $97,%00100000 + !byte $13,%10000101; + !byte $13,%01100100 + !byte $03,%01000100 + !byte $9D,%01000000 + !byte $27,%01000100 + !byte $15,%00000100 + !byte $9D,%00000000 + !byte $07,%11100011 + !byte $A1,%00100010 + !byte $11,%11100011 + !byte $A3,%11100011 + !byte $19,%11100011 + !byte $A1,%00000000 + !byte $A5,%01000100 + !byte $A5,%00100010 + !byte $07,%01000010 + !byte $A5,%00000010 + !byte $A5,%11100001 + !byte $03,%00100010 + !byte $17,%10000011; + !byte $17,%01100010 + !byte $A9,%10100011 + !byte $43,%11000001 + !byte $A9,%10000011; + !byte $A9,%01100010 + !byte $13,%00100010 + !byte $A9,%11100001 + !byte $A9,%11000001 + !byte $09,%11100001 + !byte $0F,%00000010 + !byte $25,%10000011; + !byte $25,%01100010 + !byte $AD,%10100001 + !byte $AD,%11100101 + !byte $AD,%11000101 + !byte $AD,%11000001 + !byte $AD,%01000000 + !byte $AD,%00100000 + !byte $AD,%00000100 + !byte $AD,%11100011 + !byte $AD,%11100001 + !byte $AD,%10000001; + !byte $AD,%01100000 + !byte $AF,%00000000 + !byte $AF,%10000101; + !byte $AF,%01100100 + !byte $AF,%10101001 + !byte $AF,%10000011; + !byte $AF,%01100010 + !byte $23,%00000010 + !byte $05,%00100000 + !byte $19,%11000001 + !byte $09,%01000000 + !byte $17,%10100001 + !byte $09,%00100000 + !byte $B1,%10000101; + !byte $B1,%01100100 + !byte $B1,%11100001 + !byte $B1,%11000001 + !byte $B1,%01000000 + !byte $B3,%00000000 + !byte $B3,%10100001 + !byte $B3,%10000011; + !byte $B3,%01100010 + !byte $B3,%10100011 + !byte $B1,%00001010 + !byte $B3,%01000010 + !byte $B5,%00100000 + !byte $B5,%01000000 + !byte $1B,%01000000 + !byte $B3,%00101000 + !byte $B7,%00000010 + !byte $B7,%11000001 + !byte $B5,%11100101 + !byte $B9,%01000000 + !byte $B7,%11100011 + !byte $B3,%10001011; + !byte $B3,%01101010 + !byte $B5,%10100111 + !byte $B7,%00100100 + !byte $B9,%11100011 + !byte $B9,%00100010 + !byte $BB,%01000000 + !byte $1F,%00100000 + !byte $B7,%11000101 + !byte $B9,%11000011 + !byte $B9,%01000010 + !byte $BB,%11000001 + !byte $1D,%00000000 + !byte $BD,%11000001 + !byte $BD,%00000010 + !byte $31,%10100001 + !byte $BF,%00100000 + !byte $BB,%00100110 + !byte $BB,%00000110 + !byte $B7,%00101010 + !byte $BF,%10100011 + !byte $31,%01000000 + !byte $2D,%00100000 + !byte $BF,%01000100 + !byte $BD,%00100110 + !byte $BF,%00000100 + !byte $BF,%10100101 + !byte $BF,%10000101; + !byte $BF,%01100100 + !byte $3D,%11000001 + !byte $6F,%00100000 + !byte $33,%00000000 + !byte $BD,%11101001 + !byte $B9,%10001101; + !byte $B9,%01101100 + !byte $BB,%00101100 + !byte $3B,%00000000 + !byte $BF,%10001011; + !byte $BF,%01101010 + !byte $43,%01000000 + !byte $85,%00000000 + !byte $51,%00000010 + !byte $4B,%10100001 + !byte $47,%01000000 + !byte $43,%00000000 + !byte $85,%01000000 + !byte $BF,%10001101; + !byte $BF,%01101100 + !byte $8F,%00000000 + !byte $87,%10100001 + !byte $93,%00000000 + !byte $95,%00000000 + !byte $01,%11000011 + !byte $03,%01001110 + !byte $01,%01000010 + !byte $9B,%00000000 + !byte $99,%00100000 + !byte $83,%00100010 + !byte $99,%01000000 + !byte $95,%10000001; + !byte $95,%01100000 + !byte $05,%00100100 + !byte $05,%10100011 + !byte $03,%10100001 + !byte $07,%01000100 + !byte $05,%10000001; + !byte $05,%01100000 + !byte $A5,%00000000 + !byte $9F,%01000000 + !byte $9D,%10000001; + !byte $9D,%01100000 + !byte $A3,%01000000 + !byte $A9,%00000000 + !byte $A7,%00100000 + !byte $09,%11000011 + !byte $09,%11000001 + !byte $0B,%00000100 + !byte $57,%01000000 + !byte $A7,%01000000 + !byte $A3,%10000001; + !byte $A3,%01100000 + !byte $AF,%00100000 + !byte $9B,%11100001 + !byte $9D,%11100001 + !byte $AB,%01000000 + !byte $0B,%00100000 + !byte $0D,%01000010 + !byte $B7,%00000000 + !byte $AF,%01000000 + !byte $A3,%11000001 + !byte $0F,%10100011 + !byte $BB,%00000000 + !byte $9F,%00000010 + !byte $B7,%00100000 + !byte $AF,%10000001; + !byte $AF,%01100000 + !byte $AB,%10100001 + !byte $9B,%01000010 + !byte $0F,%01000000 + !byte $0F,%11000001 + !byte $BF,%00000000 + !byte $5B,%00100000 + !byte $B9,%10000001; + !byte $B9,%01100000 + !byte $11,%10000001; + !byte $11,%01100000 + !byte $BD,%01000000 + !byte $A7,%00000010 + !byte $9F,%01000010 + !byte $11,%01000000 + !byte $AB,%11100001 + !byte $AB,%00000010 + !byte $13,%01000010 + !byte $B5,%11100001 + !byte $BF,%10100001 + !byte $B9,%11000001 + !byte $AF,%00000010 + !byte $A3,%10100011 + !byte $B9,%11100001 + !byte $AD,%01000010 + !byte $B5,%00000010 + !byte $17,%11100001 + !byte $A5,%10100011 + !byte $17,%11000001 + !byte $BB,%00000010 + !byte $B1,%01000010 + !byte $AF,%01000010 + !byte $AB,%10000011; + !byte $AB,%01100010 + !byte $B7,%01000010 + !byte $BB,%00100010 + !byte $A1,%11100011 + !byte $19,%00000000 + !byte $19,%01000010 + !byte $19,%10000011; + !byte $19,%01100010 + !byte $BF,%00000010 + !byte $B5,%01000010 + !byte $1B,%00100000 + !byte $B7,%10000011; + !byte $B7,%01100010 + !byte $1B,%00000000 + !byte $1B,%10000001; + !byte $1B,%01100000 + !byte $B1,%10100011 + !byte $BF,%01000010 + !byte $B1,%11000011 + !byte $BB,%10100011 + !byte $B5,%11000011 + !byte $A9,%00000100 + !byte $BD,%11000011 + !byte $AF,%00000100 + !byte $A3,%01000100 + !byte $1F,%01000000 + !byte $1F,%10100011 + !byte $21,%11100001 + !byte $B5,%00000100 + !byte $A9,%01000100 + !byte $B5,%00100100 + !byte $21,%11100011 + !byte $BD,%00000100 + !byte $AD,%01000100 + !byte $BD,%00100100 + !byte $69,%00000000 + !byte $BB,%00100100 + !byte $A7,%10100101 + !byte $B9,%01000100 + !byte $BB,%01000100 + !byte $B5,%10000101; + !byte $B5,%01100100 + !byte $B9,%10000101; + !byte $B9,%01100100 + !byte $B1,%10100101 + !byte $29,%00000000 + !byte $BD,%10100101 + !byte $BF,%11010011 + !byte $B1,%11100101 + !byte $AF,%11100101 + !byte $29,%00000010 + !byte $B7,%11100101 + !byte $AD,%00100110 + !byte $B7,%00100110 + !byte $B5,%00100110 + !byte $31,%00100000 + !byte $09,%00101010 + !byte $BF,%01000110 + !byte $03,%00101010 + !byte $B3,%10100111 + !byte $AB,%10100111 + !byte $7B,%00000010 + !byte $77,%01000000 + !byte $BF,%10100111 + !byte $BB,%10100111 + !byte $7D,%00100010 + !byte $37,%11000001 + !byte $BD,%11100111 + !byte $B7,%11100111 + !byte $B5,%11100111 + !byte $B3,%11100111 + !byte $0B,%11001001 + !byte $B9,%00001000 + !byte $05,%11001001 + !byte $7F,%00100010 + !byte $A3,%00101000 + !byte $AD,%00101000 + !byte $3B,%10100001 + !byte $09,%10101001 + !byte $B9,%01001000 + !byte $3D,%11100001 + !byte $BF,%10001001; + !byte $BF,%01101000 + !byte $B9,%10001001; + !byte $B9,%01101000 + !byte $BF,%10101001 + !byte $83,%11100001 + !byte $13,%01001000 + !byte $B3,%11001001 + !byte $87,%11100011 + !byte $81,%00100000 + !byte $83,%01000000 + !byte $BB,%00001010 + !byte $83,%00000000 + !byte $1F,%00101000 + !byte $03,%00001000 + !byte $03,%11000111 + !byte $01,%10100111 + !byte $49,%01000010 + !byte $BF,%10101011 + !byte $11,%11000111 + !byte $BD,%11001011 + !byte $8D,%01000010 + !byte $8F,%11100011 + !byte $8B,%00000000 + !byte $1D,%11000111 + !byte $05,%10000111; + !byte $05,%01100110 + !byte $01,%01000110 + !byte $53,%10000001; + !byte $53,%01100000 + !byte $55,%00000000 + !byte $0B,%01000110 + !byte $55,%10000001; + !byte $55,%01100000 + !byte $8F,%01000000 + !byte $17,%10000111; + !byte $17,%01100110 + !byte $07,%00100110 + !byte $05,%00000110 + !byte $91,%00100010 + !byte $1F,%10000111; + !byte $1F,%01100110 + !byte $03,%11100101 + !byte $01,%11100101 + !byte $93,%11000011 + !byte $91,%00000000 + !byte $93,%00100000 + !byte $BD,%10001101; + !byte $BD,%01101100 + !byte $93,%00100010 + !byte $93,%01000000 + !byte $0B,%11100101 + !byte $BF,%10101101 + !byte $5F,%00000000 + !byte $BD,%10101101 + !byte $03,%10100101 + !byte $95,%10100001 + !byte $95,%00100000 + !byte $95,%11000001 + !byte $09,%11000101 + !byte $01,%10100101 + !byte $5D,%11000001 + !byte $0D,%11000101 + !byte $97,%10100011 + !byte $21,%00100110 + !byte $0D,%10100101 + !byte $97,%10100001 + !byte $97,%01000000 + !byte $97,%10000001; + !byte $97,%01100000 + !byte $97,%00000000 + !byte $99,%00100100 + !byte $99,%10000001; + !byte $99,%01100000 + !byte $21,%00000110 + !byte $0B,%10000101; + !byte $0B,%01100100 + !byte $99,%00100010 + !byte $05,%01000100 + !byte $03,%00100100 + !byte $09,%01000100 + !byte $9B,%00000010 + !byte $9B,%10100001 + !byte $9B,%00100000 + !byte $63,%11000001 + !byte $1B,%11000101 + !byte $9B,%00100010 + !byte $9B,%11000001 + !byte $9B,%01000000 + !byte $05,%00000100 + !byte $69,%01000000 + !byte $11,%01000100 + !byte $0F,%01000100 + !byte $0F,%00100100 + !byte $9D,%10000011; + !byte $9D,%01100010 + !byte $9D,%10100001 + !byte $9D,%00100010 + !byte $9D,%11000001 + !byte $09,%00000100 + !byte $03,%10101111 + !byte $09,%11100011 + !byte $9F,%10000001; + !byte $9F,%01100000 + !byte $17,%01000100 + !byte $03,%11000011 + !byte $9F,%10100001 + !byte $0D,%00000100 + !byte $05,%11000011 + !byte $03,%10001111; + !byte $03,%01101110 + !byte $03,%10100011 + !byte $9F,%10000011; + !byte $9F,%01100010 + !byte $07,%11000011 + !byte $9F,%11000011 + !byte $9F,%10100011 + !byte $9F,%00100010 + !byte $BF,%11001111 + !byte $15,%00100100 + !byte $23,%10100101 + !byte $9F,%01000110 + !byte $A1,%11100001 + !byte $A1,%10000001; + !byte $A1,%01100000 + !byte $A1,%00100000 + !byte $17,%00100100 + !byte $05,%01001110 + !byte $A1,%00000010 + !byte $23,%10000101; + !byte $23,%01100100 + !byte $03,%01000010 + !byte $01,%10101101 + !byte $A3,%00000000 + !byte $75,%00000000 + !byte $73,%00100000 + !byte $A1,%10100011 + !byte $37,%00100110 + !byte $13,%11100011 + !byte $0F,%11000011 + !byte $07,%10000011; + !byte $07,%01100010 + !byte $0D,%10100011 + !byte $A3,%10100001 + !byte $11,%11000011 + !byte $09,%10000011; + !byte $09,%01100010 + !byte $01,%10001101; + !byte $01,%01101100 + !byte $A3,%10000011; + !byte $A3,%01100010 + !byte $A3,%00000010 + !byte $1D,%00100100 + !byte $05,%01000010 + !byte $07,%00101110 + !byte $09,%01000010 + !byte $A1,%11000111 + !byte $A5,%10000001; + !byte $A5,%01100000 + !byte $1B,%00000100 + !byte $0D,%10000011; + !byte $0D,%01100010 + !byte $A3,%00100100 + !byte $A3,%11000011 + !byte $73,%10100001 + !byte $B7,%11101111 + !byte $21,%00100100 + !byte $A5,%01000010 + !byte $BD,%00110000 + !byte $1B,%11100011 + !byte $A1,%00101000 + !byte $A5,%10000011; + !byte $A5,%01100010 + !byte $11,%10000011; + !byte $11,%01100010 + !byte $A5,%00000100 + !byte $A7,%11000001 + !byte $2B,%10000101; + !byte $2B,%01100100 + !byte $15,%10100011 + !byte $05,%11100001 + !byte $09,%11101101 + !byte $A5,%00100100 + !byte $A7,%11100001 + !byte $A7,%10100001 + !byte $7D,%00000000 + !byte $BD,%01010000 + !byte $2F,%10100101 + !byte $21,%00000100 + !byte $19,%11000011 + !byte $17,%10100011 + !byte $07,%00000010 + !byte $01,%11000001 + !byte $15,%10000011; + !byte $15,%01100010 + !byte $05,%11000001 + !byte $A5,%11100101 + !byte $A9,%10100001 + !byte $07,%11100001 + !byte $01,%10100001 + !byte $A7,%11100011 + !byte $A7,%10000011; + !byte $A7,%01100010 + !byte $A9,%10000001; + !byte $A9,%01100000 + !byte $35,%11000101 + !byte $07,%11000001 + !byte $AB,%00100000 + !byte $1F,%11000011 + !byte $11,%00100010 + !byte $A9,%01000010 + !byte $7B,%10100001 + !byte $2F,%10000101; + !byte $2F,%01100100 + !byte $15,%01000010 + !byte $0D,%00000010 + !byte $0B,%11100001 + !byte $01,%10000001; + !byte $01,%01100000 + !byte $11,%00000010 + !byte $A9,%11000011 + !byte $BB,%10110001 + !byte $0D,%11100001 + !byte $01,%01000000 + !byte $01,%11101001 + !byte $A7,%00000110 + !byte $A9,%11100011 + !byte $2B,%00100100 + !byte $A9,%10000101; + !byte $A9,%01100100 + !byte $AB,%00100010 + !byte $01,%10101001 + !byte $A7,%10000111; + !byte $A7,%01100110 + !byte $A9,%10100101 + !byte $A9,%00100100 + !byte $AB,%01000010 + !byte $1D,%10000011; + !byte $1D,%01100010 + !byte $11,%11100001 + !byte $05,%01000000 + !byte $01,%00100000 + !byte $01,%10001001; + !byte $01,%01101000 + !byte $A9,%11000101 + !byte $2B,%00000100 + !byte $25,%11000011 + !byte $1D,%01000010 + !byte $0B,%10000001; + !byte $0B,%01100000 + !byte $05,%00001010 + !byte $A9,%00000110 + !byte $A9,%11100101 + !byte $AB,%11100011 + !byte $03,%11001001 + !byte $2B,%11100011 + !byte $13,%11000001 + !byte $0D,%10000001; + !byte $0D,%01100000 + !byte $07,%00100000 + !byte $01,%00001000 + !byte $AB,%01000100 + !byte $AD,%10100011 + !byte $AF,%10100001 + !byte $B1,%00000000 + !byte $25,%10100011 + !byte $A9,%01000110 + !byte $AD,%11000011 + !byte $89,%00100000 + !byte $1B,%00100010 + !byte $19,%00000010 + !byte $01,%00101000 + !byte $0F,%10000001; + !byte $0F,%01100000 + !byte $05,%10001001; + !byte $05,%01101000 + !byte $AD,%00100100 + !byte $83,%11000001 + !byte $1B,%00000010 + !byte $19,%11100001 + !byte $03,%00101000 + !byte $07,%11101001 + !byte $A9,%11000111 + !byte $AB,%11000101 + !byte $AF,%00100010 + !byte $B1,%10100001 + !byte $15,%11000001 + !byte $13,%10100001 + !byte $0D,%01000000 + !byte $05,%10101001 + !byte $1B,%11100001 + !byte $07,%11001001 + !byte $AF,%10100011 + !byte $B3,%01000000 + !byte $2F,%11100011 + !byte $2B,%11000011 + !byte $15,%10100001 + !byte $13,%10000001; + !byte $13,%01100000 + !byte $0D,%00100000 + !byte $AB,%00100110 + !byte $AD,%10100101 + !byte $AD,%10000101; + !byte $AD,%01100100 + !byte $B1,%00000010 + !byte $B3,%10000001; + !byte $B3,%01100000 + !byte $33,%00100100 + !byte $23,%01000010 + !byte $05,%00101000 + !byte $15,%10000001; + !byte $15,%01100000 + !byte $13,%01000000 + !byte $AD,%00000110 + !byte $89,%10100001 + !byte $2B,%10100011 + !byte $23,%00100010 + !byte $AB,%10000111; + !byte $AB,%01100110 + !byte $B5,%00000000 + !byte $0D,%00000000 + !byte $07,%01001000 + !byte $AD,%01000110 + !byte $B1,%11100011 + !byte $3F,%10100101 + !byte $01,%11000101 + !byte $B1,%00000100 + !byte $B5,%11000001 + !byte $37,%00100100 + !byte $2F,%11000011 + !byte $21,%00000010 + !byte $07,%00001000 + !byte $25,%00000010 + !byte $B1,%00100100 + !byte $15,%00100000 + !byte $01,%10000101; + !byte $01,%01100100 + !byte $AB,%01001000 + !byte $B1,%01000100 + !byte $2F,%10100011 + !byte $2B,%10000011; + !byte $2B,%01100010 + !byte $01,%01000100 + !byte $03,%11000101 + !byte $05,%00100110 + !byte $0B,%10101001 + !byte $1F,%10100001 + !byte $1D,%10000001; + !byte $1D,%01100000 + !byte $01,%00000100 + !byte $05,%11000101 + !byte $09,%11000111 + !byte $0D,%10101001 + !byte $AD,%00001000 + !byte $B1,%11000101 + !byte $B5,%10100011 + !byte $B9,%00100000 + !byte $95,%01000000 + !byte $93,%10000001; + !byte $93,%01100000 + !byte $23,%11100001 + !byte $21,%11000001 + !byte $01,%11100011 + !byte $0B,%01001000 + !byte $AF,%10000111; + !byte $AF,%01100110 + !byte $B3,%00000100 + !byte $99,%00000000 + !byte $2B,%01000010 + !byte $29,%00100010 + !byte $03,%10000101; + !byte $03,%01100100 + !byte $05,%11100101 + !byte $07,%01000110 + !byte $0F,%00101010 + !byte $2F,%10000011; + !byte $2F,%01100010 + !byte $21,%10100001 + !byte $1F,%10000001; + !byte $1F,%01100000 + !byte $19,%00100000 + !byte $01,%10000011; + !byte $01,%01100010 + !byte $05,%10000101; + !byte $05,%01100100 + !byte $09,%01000110 + !byte $0B,%11100111 + !byte $AF,%10100111 + !byte $B1,%00000110 + !byte $B7,%00100010 + !byte $2B,%00100010 + !byte $03,%00000100 + !byte $AF,%11000111 + !byte $B1,%00100110 + !byte $B3,%10100101 + !byte $B5,%11100011 + !byte $B5,%01010010 + !byte $1D,%01000000 + !byte $17,%00000000 + !byte $03,%11100011 + !byte $2F,%01000010 + !byte $05,%11100011 + !byte $07,%10100101 + !byte $AF,%11100111 + !byte $B5,%01000100 + !byte $B7,%10100011 + !byte $B9,%00000010 + !byte $BD,%00100000 + !byte $9F,%00000000 + !byte $9D,%00100000 + !byte $93,%11000001 + !byte $91,%11100001 + !byte $01,%11100001 + !byte $03,%10000011; + !byte $03,%01100010 + !byte $07,%10000101; + !byte $07,%01100100 + !byte $09,%11100101 + !byte $AD,%10001001; + !byte $AD,%01101000 + !byte $B1,%10000111; + !byte $B1,%01100110 + !byte $B1,%01000110 + !byte $BD,%00000000 + !byte $8D,%00100010 + !byte $31,%10000011; + !byte $31,%01100010 + !byte $21,%10000001; + !byte $21,%01100000 + !byte $01,%00000010 + !byte $2F,%00100010 + !byte $03,%00000010 + !byte $BD,%10100001 + !byte $9B,%10000001; + !byte $9B,%01100000 + !byte $99,%10100001 + !byte $97,%11000001 + !byte $23,%10000001; + !byte $23,%01100000 + !byte $21,%01000000 + !byte $07,%00100100 + !byte $09,%10100101 + !byte $0D,%10100111 + !byte $AD,%11001001 + !byte $B1,%11000111 + !byte $B3,%00000110 + !byte $B5,%10100101 + !byte $B9,%10100011 + !byte $9F,%00100000 + !byte $87,%11000011 + !byte $05,%10000011; + !byte $05,%01100010 + !byte $07,%00000100 + !byte $09,%10000101; + !byte $09,%01100100 + !byte $01,%00000000 + !byte $0D,%01000110 + !byte $AF,%10001001; + !byte $AF,%01101000 + !byte $B5,%00000110 + !byte $BB,%01000010 + !byte $35,%10000011; + !byte $35,%01100010 + !byte $29,%11000001 + !byte $03,%10000001; + !byte $03,%01100000 + !byte $05,%00000010 + !byte $07,%10100011 + !byte $0D,%00100110 + !byte $B7,%10000101; + !byte $B7,%01100100 + !byte $B9,%00000100 + !byte $BB,%10000011; + !byte $BB,%01100010 + !byte $BF,%01000000 + !byte $A3,%00100000 + !byte $A1,%01000000 + !byte $99,%11000001 + !byte $97,%11100001 + !byte $05,%00100010 + !byte $09,%00100100 + !byte $0B,%10100101 + !byte $39,%10100011 + !byte $23,%00100000 + !byte $05,%10100001 + !byte $07,%00100010 + !byte $0B,%00100100 + !byte $B5,%01000110 + !byte $BD,%00100010 + !byte $BF,%11100001 + !byte $A5,%00100000 + !byte $99,%11100001 + !byte $29,%10100001 + !byte $0F,%01000110 + !byte $11,%00001000 + !byte $13,%10101001 + !byte $B7,%10100101 + !byte $B9,%00100100 + !byte $BD,%01000010 + !byte $BF,%11000001 + !byte $3F,%00000100 + !byte $21,%00000000 + !byte $09,%10100011 + !byte $0B,%01000100 + !byte $31,%00000010 + !byte $2B,%10100001 + !byte $29,%10000001; + !byte $29,%01100000 + !byte $0B,%10100011 + !byte $0B,%11100011 + !byte $B1,%01001000 + !byte $B3,%00001000 + !byte $B5,%10000111; + !byte $B5,%01100110 + !byte $B7,%00000110 + !byte $BD,%10100011 + !byte $A9,%00100000 + !byte $A1,%10100001 + !byte $9F,%11000001 + !byte $05,%00000000 + !byte $07,%10100001 + !byte $09,%00100010 + !byte $0B,%11000011 + !byte $0D,%00100100 + !byte $0D,%10000101; + !byte $0D,%01100100 + !byte $0F,%00000110 + !byte $11,%10000111; + !byte $11,%01100110 + !byte $B1,%10001001; + !byte $B1,%01101000 + !byte $BF,%00100010 + !byte $AB,%00000000 + !byte $35,%01000010 + !byte $27,%01000000 + !byte $25,%00100000 + !byte $07,%10000001; + !byte $07,%01100000 + !byte $09,%00000010 + !byte $0D,%01000100 + !byte $15,%11101001 + !byte $09,%10000001; + !byte $09,%01100000 + !byte $0B,%00000010 + !byte $0B,%01000010 + !byte $B5,%11000111 + !byte $BB,%10000101; + !byte $BB,%01100100 + !byte $BF,%10000011; + !byte $BF,%01100010 + !byte $A5,%10100001 + !byte $39,%10000011; + !byte $39,%01100010 + !byte $09,%10100001 + !byte $0B,%00100010 + !byte $0D,%11100011 + !byte $AF,%00101010 + !byte $B7,%01000110 + !byte $BD,%11100011 + !byte $A9,%01000000 + !byte $A7,%10000001; + !byte $A7,%01100000 + !byte $A1,%11000001 + !byte $9F,%11100001 + !byte $9D,%00000010 + !byte $3D,%11000011 + !byte $35,%00100010 + !byte $31,%11100001 + !byte $29,%01000000 + !byte $27,%00100000 + !byte $07,%00000000 + !byte $0D,%11000011 + !byte $0F,%10000101; + !byte $0F,%01100100 + !byte $11,%00000110 + !byte $0F,%00000100 + !byte $11,%10000101; + !byte $11,%01100100 + !byte $B1,%11101001 + !byte $B5,%00001000 + !byte $B9,%00000110 + !byte $BB,%10100101 + !byte $8D,%00000100 + !byte $29,%00100000 + !byte $27,%00000000 + !byte $0F,%11100011 + !byte $11,%11000101 + !byte $17,%10001001; + !byte $17,%01101000 + !byte $BB,%11000101 + !byte $AB,%10000001; + !byte $AB,%01100000 + !byte $A5,%11000001 + !byte $A3,%11100001 + !byte $4D,%11000101 + !byte $3D,%10100011 + !byte $35,%00000010 + !byte $31,%11000001 + !byte $09,%00000000 + !byte $0B,%10100001 + !byte $0D,%00100010 + !byte $13,%00100110 + !byte $15,%11100111 + !byte $0B,%00000000 + !byte $0F,%00100010 + !byte $0F,%10000011; + !byte $0F,%01100010 + !byte $11,%00100100 + !byte $B3,%00100000 + !byte $9D,%01000010 + !byte $2B,%00100000 + !byte $0D,%11000001 + !byte $0F,%01000010 + !byte $11,%00000100 + !byte $13,%11100101 + !byte $BB,%11100101 + !byte $BF,%00100100 + !byte $0D,%10100001 + !byte $15,%01000110 + !byte $17,%00101000 + !byte $0F,%10100001 + !byte $0F,%11100001 + !byte $AD,%00001100 + !byte $B9,%11000111 + !byte $BB,%01000110 + !byte $B1,%10000001; + !byte $B1,%01100000 + !byte $AB,%11000001 + !byte $A3,%00100010 + !byte $A1,%01000010 + !byte $31,%10000001; + !byte $31,%01100000 + !byte $2F,%01000000 + !byte $13,%00100100 + !byte $AF,%10101011 + !byte $B3,%11101001 + !byte $B9,%00000000 + !byte $9B,%10100011 + !byte $41,%11000011 + !byte $11,%01000010 + !byte $11,%10100011 + !byte $13,%00000100 + !byte $13,%01000100 + !byte $15,%11100101 + !byte $49,%00100100 + !byte $13,%10100011 + !byte $19,%11000111 + !byte $B5,%11001001 + !byte $B5,%10101001 + !byte $BB,%10000111; + !byte $BB,%01100110 + !byte $BF,%11000101 + !byte $B5,%10000001; + !byte $B5,%01100000 + !byte $AF,%11000001 + !byte $A9,%00000010 + !byte $A7,%00100010 + !byte $3B,%00100010 + !byte $0F,%00000000 + !byte $13,%10000011; + !byte $13,%01100010 + !byte $17,%00100110 + !byte $B1,%10001011; + !byte $B1,%01101010 + !byte $B7,%01001000 + !byte $BB,%00100000 + !byte $B7,%01000000 + !byte $A3,%01000010 + !byte $A1,%10000011; + !byte $A1,%01100010 + !byte $41,%10100011 + !byte $37,%11100001 + !byte $0F,%00100000 + !byte $11,%11000001 + !byte $13,%11000011 + !byte $17,%00000110 + !byte $19,%00001000 + !byte $1D,%10001011; + !byte $1D,%01101010 + !byte $4B,%01000100 + !byte $3F,%01000010 + !byte $11,%00100000 + !byte $13,%00000010 + !byte $B1,%10101011 + !byte $B9,%00101000 + !byte $BB,%11000111 + !byte $BD,%01000110 + !byte $BF,%11100101 + !byte $B3,%11000001 + !byte $AD,%00000010 + !byte $3B,%00000010 + !byte $11,%00000000 + !byte $13,%11100001 + !byte $15,%11100011 + !byte $B7,%10001001; + !byte $B7,%01101000 + !byte $BF,%00000110 + !byte $B5,%10100001 + !byte $AF,%11100001 + !byte $A9,%00100010 + !byte $A7,%01000010 + !byte $9D,%11000011 + !byte $15,%11000011 + !byte $17,%10100101 + !byte $1B,%00101000 + !byte $1B,%01001000 + !byte $1B,%10001001; + !byte $1B,%01101000 + !byte $13,%00100000 + !byte $15,%00000010 + !byte $17,%11000011 + !byte $B7,%10101001 + !byte $BB,%11100111 + !byte $9B,%00000100 + !byte $37,%10100001 + !byte $17,%00000100 + !byte $AF,%00001100 + !byte $BD,%10000001; + !byte $BD,%01100000 + !byte $B9,%10100001 + !byte $B3,%11100001 + !byte $AD,%00100010 + !byte $A1,%11000011 + !byte $45,%11000011 + !byte $31,%00000000 + !byte $15,%00100010 + !byte $17,%11100011 + !byte $19,%11000101 + !byte $43,%10000011; + !byte $43,%01100010 + !byte $19,%00100100 + !byte $1B,%01000110 + !byte $AF,%01001100 + !byte $BB,%00101000 + !byte $A7,%10100011 + !byte $A5,%11000011 + !byte $39,%10100001 + !byte $37,%10000001; + !byte $37,%01100000 + !byte $17,%00000010 + !byte $17,%01000010 + !byte $19,%00000100 + !byte $1B,%00000110 + !byte $B7,%11100001 + !byte $B1,%00100010 + !byte $15,%00000000 + !byte $15,%01000000 + !byte $17,%00100010 + !byte $19,%01000100 + !byte $39,%10000001; + !byte $39,%01100000 + !byte $19,%00100010 + !byte $B1,%00001100 + !byte $B5,%01001010 + !byte $BF,%11000111 + !byte $AD,%10000011; + !byte $AD,%01100010 + !byte $AB,%10100011 + !byte $9B,%01000100 + !byte $93,%10100101 + !byte $17,%00100000 + !byte $17,%10000001; + !byte $17,%01100000 + !byte $1B,%00100100 + !byte $B5,%10001011; + !byte $B5,%01101010 + !byte $BD,%00001000 + !byte $BB,%11100001 + !byte $B5,%00100010 + !byte $A7,%11000011 + !byte $A5,%11100011 + !byte $17,%01000000 + !byte $19,%10100011 + !byte $39,%01000000 + !byte $19,%01000000 + !byte $19,%10100001 + !byte $1B,%10100011 + !byte $1D,%10000101; + !byte $1D,%01100100 + !byte $B3,%11101011 + !byte $B1,%10000011; + !byte $B1,%01100010 + !byte $01,%00010010 + !byte $41,%00000010 + !byte $19,%10000001; + !byte $19,%01100000 + !byte $1B,%10000011; + !byte $1B,%01100010 + !byte $1D,%11100101 + !byte $AB,%11000011 + !byte $A3,%00000100 + !byte $A1,%00100100 + !byte $97,%10100101 + !byte $05,%11110001 + !byte $49,%11000011 + !byte $35,%00000000 + !byte $1B,%01000010 + !byte $1B,%11000011 + !byte $1D,%10100101 + !byte $1B,%10100001 + !byte $1D,%10100011 + !byte $1D,%00000100 + !byte $1F,%00100110 + !byte $AF,%11001101 + !byte $B5,%10000011; + !byte $B5,%01100010 + !byte $AF,%11000011 + !byte $A7,%00000100 + !byte $A1,%01000100 + !byte $03,%11110001 + !byte $47,%10000011; + !byte $47,%01100010 + !byte $1D,%11100011 + !byte $1F,%00000110 + !byte $B1,%01001100 + !byte $B7,%01001010 + !byte $B9,%00001010 + !byte $39,%00100000 + !byte $1B,%11000001 + !byte $1D,%11000011 + !byte $1D,%00000010 + !byte $1F,%00100100 + !byte $B9,%00101010 + !byte $BB,%11101001 + !byte $BF,%01001000 + !byte $B9,%10000011; + !byte $B9,%01100010 + !byte $B3,%11000011 + !byte $AB,%00000100 + !byte $45,%00100010 + !byte $3F,%10100001 + !byte $1D,%10100001 + !byte $1D,%11100001 + !byte $1D,%00100010 + !byte $1F,%00000100 + !byte $B1,%10001101; + !byte $B1,%01101100 + !byte $B5,%11101011 + !byte $B9,%01001010 + !byte $BD,%10101001 + !byte $AF,%11100011 + !byte $A7,%00100100 + !byte $A1,%10000101; + !byte $A1,%01100100 + !byte $01,%11110001 + !byte $3B,%00100000 + !byte $39,%00000000 + !byte $1D,%11000001 + !byte $1F,%11100011 + !byte $1F,%11000001 + !byte $1F,%00000010 + !byte $21,%11000101 + !byte $BB,%00101010 + !byte $BD,%10000011; + !byte $BD,%01100010 + !byte $B7,%11000011 + !byte $A7,%01000100 + !byte $A5,%10000101; + !byte $A5,%01100100 + !byte $99,%11100101 + !byte $07,%10110001 + !byte $4B,%10100011 + !byte $3F,%10000001; + !byte $3F,%01100000 + !byte $1F,%11100001 + !byte $1F,%01000010 + !byte $21,%10100101 + !byte $23,%11000111 + !byte $BD,%11001001 + !byte $B3,%11100011 + !byte $AB,%00100100 + !byte $03,%11010001 + !byte $4D,%11000011 + !byte $1F,%00100010 + !byte $1F,%10000011; + !byte $1F,%01100010 + !byte $3F,%01000000 + !byte $21,%10000011; + !byte $21,%01100010 + !byte $AF,%00001110 + !byte $B3,%10001101; + !byte $B3,%01101100 + !byte $B7,%11101011 + !byte $BF,%11001001 + !byte $BB,%11000011 + !byte $AF,%00100100 + !byte $47,%00000010 + !byte $1F,%00000000 + !byte $21,%01000010 + !byte $21,%11000011 + !byte $B1,%11001101 + !byte $BD,%00001010 + !byte $A7,%10000101; + !byte $A7,%01100100 + !byte $A5,%10100101 + !byte $05,%10110001 + !byte $01,%11010001 + !byte $21,%00100010 + !byte $21,%10100011 + !byte $25,%10101001 + !byte $41,%01000000 + !byte $21,%00100000 + !byte $23,%10000011; + !byte $23,%01100010 + !byte $23,%11100011 + !byte $BF,%11101001 + !byte $BF,%11000011 + !byte $BB,%11100011 + !byte $B3,%00100100 + !byte $AB,%10000101; + !byte $AB,%01100100 + !byte $23,%11000011 + !byte $23,%01000100 + !byte $B3,%10101101 + !byte $B7,%00000100 + !byte $AF,%01000100 + !byte $A3,%11000101 + !byte $3D,%00000000 + !byte $23,%10100011 + !byte $23,%00000100 + !byte $25,%00000100 + !byte $B3,%01000100 + !byte $A7,%11000101 + !byte $01,%10110001 + !byte $4F,%10100011 + !byte $45,%10100001 + !byte $23,%11000001 + !byte $25,%11100011 + !byte $25,%01000100 + !byte $B3,%11001101 + !byte $B5,%10001101; + !byte $B5,%01101100 + !byte $B9,%11101011 + !byte $BB,%00000100 + !byte $AB,%10100101 + !byte $57,%10000101; + !byte $57,%01100100 + !byte $47,%11100001 + !byte $41,%00100000 + !byte $3F,%00000000 + !byte $23,%00000000 + !byte $23,%01000000 + !byte $23,%10100001 + !byte $25,%00100100 + !byte $25,%11100001 + !byte $25,%00100010 + !byte $B7,%01000100 + !byte $AF,%10100101 + !byte $03,%10010001; + !byte $03,%01110000 + !byte $45,%10000001; + !byte $45,%01100000 + !byte $25,%10000001; + !byte $25,%01100000 + !byte $25,%11000001 + !byte $B5,%10101101 + !byte $BB,%11001011 + !byte $B3,%10000101; + !byte $B3,%01100100 + !byte $A7,%11100101 + !byte $4D,%01000010 + !byte $41,%00000000 + !byte $25,%00000000 + !byte $25,%01000000 + !byte $25,%10100001 + !byte $25,%01000010 + !byte $4B,%00000010 + !byte $27,%10100001 + !byte $27,%11100001 + !byte $27,%10100011 + !byte $B7,%10001101; + !byte $B7,%01101100 + !byte $BB,%11101011 + !byte $AB,%11100101 + !byte $45,%01000000 + !byte $27,%10000001; + !byte $27,%01100000 + !byte $27,%11000001 + !byte $27,%00100010 + !byte $27,%10000011; + !byte $27,%01100010 + !byte $27,%11100011 + !byte $B9,%00101100 + !byte $BD,%01000100 + !byte $AF,%11000101 + !byte $01,%10010001; + !byte $01,%01110000 + !byte $49,%11000001 + !byte $27,%00000010 + !byte $27,%01000010 + !byte $27,%11000011 + !byte $45,%00100000 + !byte $29,%01000010 + !byte $29,%11000011 + !byte $29,%00000110 + !byte $B7,%10101101 + !byte $B9,%01001100 + !byte $BB,%00001100 + !byte $B9,%10100101 + !byte $B3,%11000101 + !byte $A5,%00100110 + !byte $29,%10100011 + !byte $BD,%10000101; + !byte $BD,%01100100 + !byte $B5,%11000101 + !byte $AB,%00000110 + !byte $03,%01010000 + !byte $49,%10100001 + !byte $29,%10000011; + !byte $29,%01100010 + !byte $29,%11100011 + !byte $53,%10100011 + !byte $4F,%00100010 + !byte $47,%00100000 + !byte $AD,%11101111 + !byte $B3,%00101110 + !byte $B9,%11000101 + !byte $AF,%00000110 + !byte $B1,%10001111; + !byte $B1,%01101110 + !byte $B5,%11101101 + !byte $BD,%11101011 + !byte $BF,%11001011 + !byte $B3,%11100101 + !byte $A9,%00100110 + !byte $01,%01010000 + !byte $5B,%10000101; + !byte $5B,%01100100 + !byte $4D,%11100001 + !byte $49,%10000001; + !byte $49,%01100000 + !byte $2B,%10000111; + !byte $2B,%01100110 + !byte $2B,%11000111 + !byte $2B,%00000000 + !byte $2B,%01000000 + !byte $2B,%00000010 + !byte $BD,%11000101 + !byte $AB,%01000110 + !byte $0D,%11101111 + !byte $2B,%11100001 + !byte $BB,%01001100 + !byte $BF,%11101011 + !byte $B9,%11100101 + !byte $AF,%00100110 + !byte $03,%00110000 + !byte $2B,%10000001; + !byte $2B,%01100000 + !byte $2B,%11000001 + !byte $2D,%00000000 + !byte $2D,%01000000 + !byte $2D,%00000010 + !byte $2D,%10000011; + !byte $2D,%01100010 + !byte $2D,%11100011 + !byte $2D,%10000101; + !byte $2D,%01100100 + !byte $B7,%11101101 + !byte $B3,%00100110 + !byte $A5,%10100111 + !byte $01,%00110000 + !byte $53,%01000010 + !byte $49,%00100000 + !byte $2D,%10100001 + !byte $2D,%11100001 + !byte $2D,%01000010 + !byte $2D,%11000011 + !byte $2D,%00100100 + !byte $AB,%01010000 + !byte $BB,%10001101; + !byte $BB,%01101100 + !byte $BD,%11100101 + !byte $AF,%01000110 + !byte $9F,%11000111 + !byte $2D,%10000001; + !byte $2D,%01100000 + !byte $2D,%11000001 + !byte $2D,%00100010 + !byte $2D,%10100011 + !byte $2D,%11000101 + !byte $2D,%11100101 + !byte $2F,%00000000 + !byte $2F,%00000010 + !byte $B9,%11101101 + !byte $B9,%00100110 + !byte $B3,%01000110 + !byte $0D,%11001111 + !byte $4F,%11000001 + !byte $2F,%10100001 + !byte $2F,%11100001 + !byte $B1,%11001111 + !byte $BD,%00000110 + !byte $AD,%10000111; + !byte $AD,%01100110 + !byte $03,%00010000 + !byte $55,%10000011; + !byte $55,%01100010 + !byte $4D,%10000001; + !byte $4D,%01100000 + !byte $2F,%00100000 + !byte $2F,%10000001; + !byte $2F,%01100000 + !byte $2F,%11000001 + !byte $4B,%00000000 + !byte $BF,%00100110 + !byte $B9,%01000110 + !byte $AD,%10100111 + !byte $B3,%10000111; + !byte $B3,%01100110 + !byte $05,%11101111 + !byte $4F,%10000001; + !byte $4F,%01100000 + !byte $B7,%10000111; + !byte $B7,%01100110 + !byte $AD,%11000111 + !byte $AB,%11000111 + !byte $1B,%01001110 + !byte $03,%11101111 + !byte $51,%10100001 + !byte $31,%01000010 + !byte $31,%11100011 + !byte $31,%10000101; + !byte $31,%01100100 + !byte $31,%10100101 + !byte $31,%11000101 + !byte $B7,%01001110 + !byte $B9,%00001110 + !byte $B9,%10000111; + !byte $B9,%01100110 + !byte $B1,%10100111 + !byte $0F,%10101111 + !byte $61,%11000101 + !byte $55,%00100010 + !byte $53,%11100001 + !byte $4F,%01000000 + !byte $4D,%00100000 + !byte $31,%00100010 + !byte $31,%10100011 + !byte $31,%11000011 + !byte $57,%01000010 + !byte $33,%11000001 + !byte $33,%00100010 + !byte $33,%10100011 + !byte $AD,%10010001; + !byte $AD,%01110000 + !byte $BD,%10000111; + !byte $BD,%01100110 + !byte $B3,%11000111 + !byte $13,%10001111; + !byte $13,%01101110 + !byte $33,%01000000 + !byte $33,%10100001 + !byte $33,%00000010 + !byte $33,%10000011; + !byte $33,%01100010 + !byte $33,%11100011 + !byte $B5,%10101111 + !byte $BF,%10000111; + !byte $BF,%01100110 + !byte $B9,%10100111 + !byte $B7,%10100111 + !byte $AD,%11100111 + !byte $AB,%11100111 + !byte $17,%01001110 + !byte $0D,%10101111 + !byte $33,%10000001; + !byte $33,%01100000 + !byte $33,%11100001 + !byte $33,%01000010 + !byte $33,%11000011 + !byte $35,%10000001; + !byte $35,%01100000 + !byte $35,%11000001 + !byte $B3,%11101111 + !byte $BB,%00001110 + !byte $B1,%11100111 + !byte $03,%11001111 + !byte $01,%11001111 + !byte $5D,%11100011 + !byte $53,%10100001 + !byte $4F,%00000000 + !byte $35,%01000000 + !byte $35,%10100001 + !byte $33,%10100101 + !byte $BD,%10100111 + !byte $B7,%11000111 + !byte $AB,%00001000 + !byte $35,%00100000 + !byte $35,%11100001 + !byte $33,%10000101; + !byte $33,%01100100 + !byte $55,%11000001 + !byte $51,%00100000 + !byte $35,%10100011 + !byte $BD,%00001110 + !byte $B9,%11100111 + !byte $B1,%00001000 + !byte $AF,%00001000 + !byte $05,%10101111 + !byte $5F,%00000100 + !byte $5B,%10000011; + !byte $5B,%01100010 + !byte $57,%00000010 + !byte $37,%00000000 + !byte $37,%01000000 + !byte $35,%11100011 + !byte $35,%00000100 + !byte $BD,%11000111 + !byte $21,%00001110 + !byte $1B,%00101110 + !byte $37,%00100000 + !byte $35,%11000011 + !byte $35,%10000101; + !byte $35,%01100100 + !byte $37,%00100010 + !byte $37,%10100011 + !byte $AF,%10010001; + !byte $AF,%01110000 + !byte $BD,%00101110 + !byte $BF,%11100111 + !byte $B7,%00001000 + !byte $37,%00000010 + !byte $37,%10000011; + !byte $37,%01100010 + !byte $35,%00000110 + !byte $AB,%11110001 + !byte $B7,%11001111 + !byte $B9,%10001111; + !byte $B9,%01101110 + !byte $B1,%00101000 + !byte $AF,%00101000 + !byte $01,%10101111 + !byte $5D,%10100011 + !byte $37,%01000010 + !byte $37,%11000011 + !byte $37,%11100011 + !byte $57,%10100001 + !byte $39,%11000001 + !byte $39,%00100010 + !byte $37,%01000100 + !byte $AD,%11010001 + !byte $B3,%00110000 + !byte $BF,%00001000 + !byte $B7,%00101000 + !byte $B5,%00101000 + !byte $07,%10001111; + !byte $07,%01101110 + !byte $59,%11100001 + !byte $55,%01000000 + !byte $39,%00000010 + !byte $B5,%00010000 + !byte $BB,%10001111; + !byte $BB,%01101110 + !byte $BB,%00001000 + !byte $AF,%01001000 + !byte $AD,%01001000 + !byte $5B,%00100010 + !byte $53,%00000000 + !byte $39,%11100001 + !byte $39,%01000010 + !byte $37,%10000101; + !byte $37,%01100100 + !byte $37,%10100101 + !byte $5D,%01000010 + !byte $3B,%10000001; + !byte $3B,%01100000 + !byte $3B,%11000001 + !byte $39,%11000011 + !byte $39,%10000101; + !byte $39,%01100100 + !byte $BD,%00101000 + !byte $B5,%01001000 + !byte $B3,%01001000 + !byte $0B,%01001110 + !byte $07,%01001110 + !byte $5F,%11000011 + !byte $3B,%01000000 + !byte $AF,%10110001 + !byte $B1,%10010001; + !byte $B1,%01110000 + !byte $BF,%00101110 + !byte $BF,%00101000 + !byte $01,%10001111; + !byte $01,%01101110 + !byte $57,%10000001; + !byte $57,%01100000 + !byte $3B,%11100001 + !byte $39,%11100011 + !byte $37,%10100111 + !byte $3D,%10000001; + !byte $3D,%01100000 + !byte $3B,%11000011 + !byte $BB,%10101111 + !byte $BD,%01001000 + !byte $BB,%01001000 + !byte $AD,%10101001 + !byte $0F,%00101110 + !byte $59,%10100001 + !byte $3D,%01000000 + !byte $3D,%10100001 + !byte $3B,%10000011; + !byte $3B,%01100010 + !byte $3B,%10100011 + !byte $B3,%01010000 + !byte $B5,%10001001; + !byte $B5,%01101000 + !byte $B3,%10001001; + !byte $B3,%01101000 + !byte $3D,%00100000 + !byte $3B,%01000010 + !byte $3B,%11100011 + !byte $39,%11000101 + !byte $39,%00000110 + !byte $5D,%00000010 + !byte $3D,%00100010 + !byte $3B,%10000101; + !byte $3B,%01100100 + !byte $3B,%10100101 + !byte $B7,%00010000 + !byte $BD,%10101111 + !byte $BB,%10001001; + !byte $BB,%01101000 + !byte $3D,%00000010 + !byte $3D,%10000011; + !byte $3D,%01100010 + !byte $B9,%11101111 + !byte $BD,%10001001; + !byte $BD,%01101000 + !byte $B3,%10101001 + !byte $B1,%10101001 + !byte $A9,%11001001 + !byte $3F,%00100000 + !byte $3D,%01000010 + !byte $3F,%11000001 + !byte $3F,%00100010 + !byte $B7,%00110000 + !byte $B9,%10101001 + !byte $5B,%10000001; + !byte $5B,%01100000 + !byte $3F,%00000010 + !byte $AD,%00010010 + !byte $B9,%00010000 + !byte $BB,%10101001 + !byte $B1,%11001001 + !byte $AF,%11001001 + !byte $6B,%00100110 + !byte $67,%10000101; + !byte $67,%01100100 + !byte $59,%00100000 + !byte $3F,%11100001 + !byte $3D,%11100011 + !byte $3D,%00000100 + !byte $41,%11000001 + !byte $3F,%11000011 + !byte $3D,%11000101 + !byte $B7,%11001001 + !byte $A3,%00001010 + !byte $09,%00001110 + !byte $01,%00101110 + !byte $41,%10100001 + !byte $3F,%10000011; + !byte $3F,%01100010 + !byte $3F,%10100011 + !byte $A5,%11010011 + !byte $B3,%10110001 + !byte $B5,%10010001; + !byte $B5,%01110000 + !byte $BD,%11001111 + !byte $BB,%11001001 + !byte $B9,%11001001 + !byte $AF,%11101001 + !byte $15,%11101101 + !byte $0B,%00001110 + !byte $41,%10000001; + !byte $41,%01100000 + !byte $41,%11100001 + !byte $3F,%11100011 + !byte $61,%00100010 + !byte $41,%00100010 + !byte $3D,%00100110 + !byte $BB,%00010000 + !byte $B5,%11101001 + !byte $AF,%00001010 + !byte $69,%10100101 + !byte $43,%10100001 + !byte $41,%10000011; + !byte $41,%01100010 + !byte $3F,%01000100 + !byte $3B,%00001000 + !byte $B9,%11101001 + !byte $B7,%11101001 + !byte $11,%11101101 + !byte $07,%00001110 + !byte $03,%00001110 + !byte $5B,%00000000 + !byte $43,%00100000 + !byte $43,%10000001; + !byte $43,%01100000 + !byte $41,%01000010 + !byte $45,%00000000 + !byte $43,%00100010 + !byte $BB,%00110000 + !byte $B3,%00001010 + !byte $63,%01000010 + !byte $5F,%10100001 + !byte $43,%00000010 + !byte $41,%00100100 + !byte $B9,%01010000 + !byte $B7,%00001010 + !byte $B5,%00001010 + !byte $A7,%00101010 + !byte $0D,%11101101 + !byte $61,%11100001 + !byte $43,%11100001 + !byte $43,%01000010 + !byte $41,%11100011 + !byte $41,%00000100 + !byte $67,%11100011 + !byte $5D,%00000000 + !byte $47,%00000000 + !byte $45,%11000001 + !byte $43,%10100011 + !byte $43,%11000011 + !byte $B7,%10110001 + !byte $BF,%11101111 + !byte $01,%11101101 + !byte $45,%00000010 + !byte $AB,%10010011; + !byte $AB,%01110010 + !byte $AF,%00110010 + !byte $BF,%00001010 + !byte $B5,%00101010 + !byte $B3,%00101010 + !byte $B1,%00101010 + !byte $11,%11001101 + !byte $07,%11101101 + !byte $5F,%01000000 + !byte $45,%11100001 + !byte $43,%11100011 + !byte $49,%00000000 + !byte $47,%11000001 + !byte $45,%10100011 + !byte $41,%00000110 + !byte $BD,%00101010 + !byte $69,%00000100 + !byte $47,%10100001 + !byte $45,%10000011; + !byte $45,%01100010 + !byte $43,%00100100 + !byte $BF,%00101010 + !byte $B3,%01001010 + !byte $B1,%01001010 + !byte $AF,%01001010 + !byte $1D,%10101101 + !byte $0F,%11001101 + !byte $0B,%11001101 + !byte $09,%11001101 + !byte $61,%10100001 + !byte $47,%10000001; + !byte $47,%01100000 + !byte $45,%01000010 + !byte $43,%00000100 + !byte $49,%01000000 + !byte $BB,%01001010 + !byte $67,%10000011; + !byte $67,%01100010 + !byte $45,%00000100 + !byte $B1,%00110010 + !byte $B3,%00010010 + !byte $BF,%01001010 + !byte $BD,%01001010 + !byte $AF,%10001011; + !byte $AF,%01101010 + !byte $13,%10101101 + !byte $11,%10101101 + !byte $65,%00000010 + !byte $47,%00100010 + !byte $47,%01000010 + !byte $45,%11100011 + !byte $6B,%00100100 + !byte $67,%00100010 + !byte $4B,%01000000 + !byte $49,%00000010 + !byte $47,%10100011 + !byte $45,%10100101 + !byte $B9,%10001011; + !byte $B9,%01101010 + !byte $B7,%10001011; + !byte $B7,%01101010 + !byte $4B,%00100000 + !byte $4B,%10000001; + !byte $4B,%01100000 + !byte $49,%11100001 + !byte $BD,%10001011; + !byte $BD,%01101010 + !byte $BB,%10001011; + !byte $BB,%01101010 + !byte $0D,%10101101 + !byte $0B,%10101101 + !byte $6F,%00000110 + !byte $69,%10100011 + !byte $63,%10000001; + !byte $63,%01100000 + !byte $49,%00100010 + !byte $47,%11000011 + !byte $47,%11100011 + !byte $49,%10100011 + !byte $B9,%10101011 + !byte $B7,%10101011 + !byte $B5,%10101011 + !byte $B3,%10101011 + !byte $1B,%10001101; + !byte $1B,%01101100 + !byte $17,%10001101; + !byte $17,%01101100 + !byte $63,%00100000 + !byte $4B,%11100001 + !byte $49,%10000011; + !byte $49,%01100010 + !byte $47,%00000100 + !byte $47,%00100100 + !byte $BF,%01010000 + !byte $BD,%10101011 + !byte $BB,%10101011 + !byte $65,%11000001 + !byte $4D,%00000000 + !byte $4D,%01000000 + !byte $4B,%11000001 + !byte $67,%11100001 + !byte $4F,%00100000 + !byte $4D,%10100001 + !byte $4B,%10000011; + !byte $4B,%01100010 + !byte $47,%10000101; + !byte $47,%01100100 + !byte $B7,%11001011 + !byte $B5,%11001011 + !byte $B3,%11001011 + !byte $B1,%11001011 + !byte $AF,%11001011 + !byte $13,%10001101; + !byte $13,%01101100 + !byte $03,%10001101; + !byte $03,%01101100 + !byte $6B,%11000011 + !byte $65,%10000001; + !byte $65,%01100000 + !byte $4B,%01000010 + !byte $49,%11100011 + !byte $49,%00000100 + !byte $BF,%10010001; + !byte $BF,%01110000 + !byte $B9,%11001011 + !byte $AB,%11001011 + !byte $0F,%10001101; + !byte $0F,%01101100 + !byte $0D,%10001101; + !byte $0D,%01101100 + !byte $09,%10001101; + !byte $09,%01101100 + !byte $05,%10001101; + !byte $05,%01101100 + !byte $01,%10010011; + !byte $01,%01110010 + !byte $4D,%11000001 + !byte $4B,%00100010 + !byte $49,%01000100 + !byte $B1,%11101011 + !byte $AF,%11101011 + !byte $01,%01010010 + !byte $51,%00000000 + !byte $4D,%00100010 + !byte $4B,%11100011 + !byte $AD,%11010011 + !byte $AF,%10110011 + !byte $B7,%00010010 + !byte $6D,%11100011 + !byte $67,%10100001 + !byte $65,%00100000 + !byte $4F,%10100001 + !byte $4D,%00000010 + !byte $4B,%11000011 + !byte $47,%11100101 + !byte $51,%10000001; + !byte $51,%01100000 + !byte $4F,%11100001 + !byte $4D,%10000011; + !byte $4D,%01100010 + !byte $4B,%00100100 + !byte $1B,%01001100 + !byte $13,%01001100 + !byte $01,%01001100 + !byte $6F,%00100100 + !byte $6B,%01000010 + !byte $67,%01000000 + !byte $51,%01000000 + !byte $4B,%00000100 + !byte $B9,%00010010 + !byte $BD,%11010001 + !byte $0B,%01001100 + !byte $07,%01001100 + !byte $05,%01001100 + !byte $01,%00110010 + !byte $69,%11100001 + !byte $4F,%00000010 + !byte $4D,%10100011 + !byte $6D,%10000011; + !byte $6D,%01100010 + !byte $6B,%11100001 + !byte $51,%11100001 + !byte $4F,%01000010 + !byte $4D,%00000100 + !byte $B1,%10110011 + !byte $BB,%00010010 + !byte $BF,%00001100 + !byte $BD,%00001100 + !byte $6B,%00000010 + !byte $69,%10100001 + !byte $53,%01000000 + !byte $51,%11000001 + !byte $4D,%11100011 + !byte $BD,%11110001 + !byte $B9,%00001100 + !byte $B7,%00001100 + !byte $B5,%00001100 + !byte $B3,%00001100 + !byte $03,%00110010 + !byte $75,%10100111 + !byte $6F,%00000100 + !byte $67,%00000000 + !byte $53,%00100000 + !byte $4F,%10000011; + !byte $4F,%01100010 + !byte $53,%11000001 + !byte $51,%01000010 + !byte $4F,%11100011 + !byte $4D,%00100100 + !byte $BF,%00101100 + !byte $BD,%00101100 + !byte $15,%00101100 + !byte $03,%00010010 + !byte $6B,%10100001 + !byte $51,%00100010 + !byte $4F,%11000011 + !byte $B7,%00101100 + !byte $B5,%00101100 + !byte $B3,%00101100 + !byte $B1,%00101100 + !byte $AF,%00101100 + !byte $2D,%00101100 + !byte $1D,%00101100 + !byte $0D,%00101100 + !byte $09,%00101100 + !byte $55,%00100000 + !byte $4D,%01000100 + !byte $4B,%11000101 + !byte $6B,%01000000 + !byte $57,%00000000 + !byte $53,%00100010 + !byte $51,%11000011 + !byte $B9,%01010010 + !byte $BF,%01001100 + !byte $BD,%01001100 + !byte $57,%00100000 + !byte $55,%10100001 + !byte $53,%00000010 + !byte $51,%10100011 + !byte $BB,%00110010 + !byte $B7,%01001100 + !byte $B5,%01001100 + !byte $B3,%01001100 + !byte $73,%10100101 + !byte $6F,%10000011; + !byte $6F,%01100010 + !byte $6D,%00000010 + !byte $51,%10000011; + !byte $51,%01100010 + !byte $4F,%00000100 + !byte $4F,%00100100 + !byte $BF,%00010010 + !byte $11,%00001100 + !byte $71,%11000011 + !byte $6B,%00000000 + !byte $55,%11100001 + !byte $55,%00000010 + !byte $53,%10000011; + !byte $53,%01100010 + !byte $B5,%10110011 + !byte $B7,%10010011; + !byte $B7,%01110010 + !byte $0F,%00001100 + !byte $0B,%00001100 + !byte $75,%11100101 + !byte $73,%10000101; + !byte $73,%01100100 + !byte $73,%01000100 + !byte $59,%00000000 + !byte $51,%11100011 + !byte $51,%00000100 + !byte $4F,%01000100 + !byte $B1,%11110011 + !byte $B7,%10110011 + !byte $AF,%10001101; + !byte $AF,%01101100 + !byte $AD,%10001101; + !byte $AD,%01101100 + !byte $01,%11101011 + !byte $75,%11000101 + !byte $71,%10100011 + !byte $59,%10000001; + !byte $59,%01100000 + !byte $57,%11100001 + !byte $55,%01000010 + !byte $51,%01000100 + !byte $BD,%00110010 + !byte $23,%00001100 + !byte $1D,%00001100 + !byte $59,%01000000 + !byte $57,%11000001 + !byte $53,%11000011 + !byte $53,%11100011 + !byte $51,%00100100 + !byte $73,%11000011 + !byte $6F,%11000001 + !byte $6F,%10000001; + !byte $6F,%01100000 + !byte $55,%10100011 + !byte $BB,%10101101 + !byte $B9,%10101101 + !byte $B1,%10101101 + !byte $AF,%10101101 + !byte $13,%11101011 + !byte $11,%11101011 + !byte $0D,%11101011 + !byte $03,%10110001 + !byte $71,%01000010 + !byte $59,%11000001 + !byte $53,%00000100 + !byte $53,%00100100 + !byte $51,%10000101; + !byte $51,%01100100 + !byte $BF,%00110010 + !byte $05,%11010001 + !byte $79,%11100111 + !byte $75,%10100101 + !byte $71,%00100010 + !byte $5B,%01000000 + !byte $57,%00100010 + !byte $55,%11000011 + !byte $57,%10000011; + !byte $57,%01100010 + !byte $BD,%11001101 + !byte $BB,%11001101 + !byte $B9,%11001101 + !byte $B7,%11001101 + !byte $B5,%11001101 + !byte $1B,%11101011 + !byte $03,%11001011 + !byte $71,%11100001 + !byte $5D,%01000000 + !byte $5B,%11000001 + !byte $59,%00100010 + !byte $55,%11100011 + !byte $55,%00000100 + !byte $53,%01000100 + !byte $53,%10000101; + !byte $53,%01100100 + !byte $51,%11100101 + !byte $B9,%10110011 + !byte $BF,%11001101 + !byte $1F,%11101011 + !byte $15,%11101011 + !byte $07,%11001011 + !byte $05,%11001011 + !byte $07,%11010001 + !byte $5D,%00100000 + !byte $5B,%10100001 + !byte $59,%00000010 + !byte $57,%10100011 + !byte $5D,%10000001; + !byte $5D,%01100000 + !byte $5B,%11100001 + !byte $59,%01000010 + !byte $55,%00100100 + !byte $55,%01000100 + !byte $BD,%11101101 + !byte $BB,%11101101 + !byte $23,%11101011 + !byte $13,%11001011 + !byte $0F,%11001011 + !byte $73,%00100010 + !byte $5D,%10100001 + !byte $57,%11000011 + !byte $57,%11100011 + !byte $51,%00100110 + !byte $BF,%11101101 + !byte $05,%10010001; + !byte $05,%01110000 + !byte $75,%11100011 + !byte $71,%10000001; + !byte $71,%01100000 + !byte $5F,%00100000 + !byte $5B,%00000010 + !byte $59,%10000011; + !byte $59,%01100010 + !byte $73,%11100001 + !byte $71,%00100000 + !byte $57,%00000100 + !byte $BB,%10110011 + !byte $B3,%11101101 + !byte $B1,%11101101 + !byte $AF,%11101101 + !byte $1B,%11001011 + !byte $05,%01010000 + !byte $75,%10000011; + !byte $75,%01100010 + !byte $61,%00100000 + !byte $59,%10100011 + !byte $59,%11000011 + !byte $BF,%00001110 + !byte $19,%11001011 + !byte $09,%10101011 + !byte $07,%10101011 + !byte $01,%00010000 + !byte $07,%10010001; + !byte $07,%01110000 + !byte $61,%00000000 + !byte $5F,%10000001; + !byte $5F,%01100000 + !byte $5D,%11100001 + !byte $5B,%01000010 + !byte $57,%00100100 + !byte $55,%10000101; + !byte $55,%01100100 + !byte $55,%10100101 + !byte $77,%00100100 + !byte $61,%01000000 + !byte $59,%11100011 + !byte $BB,%11010011 + !byte $B7,%00001110 + !byte $B5,%00001110 + !byte $B3,%00001110 + !byte $B1,%00001110 + !byte $0F,%10101011 + !byte $01,%10001011; + !byte $01,%01101010 + !byte $01,%11101111 + !byte $07,%01010000 + !byte $61,%10000001; + !byte $61,%01100000 + !byte $5F,%11100001 + !byte $5B,%10100011 + !byte $1F,%11001011 + !byte $03,%10001011; + !byte $03,%01101010 + !byte $05,%00110000 + !byte $09,%10010001; + !byte $09,%01110000 + !byte $77,%00000100 + !byte $63,%00000000 + !byte $5F,%11000001 + !byte $5D,%00100010 + !byte $59,%00000100 + !byte $57,%01000100 + !byte $77,%10000011; + !byte $77,%01100010 + !byte $5F,%00000010 + !byte $5B,%11000011 + !byte $B9,%11110011 + !byte $BB,%00101110 + !byte $B9,%00101110 + !byte $B7,%00101110 + !byte $B5,%00101110 + !byte $05,%00010000 + !byte $09,%01010000 + !byte $79,%01000100 + !byte $65,%00000000 + !byte $5D,%10000011; + !byte $5D,%01100010 + !byte $59,%01000100 + !byte $BD,%11010011 + !byte $AB,%00001110 + !byte $0B,%10001011; + !byte $0B,%01101010 + !byte $09,%10001011; + !byte $09,%01101010 + !byte $07,%00110000 + !byte $7D,%00101000 + !byte $75,%11100001 + !byte $75,%10100001 + !byte $63,%01000000 + !byte $61,%11000001 + !byte $5F,%00100010 + !byte $5B,%11100011 + !byte $59,%00100100 + !byte $57,%10100101 + !byte $5F,%10000011; + !byte $5F,%01100010 + !byte $BD,%01001110 + !byte $BB,%01001110 + !byte $B9,%01001110 + !byte $B1,%00101110 + !byte $11,%10001011; + !byte $11,%01101010 + !byte $03,%01001010 + !byte $01,%01001010 + !byte $07,%00010000 + !byte $77,%00000010 + !byte $65,%01000000 + !byte $5F,%01000010 + !byte $5B,%00000100 + !byte $5B,%00100100 + !byte $59,%10000101; + !byte $59,%01100100 + !byte $BF,%01001110 + !byte $AF,%00101110 + !byte $05,%01001010 + !byte $09,%00110000 + !byte $0B,%01010000 + !byte $79,%00100100 + !byte $75,%00100000 + !byte $63,%10100001 + !byte $61,%00000010 + !byte $5D,%11000011 + !byte $79,%10100011 + !byte $61,%01000010 + !byte $5B,%01000100 + !byte $BD,%10001111; + !byte $BD,%01101110 + !byte $B5,%01001110 + !byte $B3,%01001110 + !byte $B1,%01001110 + !byte $AF,%01001110 + !byte $01,%01001110 + !byte $05,%11001111 + !byte $09,%00010000 + !byte $0B,%00110000 + !byte $7B,%10000101; + !byte $7B,%01100100 + !byte $77,%10100001 + !byte $65,%10100001 + !byte $63,%00000010 + !byte $5D,%00000100 + !byte $59,%10100101 + !byte $59,%11000101 + !byte $BF,%10001111; + !byte $BF,%01101110 + !byte $17,%10001011; + !byte $17,%01101010 + !byte $15,%10001011; + !byte $15,%01101010 + !byte $0D,%01001010 + !byte $0B,%01001010 + !byte $01,%00101010 + !byte $07,%11101111 + !byte $67,%00100000 + !byte $63,%11100001 + !byte $5F,%10100011 + !byte $7B,%00000100 + !byte $79,%00000010 + !byte $63,%00100010 + !byte $5F,%11100011 + !byte $BF,%11110011 + !byte $B7,%10001111; + !byte $B7,%01101110 + !byte $B5,%10001111; + !byte $B5,%01101110 + !byte $B3,%10001111; + !byte $B3,%01101110 + !byte $1B,%10001011; + !byte $1B,%01101010 + !byte $19,%10001011; + !byte $19,%01101010 + !byte $0F,%01001010 + !byte $07,%11001111 + !byte $0D,%00110000 + !byte $7D,%10000111; + !byte $7D,%01100110 + !byte $7D,%01000110 + !byte $7D,%00100110 + !byte $7B,%00100100 + !byte $77,%00100000 + !byte $69,%00100000 + !byte $61,%10100011 + !byte $BF,%10101111 + !byte $13,%01001010 + !byte $07,%00101010 + !byte $09,%11101111 + !byte $0B,%00010000 + !byte $7B,%01000100 + !byte $77,%00000000 + !byte $67,%10000001; + !byte $67,%01100000 + !byte $65,%11100001 + !byte $61,%10000011; + !byte $61,%01100010 + !byte $5D,%00100100 + !byte $5D,%01000100 + !byte $5B,%10100101 + !byte $7F,%00101000 + !byte $7B,%11000011 + !byte $79,%10100001 + !byte $79,%01000000 + !byte $6B,%00100000 + !byte $61,%11000011 + !byte $B9,%10101111 + !byte $B7,%10101111 + !byte $01,%00001010 + !byte $05,%10001111; + !byte $05,%01101110 + !byte $0B,%11101111 + !byte $7D,%10100101 + !byte $7B,%10000011; + !byte $7B,%01100010 + !byte $69,%10000001; + !byte $69,%01100000 + !byte $63,%10000011; + !byte $63,%01100010 + !byte $AF,%10001111; + !byte $AF,%01101110 + !byte $1F,%10001011; + !byte $1F,%01101010 + !byte $0D,%00101010 + !byte $01,%00001110 + !byte $03,%00101110 + !byte $07,%10101111 + !byte $09,%11001111 + !byte $0D,%00010000 + !byte $7B,%10100011 + !byte $67,%11000001 + !byte $65,%00100010 + !byte $61,%11100011 + !byte $5F,%00100100 + !byte $5D,%10000101; + !byte $5D,%01100100 + !byte $5B,%11000101 + !byte $7D,%00100100 + !byte $7B,%00100010 + !byte $6B,%10000001; + !byte $6B,%01100000 + !byte $65,%10000011; + !byte $65,%01100010 + !byte $63,%10100011 + !byte $BB,%11001111 + !byte $B9,%11001111 + !byte $B3,%10101111 + !byte $B1,%10101111 + !byte $25,%10001011; + !byte $25,%01101010 + !byte $11,%00101010 + !byte $05,%00101110 + !byte $7D,%10000101; + !byte $7D,%01100100 + !byte $79,%00000000 + !byte $6D,%00000000 + !byte $69,%11000001 + !byte $65,%01000010 + !byte $61,%00000100 + !byte $5F,%01000100 + !byte $5D,%10100101 + !byte $5D,%11000101 + !byte $AF,%10101111 + !byte $09,%10101111 + !byte $0B,%11001111 + !byte $7B,%11000001 + !byte $6D,%00100000 + !byte $67,%00000010 + !byte $63,%11000011 + !byte $7B,%00100000 + !byte $6F,%00000000 + !byte $6B,%11000001 + !byte $67,%01000010 + !byte $63,%00000100 + !byte $61,%01000100 + !byte $BD,%11101111 + !byte $BB,%11101111 + !byte $B5,%11001111 + !byte $B3,%11001111 + !byte $0B,%00001010 + !byte $0B,%10101111 + !byte $7F,%00000110 + !byte $7D,%10100011 + !byte $6D,%01000000 + !byte $69,%00000010 + !byte $63,%11100011 + !byte $61,%00100100 + !byte $5F,%10000101; + !byte $5F,%01100100 + !byte $5F,%10100101 + !byte $5D,%11100101 + !byte $2F,%10101011 + !byte $0F,%00001010 + !byte $0D,%00001010 + !byte $05,%11101001 + !byte $03,%11101001 + !byte $01,%11001101 + !byte $03,%11101101 + !byte $05,%00001110 + !byte $09,%10001111; + !byte $09,%01101110 + !byte $0F,%00010000 + !byte $7F,%00100110 + !byte $7B,%01000000 + !byte $7B,%00000000 + !byte $6D,%10000001; + !byte $6D,%01100000 + !byte $65,%10100011 + !byte $6F,%01000000 + !byte $69,%00100010 + !byte $65,%11100011 + !byte $BF,%00010000 + !byte $BD,%00010000 + !byte $B5,%11101111 + !byte $03,%11001101 + !byte $05,%11101101 + !byte $09,%01001110 + !byte $0F,%11101111 + !byte $7F,%10100101 + !byte $7D,%11000001 + !byte $6D,%10100001 + !byte $67,%10100011 + !byte $65,%11000011 + !byte $AF,%11001111 + !byte $AD,%11001111 + !byte $1B,%00101010 + !byte $0B,%10001111; + !byte $0B,%01101110 + !byte $7F,%11000101 + !byte $71,%00000000 + !byte $6D,%11000001 + !byte $69,%01000010 + !byte $63,%00100100 + !byte $61,%10000101; + !byte $61,%01100100 + !byte $5F,%11000101 + !byte $6F,%10100001 + !byte $5F,%11100101 + !byte $BF,%00110000 + !byte $B1,%11101111 + !byte $25,%01001010 + !byte $17,%00001010 + !byte $0D,%10001111; + !byte $0D,%01101110 + !byte $11,%11101111 + !byte $7F,%11000011 + !byte $7F,%01000010 + !byte $73,%00000000 + !byte $6D,%11100001 + !byte $69,%10000011; + !byte $69,%01100010 + !byte $65,%00100100 + !byte $63,%10000101; + !byte $63,%01100100 + !byte $5D,%00100110 + !byte $AF,%11101111 + !byte $1F,%00101010 + !byte $0D,%11101001 + !byte $03,%10101101 + !byte $05,%11001101 + !byte $09,%00101110 + !byte $0F,%11001111 + !byte $71,%01000000 + !byte $6B,%00100010 + !byte $67,%11000011 + !byte $65,%00000100 + !byte $63,%01000100 + !byte $61,%10100101 + !byte $7F,%11000001 + !byte $6F,%11100001 + !byte $6B,%10000011; + !byte $6B,%01100010 + !byte $5F,%00000110 + !byte $B3,%00010000 + !byte $B1,%00010000 + !byte $05,%10101101 + !byte $07,%11001101 + !byte $81,%11000101 + !byte $7F,%01000000 + !byte $73,%01000000 + !byte $6D,%00100010 + !byte $67,%00000100 + !byte $65,%01000100 + !byte $63,%10100101 + !byte $B9,%00110000 + !byte $2F,%10001011; + !byte $2F,%01101010 + !byte $19,%00001010 + !byte $13,%11101001 + !byte $03,%10101001 + !byte $01,%00101100 + !byte $03,%01001100 + !byte $0B,%00101110 + !byte $0D,%01001110 + !byte $11,%11001111 + !byte $81,%00000110 + !byte $71,%10100001 + !byte $69,%11000011 + !byte $61,%11100101 + !byte $81,%11000011 + !byte $75,%01000000 + !byte $71,%11000001 + !byte $6F,%00100010 + !byte $6D,%01000010 + !byte $67,%00100100 + !byte $AF,%00010000 + !byte $25,%00101010 + !byte $17,%11101001 + !byte $03,%10001001; + !byte $03,%01101000 + !byte $01,%00001100 + !byte $03,%00101100 + !byte $0D,%00101110 + !byte $0F,%10001111; + !byte $0F,%01101110 + !byte $13,%11001111 + !byte $81,%11100011 + !byte $81,%00100010 + !byte $6F,%00000010 + !byte $6B,%10100011 + !byte $69,%11100011 + !byte $63,%11000101 + !byte $BB,%01010000 + !byte $B5,%00110000 + !byte $AD,%00010000 + !byte $11,%11001001 + !byte $07,%10101101 + !byte $11,%10101111 + !byte $81,%10100011 + !byte $7F,%00000000 + !byte $73,%10000001; + !byte $73,%01100000 + !byte $65,%10000101; + !byte $65,%01100100 + !byte $61,%00000110 + !byte $5F,%01000110 + !byte $81,%11100001 + !byte $81,%01000000 + !byte $81,%00000000 + !byte $71,%00000010 + !byte $6D,%10100011 + !byte $63,%11100101 + !byte $B1,%00110000 + !byte $AF,%00110000 + !byte $01,%01001000 + !byte $01,%11001011 + !byte $07,%10001101; + !byte $07,%01101100 + !byte $09,%10101101 + !byte $0B,%11101101 + !byte $11,%10001111; + !byte $11,%01101110 + !byte $81,%11000001 + !byte $75,%10000001; + !byte $75,%01100000 + !byte $61,%00100110 + !byte $BD,%10010001; + !byte $BD,%01110000 + !byte $BB,%10010001; + !byte $BB,%01110000 + !byte $B7,%01010000 + !byte $B5,%01010000 + !byte $15,%11001001 + !byte $03,%00001100 + !byte $05,%00101100 + !byte $0D,%00001110 + !byte $0F,%01001110 + !byte $13,%10101111 + !byte $73,%11000001 + !byte $6F,%01000010 + !byte $6B,%11100011 + !byte $69,%00100100 + !byte $67,%01000100 + !byte $65,%10100101 + !byte $83,%11100011 + !byte $79,%00100000 + !byte $77,%10000001; + !byte $77,%01100000 + !byte $63,%00000110 + !byte $1D,%11101001 + !byte $17,%11001001 + !byte $0B,%10001001; + !byte $0B,%01101000 + !byte $03,%11101011 + !byte $05,%00001100 + !byte $07,%00101100 + !byte $0F,%00001110 + !byte $83,%00000100 + !byte $75,%11000001 + !byte $6B,%00000100 + !byte $69,%01000100 + !byte $67,%10100101 + !byte $BF,%10110001 + !byte $BD,%10110001 + !byte $B9,%10010001; + !byte $B9,%01110000 + !byte $B7,%10010001; + !byte $B7,%01110000 + !byte $B1,%01010000 + !byte $AD,%00110000 + !byte $23,%00001010 + !byte $01,%10101011 + !byte $11,%01001110 + !byte $83,%11000011 + !byte $73,%00000010 + !byte $6F,%10100011 + !byte $6D,%11000011 + !byte $65,%11000101 + !byte $65,%11100101 + !byte $83,%00100000 + !byte $77,%11000001 + !byte $6D,%00000100 + !byte $69,%10000101; + !byte $69,%01100100 + !byte $63,%00100110 + !byte $AF,%01010000 + !byte $0F,%10001001; + !byte $0F,%01101000 + !byte $09,%01001000 + !byte $03,%10101011 + !byte $09,%01001100 + !byte $13,%01001110 + !byte $75,%00000010 + !byte $6F,%11000011 + !byte $67,%11000101 + !byte $BF,%11010001 + !byte $B9,%10110001 + !byte $B3,%10010001; + !byte $B3,%01110000 + !byte $AD,%01010000 + !byte $21,%11101001 + !byte $1B,%11001001 + !byte $05,%11101011 + !byte $07,%00001100 + !byte $0B,%10001101; + !byte $0B,%01101100 + !byte $0D,%11001101 + !byte $0F,%11101101 + !byte $11,%00101110 + !byte $15,%10101111 + !byte $85,%10001001; + !byte $85,%01101000 + !byte $79,%10000001; + !byte $79,%01100000 + !byte $73,%01000010 + !byte $71,%10000011; + !byte $71,%01100010 + !byte $6B,%01000100 + !byte $65,%00000110 + !byte $67,%11100101 + !byte $BB,%11010001 + !byte $B9,%11010001 + !byte $29,%00001010 + !byte $0D,%01001000 + !byte $07,%11101011 + !byte $09,%00001100 + !byte $11,%00001110 + !byte $15,%10001111; + !byte $15,%01101110 + !byte $85,%11000011 + !byte $85,%01000010 + !byte $85,%11000001 + !byte $85,%10000001; + !byte $85,%01100000 + !byte $7D,%00100000 + !byte $7B,%10000001; + !byte $7B,%01100000 + !byte $77,%11100001 + !byte $73,%10000011; + !byte $73,%01100010 + !byte $65,%00100110 + !byte $BF,%11110001 + !byte $B5,%10110001 + !byte $11,%10001001; + !byte $11,%01101000 + !byte $07,%00101000 + !byte $05,%10101011 + !byte $13,%00101110 + !byte $85,%11100011 + !byte $85,%00100010 + !byte $79,%11000001 + !byte $75,%00100010 + !byte $6F,%11100011 + !byte $6D,%00100100 + !byte $6B,%10000101; + !byte $6B,%01100100 + !byte $69,%11000101 + !byte $7F,%00100000 + !byte $7D,%10000001; + !byte $7D,%01100000 + !byte $79,%11100001 + !byte $6D,%10000101; + !byte $6D,%01100100 + !byte $67,%00000110 + !byte $BB,%11110001 + !byte $B7,%11010001 + !byte $B5,%11010001 + !byte $11,%01001000 + !byte $05,%10001011; + !byte $05,%01101010 + !byte $15,%01001110 + !byte $77,%00100010 + !byte $75,%01000010 + !byte $71,%11100011 + !byte $6D,%01000100 + !byte $6B,%10100101 + !byte $65,%01000110 + !byte $B1,%10110001 + !byte $AB,%10010001; + !byte $AB,%01110000 + !byte $2F,%00101010 + !byte $25,%11101001 + !byte $21,%11001001 + !byte $19,%10101001 + !byte $0B,%00101000 + !byte $05,%00001000 + !byte $09,%11101011 + !byte $0B,%00101100 + !byte $0D,%01001100 + !byte $0F,%10101101 + !byte $13,%00001110 + !byte $17,%10001111; + !byte $17,%01101110 + !byte $73,%10100011 + !byte $69,%11100101 + !byte $67,%00100110 + !byte $87,%00000100 + !byte $87,%01000010 + !byte $87,%11000001 + !byte $87,%10000001; + !byte $87,%01100000 + !byte $87,%00100000 + !byte $79,%00100010 + !byte $77,%01000010 + !byte $73,%11100011 + !byte $71,%00000100 + !byte $6B,%11000101 + !byte $BD,%00010010 + !byte $B9,%11110001 + !byte $B7,%11110001 + !byte $B3,%11010001 + !byte $B1,%11010001 + !byte $AD,%10110001 + !byte $23,%11001001 + !byte $0D,%00101000 + !byte $01,%11001001 + !byte $05,%00101010 + !byte $09,%11001011 + !byte $0B,%11101011 + !byte $13,%11101101 + !byte $87,%10001001; + !byte $87,%01101000 + !byte $87,%01000000 + !byte $87,%00000000 + !byte $7D,%10100001 + !byte $75,%10100011 + !byte $69,%00000110 + !byte $1F,%10101001 + !byte $0F,%00101000 + !byte $09,%00001000 + !byte $03,%11100111 + !byte $03,%00001010 + !byte $07,%10001011; + !byte $07,%01101010 + !byte $15,%00101110 + !byte $87,%11100111 + !byte $87,%10100011 + !byte $7F,%10000001; + !byte $7F,%01100000 + !byte $7B,%11100001 + !byte $6F,%01000100 + !byte $6D,%10100101 + !byte $67,%01000110 + !byte $7F,%10100001 + !byte $77,%10100011 + !byte $75,%11000011 + !byte $6B,%11100101 + !byte $B5,%11110001 + !byte $B3,%11110001 + !byte $AB,%10110001 + !byte $2F,%00001010 + !byte $11,%00101000 + !byte $07,%01001010 + !byte $0F,%01001100 + !byte $17,%00101110 + !byte $81,%10000001; + !byte $81,%01100000 + !byte $7D,%11100001 + !byte $79,%01000010 + !byte $71,%01000100 + !byte $69,%00100110 + !byte $AF,%11010001 + !byte $0D,%00001000 + !byte $0B,%11001011 + !byte $0D,%00001100 + !byte $0F,%00101100 + !byte $11,%10001101; + !byte $11,%01101100 + !byte $13,%11001101 + !byte $15,%00001110 + !byte $73,%00000100 + !byte $71,%00100100 + !byte $6F,%10000101; + !byte $6F,%01100100 + !byte $6D,%11000101 + !byte $67,%10000111; + !byte $67,%01100110 + !byte $89,%11000011 + !byte $89,%00100010 + !byte $89,%01000000 + !byte $83,%10000001; + !byte $83,%01100000 + !byte $7F,%11100001 + !byte $7B,%01000010 + !byte $79,%10000011; + !byte $79,%01100010 + !byte $75,%00000100 + !byte $73,%00100100 + !byte $71,%10000101; + !byte $71,%01100100 + !byte $B1,%11110001 + !byte $AF,%11110001 + !byte $AB,%11010001 + !byte $07,%11000111 + !byte $07,%00001010 + !byte $0B,%10101011 + !byte $0D,%11001011 + !byte $15,%11001101 + !byte $19,%01001110 + !byte $89,%11100011 + !byte $77,%11000011 + !byte $6F,%10100101 + !byte $6D,%11100101 + !byte $69,%01000110 + !byte $BF,%01010010 + !byte $BD,%01010010 + !byte $B9,%00110010 + !byte $B5,%00010010 + !byte $1D,%10001001; + !byte $1D,%01101000 + !byte $19,%01001000 + !byte $09,%01001010 + !byte $11,%01001100 + !byte $17,%00001110 + !byte $89,%00000100 + !byte $89,%00000010 + !byte $89,%11000001 + !byte $85,%00100000 + !byte $81,%10100001 + !byte $7D,%00000010 + !byte $6B,%00000110 + !byte $8B,%11000001 + !byte $79,%11000011 + !byte $77,%11100011 + !byte $6F,%11000101 + !byte $B1,%00010010 + !byte $03,%01001000 + !byte $0F,%11101011 + !byte $11,%00101100 + !byte $19,%00101110 + !byte $8B,%01000000 + !byte $83,%10100001 + !byte $7F,%00000010 + !byte $6D,%00000110 + !byte $6B,%01000110 + !byte $BF,%10010011; + !byte $BF,%01110010 + !byte $BB,%01010010 + !byte $B7,%00110010 + !byte $B5,%00110010 + !byte $AD,%11110001 + !byte $2D,%11101001 + !byte $13,%00001000 + !byte $0D,%11100111 + !byte $01,%10000111; + !byte $01,%01100110 + !byte $09,%00001010 + !byte $0D,%10101011 + !byte $15,%10101101 + !byte $17,%11101101 + !byte $8B,%00100000 + !byte $7D,%01000010 + !byte $75,%00100100 + !byte $71,%10100101 + !byte $6F,%11100101 + !byte $69,%10000111; + !byte $69,%01100110 + !byte $8B,%11100011 + !byte $85,%10100001 + !byte $81,%00000010 + !byte $7D,%10000011; + !byte $7D,%01100010 + !byte $BF,%10110011 + !byte $BB,%10010011; + !byte $BB,%01110010 + !byte $AF,%00010010 + !byte $A9,%11110001 + !byte $2F,%11101001 + !byte $15,%00001000 + !byte $0D,%11000111 + !byte $03,%10000111; + !byte $03,%01100110 + !byte $01,%11000111 + !byte $09,%11101001 + !byte $0D,%10001011; + !byte $0D,%01101010 + !byte $17,%11001101 + !byte $8B,%01000010 + !byte $79,%11100011 + !byte $75,%01000100 + !byte $71,%11000101 + !byte $6B,%10000111; + !byte $6B,%01100110 + !byte $BD,%10010011; + !byte $BD,%01110010 + !byte $B7,%01010010 + !byte $B3,%00110010 + !byte $37,%00101010 + !byte $23,%10001001; + !byte $23,%01101000 + !byte $1D,%01001000 + !byte $11,%11100111 + !byte $09,%10100111 + !byte $01,%11100111 + !byte $05,%01001000 + !byte $07,%10101001 + !byte $0B,%00101010 + !byte $13,%00101100 + !byte $15,%10001101; + !byte $15,%01101100 + !byte $19,%00001110 + !byte $8B,%11000011 + !byte $8B,%00100010 + !byte $6D,%00100110 + !byte $69,%10100111 + !byte $8D,%10100001 + !byte $8D,%01000000 + !byte $89,%10000001; + !byte $89,%01100000 + !byte $7D,%11000011 + !byte $7B,%11100011 + !byte $79,%00000100 + !byte $75,%10000101; + !byte $75,%01100100 + !byte $71,%11100101 + !byte $BD,%10110011 + !byte $B9,%10010011; + !byte $B9,%01110010 + !byte $B3,%01010010 + !byte $21,%01001000 + !byte $0B,%10100111 + !byte $07,%10001001; + !byte $07,%01101000 + !byte $11,%11001011 + !byte $13,%00001100 + !byte $15,%01001100 + !byte $17,%10101101 + !byte $1B,%00001110 + !byte $8D,%00100000 + !byte $83,%00000010 + !byte $6F,%00100110 + !byte $AB,%00010010 + !byte $2D,%11001001 + !byte $07,%10000111; + !byte $07,%01100110 + !byte $09,%11001001 + !byte $0B,%11101001 + !byte $0F,%10001011; + !byte $0F,%01101010 + !byte $19,%11001101 + !byte $19,%11101101 + !byte $8D,%11000001 + !byte $8D,%00000000 + !byte $85,%11100001 + !byte $81,%01000010 + !byte $7F,%10000011; + !byte $7F,%01100010 + !byte $77,%01000100 + !byte $73,%11000101 + !byte $6D,%01000110 + !byte $85,%00000010 + !byte $7F,%10100011 + !byte $B5,%10010011; + !byte $B5,%01110010 + !byte $AD,%00110010 + !byte $2B,%10101001 + !byte $17,%11100111 + !byte $09,%10000111; + !byte $09,%01100110 + !byte $03,%00100110 + !byte $03,%10100111 + !byte $05,%11100111 + !byte $1B,%11101101 + !byte $8D,%11000011 + !byte $8B,%10000001; + !byte $8B,%01100000 + !byte $87,%11100001 + !byte $83,%01000010 + !byte $81,%10000011; + !byte $81,%01100010 + !byte $77,%10000101; + !byte $77,%01100100 + !byte $6F,%01000110 + !byte $6B,%10100111 + !byte $B1,%01010010 + !byte $A9,%00010010 + !byte $37,%00001010 + !byte $27,%10001001; + !byte $27,%01101000 + !byte $1B,%00001000 + !byte $01,%00100110 + !byte $09,%10001001; + !byte $09,%01101000 + !byte $11,%10101011 + !byte $15,%00001100 + !byte $17,%01001100 + !byte $19,%10101101 + !byte $1D,%00101110 + !byte $8B,%11100111 + !byte $8D,%11100011 + !byte $8F,%00100000 + !byte $7D,%11100011 + !byte $73,%11100101 + !byte $71,%00000110 + !byte $6D,%10000111; + !byte $6D,%01100110 + !byte $8D,%10000001; + !byte $8D,%01100000 + !byte $89,%11100001 + !byte $7F,%11100011 + !byte $7D,%00000100 + !byte $6F,%10000111; + !byte $6F,%01100110 + !byte $B3,%10010011; + !byte $B3,%01110010 + !byte $B1,%10010011; + !byte $B1,%01110010 + !byte $1D,%00001000 + !byte $19,%11100111 + !byte $11,%10100111 + !byte $01,%00000110 + !byte $03,%01000110 + !byte $05,%10100111 + !byte $0D,%11001001 + !byte $13,%10101011 + !byte $17,%00101100 + !byte $19,%10001101; + !byte $19,%01101100 + !byte $1D,%00001110 + !byte $73,%00000110 + !byte $6B,%11000111 + !byte $BD,%11110011 + !byte $B9,%11010011 + !byte $AF,%01010010 + !byte $AD,%01010010 + !byte $AB,%00110010 + !byte $A9,%00110010 + !byte $2D,%10101001 + !byte $25,%01001000 + !byte $15,%11000111 + !byte $0D,%10000111; + !byte $0D,%01100110 + !byte $07,%11100111 + !byte $09,%00101000 + !byte $11,%01001010 + !byte $1B,%11001101 + !byte $8F,%00100010 + !byte $8F,%10100001 + !byte $8B,%10100001 + !byte $87,%00000010 + !byte $83,%10000011; + !byte $83,%01100010 + !byte $79,%10000101; + !byte $79,%01100100 + !byte $77,%10100101 + !byte $71,%00100110 + !byte $6D,%10100111 + !byte $8F,%11000011 + !byte $91,%10100001 + !byte $91,%01000000 + !byte $87,%00100010 + !byte $83,%10100011 + !byte $6F,%10100111 + !byte $AB,%01010010 + !byte $A7,%00110010 + !byte $15,%10100111 + !byte $0D,%10001001; + !byte $0D,%01101000 + !byte $0F,%11101001 + !byte $11,%00001010 + !byte $15,%11001011 + !byte $17,%00001100 + !byte $1D,%11101101 + !byte $8B,%11100001 + !byte $85,%10000011; + !byte $85,%01100010 + !byte $79,%10100101 + !byte $71,%01000110 + !byte $BB,%11110011 + !byte $B7,%11010011 + !byte $B3,%10110011 + !byte $AF,%10010011; + !byte $AF,%01110010 + !byte $2B,%10001001; + !byte $2B,%01101000 + !byte $03,%00000110 + !byte $05,%01000110 + !byte $07,%10100111 + !byte $09,%11100111 + !byte $0F,%11001001 + !byte $13,%10001011; + !byte $13,%01101010 + !byte $15,%10101011 + !byte $17,%11101011 + !byte $19,%01001100 + !byte $1B,%10101101 + !byte $8D,%11100111 + !byte $8F,%10000001; + !byte $8F,%01100000 + !byte $7F,%00000100 + !byte $77,%11000101 + !byte $75,%00000110 + !byte $73,%00100110 + !byte $6D,%11000111 + !byte $91,%10100011 + !byte $91,%01000010 + !byte $91,%00000010 + !byte $8D,%11100001 + !byte $89,%01000010 + !byte $81,%00000100 + !byte $7F,%00100100 + !byte $7D,%01000100 + !byte $B7,%11110011 + !byte $2D,%10001001; + !byte $2D,%01101000 + !byte $0B,%00100110 + !byte $07,%00000110 + !byte $0F,%10101001 + !byte $13,%00101010 + !byte $1F,%00001110 + !byte $8F,%11100101 + !byte $91,%10000001; + !byte $91,%01100000 + !byte $8F,%11000001 + !byte $77,%11100101 + !byte $75,%00100110 + !byte $71,%10000111; + !byte $71,%01100110 + !byte $B5,%11010011 + !byte $B3,%11010011 + !byte $AD,%10010011; + !byte $AD,%01110010 + !byte $A9,%01010010 + !byte $29,%01001000 + !byte $0B,%00001000 + !byte $11,%11101001 + !byte $17,%11001011 + !byte $19,%00001100 + !byte $19,%00101100 + !byte $1D,%11001101 + !byte $8B,%00000010 + !byte $87,%10000011; + !byte $87,%01100010 + !byte $85,%10100011 + !byte $7B,%10100101 + !byte $79,%11000101 + !byte $73,%01000110 + !byte $6F,%11000111 + !byte $6D,%11100111 + !byte $91,%11000001 + !byte $77,%00000110 + !byte $75,%01000110 + !byte $B5,%11110011 + !byte $AD,%10110011 + !byte $27,%00101000 + !byte $23,%00001000 + !byte $15,%10000111; + !byte $15,%01100110 + !byte $0F,%01001000 + !byte $15,%01001010 + !byte $17,%10101011 + !byte $19,%11101011 + !byte $1B,%00101100 + !byte $1F,%11001101 + !byte $1F,%11101101 + !byte $91,%11100011 + !byte $93,%00000010 + !byte $8D,%00000010 + !byte $89,%10000011; + !byte $89,%01100010 + !byte $81,%00100100 + !byte $7F,%01000100 + !byte $7B,%11000101 + !byte $71,%10100111 + !byte $B1,%11010011 + !byte $A7,%01010010 + !byte $19,%10100111 + !byte $11,%01000110 + !byte $0B,%00000110 + !byte $07,%11100101 + !byte $0B,%11000111 + !byte $11,%10101001 + !byte $13,%00001010 + !byte $15,%00101010 + !byte $1D,%10001101; + !byte $1D,%01101100 + !byte $8D,%11101001 + !byte $91,%00000100 + !byte $91,%11000011 + !byte $93,%11100001 + !byte $93,%10100001 + !byte $8F,%11100001 + !byte $79,%11100101 + !byte $73,%10000111; + !byte $73,%01100110 + !byte $6D,%00001000 + !byte $91,%11000101 + !byte $8F,%00000010 + !byte $8B,%10000011; + !byte $8B,%01100010 + !byte $85,%00000100 + !byte $83,%00100100 + !byte $81,%01000100 + !byte $7F,%10000101; + !byte $7F,%01100100 + !byte $7B,%11100101 + !byte $B3,%11110011 + !byte $A9,%10010011; + !byte $A9,%01110010 + !byte $A7,%10010011; + !byte $A7,%01110010 + !byte $1B,%10100111 + !byte $11,%00100110 + !byte $0D,%00000110 + !byte $07,%11000101 + !byte $09,%00000110 + !byte $0F,%00001000 + !byte $15,%00001010 + !byte $1F,%10101101 + !byte $8F,%00001000 + !byte $91,%11100101 + !byte $79,%00000110 + !byte $73,%10100111 + !byte $AF,%11010011 + !byte $AB,%10110011 + !byte $39,%11101001 + !byte $33,%10101001 + !byte $25,%00001000 + !byte $21,%11100111 + !byte $1F,%11000111 + !byte $09,%00100110 + !byte $0B,%10000111; + !byte $0B,%01100110 + !byte $13,%11001001 + !byte $17,%01001010 + !byte $19,%10101011 + !byte $1B,%00001100 + !byte $1D,%01001100 + !byte $21,%11101101 + !byte $91,%10100101 + !byte $93,%10100011 + !byte $89,%10100011 + !byte $7D,%11000101 + !byte $77,%00100110 + !byte $75,%10000111; + !byte $75,%01100110 + !byte $71,%11000111 + !byte $6F,%11100111 + !byte $91,%00000110 + !byte $95,%00000010 + !byte $AF,%11110011 + !byte $0F,%11000111 + !byte $13,%10001001; + !byte $13,%01101000 + !byte $17,%00101010 + !byte $95,%11100001 + !byte $8D,%10000011; + !byte $8D,%01100010 + !byte $8B,%10100011 + !byte $85,%00100100 + !byte $83,%01000100 + !byte $81,%10000101; + !byte $81,%01100100 + !byte $7D,%11100101 + !byte $77,%01000110 + !byte $73,%11000111 + !byte $A9,%10110011 + !byte $25,%11100111 + !byte $19,%10000111; + !byte $19,%01100110 + !byte $17,%01000110 + !byte $0F,%11100111 + !byte $1F,%10001101; + !byte $1F,%01101100 + !byte $21,%11001101 + !byte $8F,%01000010 + !byte $7B,%00000110 + !byte $79,%00100110 + !byte $71,%11100111 + !byte $6F,%00001000 + !byte $93,%11000101 + !byte $95,%11000011 + !byte $95,%10000011; + !byte $95,%01100010 + !byte $8F,%10000011; + !byte $8F,%01100010 + !byte $87,%00100100 + !byte $81,%10100101 + !byte $7D,%00000110 + !byte $77,%10000111; + !byte $77,%01100110 + !byte $73,%11100111 + !byte $AB,%11010011 + !byte $A9,%11010011 + !byte $19,%01000110 + !byte $0F,%10000111; + !byte $0F,%01100110 + !byte $13,%00101000 + !byte $15,%10101001 + !byte $19,%01001010 + !byte $1B,%10101011 + !byte $1D,%11101011 + !byte $21,%10101101 + !byte $93,%11100101 + !byte $95,%11100011 + !byte $95,%10100011 + !byte $7B,%00100110 + !byte $AD,%11110011 + !byte $A7,%10110011 + !byte $39,%11001001 + !byte $2F,%01001000 + !byte $15,%00100110 + !byte $0F,%11100101 + !byte $0B,%11000101 + !byte $0F,%10100111 + !byte $15,%10001001; + !byte $15,%01101000 + !byte $19,%00101010 + !byte $1F,%00101100 + !byte $1F,%01001100 + !byte $23,%11101101 + !byte $8F,%10101001 + !byte $8D,%10100011 + !byte $85,%01000100 + !byte $83,%10000101; + !byte $83,%01100100 + !byte $7F,%11100101 + !byte $79,%01000110 + !byte $71,%00001000 + !byte $6F,%00101000 + !byte $93,%00000110 + !byte $95,%00100010 + !byte $15,%00000110 + !byte $0F,%11000101 + !byte $0D,%11100101 + !byte $0F,%00100110 + !byte $13,%11100111 + !byte $15,%01001000 + !byte $19,%11101001 + !byte $21,%01001100 + !byte $21,%10001101; + !byte $21,%01101100 + !byte $93,%00100110 + !byte $97,%10000011; + !byte $97,%01100010 + !byte $91,%10000011; + !byte $91,%01100010 + !byte $8F,%10100011 + !byte $8B,%00000100 + !byte $89,%00100100 + !byte $87,%01000100 + !byte $85,%10000101; + !byte $85,%01100100 + !byte $83,%10100101 + !byte $79,%10000111; + !byte $79,%01100110 + !byte $75,%11000111 + !byte $AB,%11110011 + !byte $A7,%11010011 + !byte $A5,%10110011 + !byte $37,%10101001 + !byte $21,%10100111 + !byte $15,%00101000 + !byte $17,%10101001 + !byte $1B,%01001010 + !byte $1D,%10101011 + !byte $1D,%11001011 + !byte $1F,%00001100 + !byte $23,%11001101 + !byte $91,%00101000 + !byte $91,%00001000 + !byte $97,%01000010 + !byte $97,%00000010 + !byte $93,%01000010 + !byte $7B,%01000110 + !byte $77,%10100111 + !byte $71,%00101000 + !byte $95,%11100101 + !byte $99,%00000010 + !byte $93,%10000011; + !byte $93,%01100010 + !byte $81,%11100101 + !byte $79,%10100111 + !byte $73,%00001000 + !byte $2D,%00001000 + !byte $29,%11100111 + !byte $23,%10100111 + !byte $13,%10100111 + !byte $17,%01001000 + !byte $1B,%00001010 + !byte $21,%00101100 + !byte $95,%01000010 + !byte $75,%11100111 + !byte $A9,%11110011 + !byte $35,%10001001; + !byte $35,%01101000 + !byte $33,%01001000 + !byte $1D,%01000110 + !byte $1B,%00100110 + !byte $13,%11000111 + !byte $19,%11001001 + !byte $23,%10001101; + !byte $23,%01101100 + !byte $23,%10101101 + !byte $25,%11101101 + !byte $95,%11000101 + !byte $97,%00100010 + !byte $8B,%00100100 + !byte $89,%01000100 + !byte $87,%10000101; + !byte $87,%01100100 + !byte $85,%10100101 + !byte $83,%11000101 + !byte $7B,%10000111; + !byte $7B,%01100110 + !byte $77,%11000111 + !byte $95,%00000110 + !byte $97,%01000100 + !byte $99,%10000011; + !byte $99,%01100010 + !byte $A7,%11110011 + !byte $13,%01000110 + !byte $17,%00001000 + !byte $19,%10001001; + !byte $19,%01101000 + !byte $1D,%00101010 + !byte $1D,%01001010 + !byte $1F,%10101011 + !byte $21,%11101011 + !byte $95,%00100110 + !byte $97,%10000101; + !byte $97,%01100100 + !byte $97,%00100100 + !byte $99,%01000010 + !byte $8F,%00000100 + !byte $8D,%00100100 + !byte $8B,%01000100 + !byte $89,%10000101; + !byte $89,%01100100 + !byte $87,%10100101 + !byte $85,%11000101 + !byte $83,%11100101 + !byte $7B,%10100111 + !byte $77,%11100111 + !byte $39,%10101001 + !byte $37,%10001001; + !byte $37,%01101000 + !byte $31,%00101000 + !byte $2B,%11100111 + !byte $27,%11000111 + !byte $25,%10100111 + !byte $1F,%01000110 + !byte $19,%00000110 + !byte $0F,%10100101 + !byte $11,%11100101 + !byte $13,%10000111; + !byte $13,%01100110 + !byte $1B,%11101001 + !byte $21,%00001100 + !byte $23,%01001100 + !byte $25,%11001101 + !byte $79,%11000111 + !byte $75,%00001000 + !byte $73,%00101000 + !byte $71,%01001000 + !byte $95,%01000110 + !byte $99,%11100011 + !byte $93,%11100011 + !byte $81,%00100110 + !byte $7B,%11000111 + !byte $75,%00101000 + !byte $2F,%00001000 + !byte $13,%10100101 + !byte $13,%00000110 + !byte $17,%11000111 + !byte $19,%00101000 + !byte $1B,%10101001 + !byte $93,%00101000 + !byte $95,%10000111; + !byte $95,%01100110 + !byte $7F,%01000110 + !byte $77,%00001000 + !byte $A5,%11110011 + !byte $A3,%11010011 + !byte $35,%01001000 + !byte $25,%10000111; + !byte $25,%01100110 + !byte $11,%10100101 + !byte $1D,%00001010 + !byte $1F,%01001010 + !byte $21,%11001011 + !byte $23,%00101100 + !byte $25,%10001101; + !byte $25,%01101100 + !byte $25,%10101101 + !byte $91,%00001010 + !byte $97,%11000101 + !byte $8F,%00100100 + !byte $8D,%01000100 + !byte $8B,%10000101; + !byte $8B,%01100100 + !byte $89,%10100101 + !byte $87,%11000101 + !byte $85,%11100101 + !byte $83,%00000110 + !byte $73,%01001000 + !byte $99,%10100011 + !byte $91,%00100100 + !byte $8F,%01000100 + !byte $8D,%10000101; + !byte $8D,%01100100 + !byte $8B,%10100101 + !byte $89,%11000101 + !byte $87,%11100101 + !byte $7F,%10000111; + !byte $7F,%01100110 + !byte $39,%10001001; + !byte $39,%01101000 + !byte $33,%00101000 + !byte $1B,%11100101 + !byte $15,%10100101 + !byte $13,%11000101 + !byte $1D,%11001001 + !byte $1F,%00001010 + !byte $97,%11100101 + !byte $93,%00000100 + !byte $85,%00000110 + !byte $83,%00100110 + !byte $7D,%10100111 + !byte $A3,%11110011 + !byte $17,%10100111 + !byte $1D,%10101001 + !byte $21,%10001011; + !byte $21,%01101010 + !byte $21,%10101011 + !byte $25,%01001100 + !byte $27,%11001101 + !byte $97,%00000110 + !byte $99,%01000100 + !byte $9B,%10000011; + !byte $9B,%01100010 + !byte $97,%11000011 + !byte $81,%01000110 + !byte $93,%11001001 + !byte $97,%01000110 + !byte $97,%11100011 + !byte $83,%01000110 + !byte $7D,%11000111 + !byte $77,%00101000 + !byte $1B,%11100111 + !byte $21,%00101010 + !byte $21,%01001010 + !byte $23,%10101011 + !byte $23,%11001011 + !byte $27,%10001101; + !byte $27,%01101100 + !byte $97,%10000111; + !byte $97,%01100110 + !byte $99,%11000101 + !byte $99,%11000011 + !byte $91,%01000100 + !byte $8F,%10000101; + !byte $8F,%01100100 + !byte $8D,%10100101 + !byte $8B,%11000101 + !byte $89,%11100101 + !byte $81,%10000111; + !byte $81,%01100110 + !byte $79,%00001000 + !byte $25,%01000110 + !byte $15,%11000101 + !byte $1F,%11001001 + !byte $1F,%11101001 + !byte $25,%00001100 + !byte $25,%00101100 + !byte $27,%10101101 + !byte $9B,%00100100 + !byte $95,%00000100 + !byte $93,%00100100 + !byte $87,%00000110 + !byte $85,%00100110 + !byte $7F,%10100111 + !byte $7B,%11100111 + !byte $75,%01001000 + !byte $73,%10001001; + !byte $73,%01101000 + !byte $97,%10100111 + !byte $9B,%10000101; + !byte $9B,%01100100 + !byte $9D,%11100011 + !byte $9D,%10100011 + !byte $95,%00100100 + !byte $93,%01000100 + !byte $87,%00100110 + !byte $29,%10000111; + !byte $29,%01100110 + !byte $27,%01000110 + !byte $15,%01000100 + !byte $17,%11100101 + !byte $19,%00100110 + !byte $1F,%10001001; + !byte $1F,%01101000 + !byte $27,%01001100 + !byte $95,%01001000 + !byte $97,%11000111 + !byte $97,%00000100 + !byte $85,%01000110 + !byte $7F,%11000111 + !byte $33,%00001000 + !byte $1F,%11100101 + !byte $17,%10000101; + !byte $17,%01100100 + !byte $15,%10000101; + !byte $15,%01100100 + !byte $17,%11000101 + !byte $1B,%11000111 + !byte $1D,%00101000 + !byte $21,%00001010 + !byte $23,%01001010 + !byte $23,%10001011; + !byte $23,%01101010 + !byte $25,%11001011 + !byte $25,%11101011 + !byte $29,%11001101 + !byte $9B,%11000011 + !byte $91,%10000101; + !byte $91,%01100100 + !byte $8F,%10100101 + !byte $8D,%11000101 + !byte $8B,%11100101 + !byte $89,%00000110 + !byte $83,%10000111; + !byte $83,%01100110 + !byte $81,%10100111 + !byte $7D,%11100111 + !byte $7B,%00001000 + !byte $79,%00101000 + !byte $77,%01001000 + !byte $75,%10001001; + !byte $75,%01101000 + !byte $73,%10101001 + !byte $97,%11100111 + !byte $9D,%00000100 + !byte $9B,%11100011 + !byte $8F,%11000101 + !byte $8D,%11100101 + !byte $21,%11100101 + !byte $19,%10000101; + !byte $19,%01100100 + !byte $19,%11100101 + !byte $21,%10101001 + !byte $27,%00001100 + !byte $27,%00101100 + !byte $29,%10101101 + !byte $9D,%00100100 + !byte $95,%01000100 + !byte $93,%10000101; + !byte $93,%01100100 + !byte $8B,%00000110 + !byte $89,%00100110 + !byte $7B,%00101000 + !byte $1B,%10000111; + !byte $1B,%01100110 + !byte $1D,%11100111 + !byte $1F,%01001000 + !byte $23,%00101010 + !byte $25,%10101011 + !byte $29,%10001101; + !byte $29,%01101100 + !byte $91,%11101011 + !byte $99,%00000100 + !byte $87,%01000110 + !byte $85,%10000111; + !byte $85,%01100110 + !byte $83,%10100111 + !byte $81,%11000111 + !byte $7F,%11100111 + !byte $7D,%00001000 + !byte $79,%01001000 + !byte $77,%10001001; + !byte $77,%01101000 + !byte $81,%11100111 + !byte $7B,%01001000 + !byte $27,%00100110 + !byte $23,%11100101 + !byte $1B,%10000101; + !byte $1B,%01100100 + !byte $19,%10100101 + !byte $1D,%10100111 + !byte $1F,%00001000 + !byte $23,%11101001 + !byte $27,%11001011 + !byte $27,%11101011 + !byte $97,%01001000 + !byte $99,%11000111 + !byte $85,%10100111 + !byte $2D,%10000111; + !byte $2D,%01100110 + !byte $1D,%10000111; + !byte $1D,%01100110 + !byte $1F,%11100111 + !byte $21,%10001001; + !byte $21,%01101000 + !byte $29,%00101100 + !byte $29,%01001100 + !byte $93,%10001011; + !byte $93,%01101010 + !byte $9F,%11100011 + !byte $95,%10000101; + !byte $95,%01100100 + !byte $8D,%00000110 + !byte $8B,%00100110 + !byte $89,%01000110 + !byte $87,%10000111; + !byte $87,%01100110 + !byte $83,%11000111 + !byte $7F,%00001000 + !byte $75,%10101001 + !byte $97,%10001001; + !byte $97,%01101000 + !byte $99,%11100111 + !byte $95,%10100101 + !byte $8F,%00000110 + !byte $8D,%00100110 + !byte $8B,%01000110 + !byte $31,%10100111 + !byte $27,%00000110 + !byte $1F,%10100101 + !byte $1D,%00000110 + !byte $21,%00101000 + !byte $25,%00001010 + !byte $27,%10001011; + !byte $27,%01101010 + !byte $27,%10101011 + !byte $2B,%10101101 + !byte $9F,%00000100 + !byte $89,%10000111; + !byte $89,%01100110 + !byte $83,%11100111 + !byte $1B,%10100101 + !byte $1D,%00100110 + !byte $1F,%10100111 + !byte $21,%00001000 + !byte $23,%10101001 + !byte $29,%00001100 + !byte $2B,%10001101; + !byte $2B,%01101100 + !byte $99,%10000101; + !byte $99,%01100100 + !byte $87,%10100111 + !byte $85,%11000111 + !byte $81,%00001000 + !byte $79,%10001001; + !byte $79,%01101000 + !byte $77,%10101001 + !byte $75,%11001001 + !byte $9F,%10100101 + !byte $A1,%00000100 + !byte $99,%10100101 + !byte $87,%11000111 + !byte $1D,%11000101 + !byte $21,%11000111 + !byte $23,%01001000 + !byte $9B,%11000111 + !byte $9D,%00000110 + !byte $9D,%01000100 + !byte $8F,%00100110 + !byte $8D,%01000110 + !byte $85,%11100111 + !byte $1B,%01000100 + !byte $23,%00101000 + !byte $25,%11001001 + !byte $27,%00101010 + !byte $27,%01001010 + !byte $29,%11001011 + !byte $29,%11101011 + !byte $2B,%01001100 + !byte $9D,%00100110 + !byte $9F,%00100100 + !byte $8B,%10000111; + !byte $8B,%01100110 + !byte $89,%10100111 + !byte $7D,%01001000 + !byte $7B,%10001001; + !byte $7B,%01101000 + !byte $79,%10101001 + !byte $77,%11001001 + !byte $9B,%11100111 + !byte $9F,%11000101 + !byte $8B,%10100111 + !byte $33,%10100111 + !byte $1F,%01000100 + !byte $1F,%11000101 + !byte $21,%10000111; + !byte $21,%01100110 + !byte $23,%11100111 + !byte $25,%10001001; + !byte $25,%01101000 + !byte $2B,%00001100 + !byte $2B,%00101100 + !byte $9F,%11100101 + !byte $9B,%10100101 + !byte $89,%11000111 + !byte $81,%00101000 + !byte $45,%11001001 + !byte $43,%10101001 + !byte $2F,%01000110 + !byte $2B,%00000110 + !byte $1D,%01000100 + !byte $21,%01000110 + !byte $27,%11101001 + !byte $27,%00001010 + !byte $29,%10001011; + !byte $29,%01101010 + !byte $29,%10101011 + !byte $2D,%10001101; + !byte $2D,%01101100 + !byte $2D,%10101101 + !byte $9F,%01000100 + !byte $9D,%10000101; + !byte $9D,%01100100 + !byte $91,%00100110 + !byte $8F,%01000110 + !byte $8D,%10000111; + !byte $8D,%01100110 + !byte $83,%00001000 + !byte $7F,%01001000 + !byte $7D,%10001001; + !byte $7D,%01101000 + !byte $7B,%10101001 + !byte $75,%11101001 + !byte $9B,%00101000 + !byte $A1,%10100101 + !byte $9F,%10000101; + !byte $9F,%01100100 + !byte $91,%01000110 + !byte $8F,%10000111; + !byte $8F,%01100110 + !byte $21,%01000100 + !byte $1F,%10000101; + !byte $1F,%01100100 + !byte $23,%10000111; + !byte $23,%01100110 + !byte $27,%10101001 + !byte $27,%11001001 + !byte $2B,%10101011 + !byte $2B,%11001011 + !byte $2B,%11101011 + !byte $2D,%01001100 + !byte $9F,%00000110 + !byte $A1,%11000101 + !byte $8D,%10100111 + !byte $8B,%11000111 + !byte $83,%00101000 + !byte $79,%11001001 + !byte $25,%10100101 + !byte $25,%00101000 + !byte $29,%00101010 + !byte $29,%01001010 + !byte $99,%10101001 + !byte $9B,%00001000 + !byte $9F,%00100110 + !byte $9D,%10100101 + !byte $9B,%11000101 + !byte $89,%11100111 + !byte $85,%00001000 + !byte $81,%01001000 + !byte $7F,%10001001; + !byte $7F,%01101000 + !byte $77,%11101001 + !byte $9F,%10000111; + !byte $9F,%01100110 + !byte $9D,%11000101 + !byte $9B,%11100101 + !byte $87,%00001000 + !byte $35,%10100111 + !byte $21,%10000101; + !byte $21,%01100100 + !byte $23,%00100110 + !byte $29,%11001001 + !byte $29,%11101001 + !byte $2B,%01001010 + !byte $2B,%10001011; + !byte $2B,%01101010 + !byte $A1,%11100101 + !byte $93,%01000110 + !byte $91,%10000111; + !byte $91,%01100110 + !byte $8F,%10100111 + !byte $7D,%10101001 + !byte $7B,%11001001 + !byte $43,%10001001; + !byte $43,%01101000 + !byte $2F,%00100110 + !byte $2B,%11100101 + !byte $29,%11000101 + !byte $23,%00000110 + !byte $23,%01000110 + !byte $25,%11000111 + !byte $27,%01001000 + !byte $2D,%00001100 + !byte $2F,%10101101 + !byte $97,%01001010 + !byte $9B,%01001000 + !byte $A1,%00000110 + !byte $A3,%10000101; + !byte $A3,%01100100 + !byte $99,%00000110 + !byte $97,%00100110 + !byte $8D,%11000111 + !byte $85,%00101000 + !byte $83,%01001000 + !byte $81,%10001001; + !byte $81,%01101000 + !byte $79,%11101001 + !byte $77,%00001010 + !byte $99,%00100110 + !byte $89,%00001000 + !byte $33,%01000110 + !byte $2B,%11000101 + !byte $25,%00100110 + !byte $27,%00001000 + !byte $2B,%00001010 + !byte $2B,%00101010 + !byte $2F,%10001101; + !byte $2F,%01101100 + !byte $9D,%11100101 + !byte $9B,%00000110 + !byte $7F,%10101001 + !byte $7D,%11001001 + !byte $31,%00100110 + !byte $23,%11000101 + !byte $27,%11100111 + !byte $29,%10001001; + !byte $29,%01101000 + !byte $29,%10101001 + !byte $2D,%10101011 + !byte $2D,%11001011 + !byte $2D,%11101011 + !byte $2F,%01001100 + !byte $9F,%10100111 + !byte $A3,%10100101 + !byte $93,%10000111; + !byte $93,%01100110 + !byte $91,%10100111 + !byte $8F,%11000111 + !byte $87,%00101000 + !byte $85,%01001000 + !byte $83,%10001001; + !byte $83,%01101000 + !byte $7B,%11101001 + !byte $A1,%10000111; + !byte $A1,%01100110 + !byte $93,%10100111 + !byte $91,%11000111 + !byte $87,%01001000 + !byte $7D,%11101001 + !byte $33,%00100110 + !byte $25,%11100101 + !byte $27,%10100111 + !byte $29,%00001000 + !byte $29,%00101000 + !byte $31,%10101101 + !byte $9B,%00100110 + !byte $99,%01000110 + !byte $8F,%11100111 + !byte $8B,%00001000 + !byte $81,%10101001 + !byte $79,%00001010 + !byte $43,%01001000 + !byte $39,%10100111 + !byte $23,%00100100 + !byte $25,%11000101 + !byte $25,%00000110 + !byte $27,%10000111; + !byte $27,%01100110 + !byte $2B,%11001001 + !byte $2B,%11101001 + !byte $2D,%01001010 + !byte $2D,%10001011; + !byte $2D,%01101010 + !byte $2F,%00001100 + !byte $2F,%00101100 + !byte $9B,%11001001 + !byte $9D,%01001000 + !byte $89,%00101000 + !byte $7F,%11001001 + !byte $77,%00101010 + !byte $A5,%11000101 + !byte $29,%10000101; + !byte $29,%01100100 + !byte $27,%11100101 + !byte $29,%10100111 + !byte $29,%11000111 + !byte $2B,%01001000 + !byte $2F,%11001011 + !byte $2F,%11101011 + !byte $95,%10100111 + !byte $93,%11000111 + !byte $91,%11100111 + !byte $8D,%00001000 + !byte $89,%01001000 + !byte $83,%10101001 + !byte $25,%10000101; + !byte $25,%01100100 + !byte $2D,%00001010 + !byte $2D,%00101010 + !byte $31,%01001100 + !byte $31,%10001101; + !byte $31,%01101100 + !byte $99,%10001011; + !byte $99,%01101010 + !byte $A1,%10100111 + !byte $A3,%11100101 + !byte $9B,%01000110 + !byte $99,%10000111; + !byte $99,%01100110 + !byte $8B,%00101000 + !byte $81,%11001001 + !byte $7B,%00001010 + !byte $79,%00101010 + !byte $A1,%11100111 + !byte $A3,%00000110 + !byte $9D,%01000110 + !byte $9B,%10000111; + !byte $9B,%01100110 + !byte $99,%10100111 + !byte $35,%00100110 + !byte $31,%11100101 + !byte $2F,%11000101 + !byte $27,%10100101 + !byte $29,%01000110 + !byte $2B,%00101000 + !byte $8B,%01001000 + !byte $85,%10101001 + !byte $45,%01001000 + !byte $3D,%11000111 + !byte $3B,%10100111 + !byte $27,%10000101; + !byte $27,%01100100 + !byte $27,%11000101 + !byte $29,%00100110 + !byte $2B,%00001000 + !byte $2F,%01001010 + !byte $31,%00001100 + !byte $31,%00101100 + !byte $A1,%00100110 + !byte $95,%11000111 + !byte $93,%11100111 + !byte $8D,%00101000 + !byte $89,%10001001; + !byte $89,%01101000 + !byte $83,%11001001 + !byte $7F,%11101001 + !byte $7D,%00001010 + !byte $7B,%00101010 + !byte $A3,%00100110 + !byte $A1,%01000110 + !byte $95,%11100111 + !byte $93,%00001000 + !byte $8F,%00101000 + !byte $27,%00000100 + !byte $29,%10100101 + !byte $29,%11100101 + !byte $2B,%01000110 + !byte $2D,%01001000 + !byte $33,%10101101 + !byte $9D,%11101001 + !byte $A5,%00000110 + !byte $9D,%10000111; + !byte $9D,%01100110 + !byte $9B,%10100111 + !byte $8D,%01001000 + !byte $87,%10101001 + !byte $79,%01001010 + !byte $27,%00100100 + !byte $2B,%10100111 + !byte $2D,%00101000 + !byte $31,%10101011 + !byte $31,%11001011 + !byte $31,%11101011 + !byte $33,%10001101; + !byte $33,%01101100 + !byte $A1,%00001000 + !byte $8B,%10001001; + !byte $8B,%01101000 + !byte $85,%11001001 + !byte $81,%11101001 + !byte $7F,%00001010 + !byte $9D,%00001010 + !byte $A3,%11100111 + !byte $29,%00000100 + !byte $29,%01000100 + !byte $2D,%11000111 + !byte $2D,%11100111 + !byte $2F,%10001001; + !byte $2F,%01101000 + !byte $2F,%10101001 + !byte $2F,%11001001 + !byte $31,%00101010 + !byte $31,%01001010 + !byte $33,%01001100 + !byte $9F,%10101001 + !byte $A3,%01000110 + !byte $95,%00001000 + !byte $89,%10101001 + !byte $83,%11101001 + !byte $81,%00001010 + !byte $7D,%00101010 + !byte $3D,%10100111 + !byte $2D,%01000100 + !byte $29,%00100100 + !byte $2B,%00100110 + !byte $2D,%10100111 + !byte $31,%10001011; + !byte $31,%01101010 + !byte $33,%00001100 + !byte $33,%00101100 + !byte $A5,%10000111; + !byte $A5,%01100110 + !byte $A7,%00100110 + !byte $9D,%10100111 + !byte $8F,%01001000 + !byte $8D,%10001001; + !byte $8D,%01101000 + !byte $87,%11001001 + !byte $7B,%01001010 + !byte $79,%10001011; + !byte $79,%01101010 + !byte $39,%00100110 + !byte $35,%11100101 + !byte $33,%11000101 + !byte $2B,%01000100 + !byte $2B,%10100101 + !byte $2D,%00000110 + !byte $2D,%01000110 + !byte $2F,%11100111 + !byte $31,%11001001 + !byte $31,%11101001 + !byte $31,%00001010 + !byte $33,%11001011 + !byte $33,%11101011 + !byte $8B,%10101001 + !byte $85,%11101001 + !byte $7F,%00101010 + !byte $45,%00101000 + !byte $3F,%10100111 + !byte $2D,%00100110 + !byte $2F,%00101000 + !byte $A7,%01000110 + !byte $A5,%01000110 + !byte $A3,%10000111; + !byte $A3,%01100110 + !byte $9D,%11000111 + !byte $97,%00001000 + !byte $95,%00101000 + !byte $91,%01001000 + !byte $8F,%10001001; + !byte $8F,%01101000 + !byte $89,%11001001 + !byte $83,%00001010 + !byte $7D,%01001010 + !byte $A3,%01001000 + !byte $A5,%11100111 + !byte $A7,%10100111 + !byte $9D,%11100111 + !byte $8D,%10101001 + !byte $2D,%10100101 + !byte $2F,%10000111; + !byte $2F,%01100110 + !byte $35,%10001101; + !byte $35,%01101100 + !byte $95,%11001101 + !byte $87,%11101001 + !byte $4D,%11001001 + !byte $2F,%10100111 + !byte $2F,%11000111 + !byte $31,%01001000 + !byte $31,%10001001; + !byte $31,%01101000 + !byte $31,%10101001 + !byte $33,%00101010 + !byte $33,%01001010 + !byte $33,%10001011; + !byte $33,%01101010 + !byte $33,%10101011 + !byte $35,%00101100 + !byte $35,%01001100 + !byte $A3,%10100111 + !byte $99,%00001000 + !byte $97,%00101000 + !byte $93,%01001000 + !byte $91,%10001001; + !byte $91,%01101000 + !byte $8B,%11001001 + !byte $85,%00001010 + !byte $81,%00101010 + !byte $7F,%01001010 + !byte $7B,%10001011; + !byte $7B,%01101010 + !byte $9F,%00101010 + !byte $A7,%11000111 + !byte $A9,%10000111; + !byte $A9,%01100110 + !byte $A3,%11000111 + !byte $99,%00101000 + !byte $89,%11101001 + !byte $79,%10101011 + !byte $3B,%00100110 + !byte $2F,%00100100 + !byte $2D,%00000100 + !byte $2F,%00000110 + !byte $31,%11100111 + !byte $31,%00001000 + !byte $35,%00001100 + !byte $A1,%11001001 + !byte $9F,%11100111 + !byte $9D,%00001000 + !byte $93,%10001001; + !byte $93,%01101000 + !byte $91,%10101001 + !byte $31,%01000100 + !byte $2F,%11100101 + !byte $31,%11000111 + !byte $33,%11001001 + !byte $33,%11101001 + !byte $33,%00001010 + !byte $35,%11001011 + !byte $35,%11101011 + !byte $A3,%10001001; + !byte $A3,%01101000 + !byte $8D,%11001001 + !byte $87,%00001010 + !byte $83,%00101010 + !byte $81,%01001010 + !byte $7D,%10001011; + !byte $7D,%01101010 + !byte $A9,%10100111 + !byte $8B,%11101001 + !byte $41,%10100111 + !byte $37,%11000101 + !byte $31,%00100100 + !byte $2F,%00000100 + !byte $2F,%01000100 + !byte $31,%00000110 + !byte $31,%10000111; + !byte $31,%01100110 + !byte $35,%10001011; + !byte $35,%01101010 + !byte $35,%10101011 + !byte $A7,%00001000 + !byte $A5,%11000111 + !byte $99,%01001000 + !byte $95,%10001001; + !byte $95,%01101000 + !byte $93,%10101001 + !byte $83,%01001010 + !byte $31,%01000110 + !byte $33,%10001001; + !byte $33,%01101000 + !byte $35,%00101010 + !byte $35,%01001010 + !byte $37,%01001100 + !byte $37,%10001101; + !byte $37,%01101100 + !byte $A7,%11100111 + !byte $9F,%00001000 + !byte $9D,%00101000 + !byte $8F,%11001001 + !byte $89,%00001010 + !byte $85,%00101010 + !byte $7F,%10001011; + !byte $7F,%01101010 + !byte $7B,%10101011 + !byte $A7,%00101000 + !byte $8F,%11101001 + !byte $85,%01001010 + !byte $47,%00001000 + !byte $33,%10000111; + !byte $33,%01100110 + !byte $37,%11101011 + !byte $A3,%00001000 + !byte $87,%00101010 + !byte $33,%11000111 + !byte $33,%11100111 + !byte $35,%10101001 + !byte $35,%11001001 + !byte $35,%11101001 + !byte $35,%00001010 + !byte $37,%11001011 + !byte $37,%00001100 + !byte $37,%00101100 + !byte $9F,%00101000 + !byte $99,%10001001; + !byte $99,%01101000 + !byte $95,%10101001 + !byte $91,%11001001 + !byte $8B,%00001010 + !byte $81,%10001011; + !byte $81,%01101010 + !byte $7D,%10101011 + !byte $9F,%01001000 + !byte $95,%11001001 + !byte $8B,%00101010 + !byte $89,%00101010 + !byte $3F,%00100110 + !byte $31,%00000100 + !byte $33,%00000110 + !byte $35,%00001000 + !byte $35,%00101000 + !byte $37,%01001010 + !byte $37,%10001011; + !byte $37,%01101010 + !byte $9F,%10101011 + !byte $A9,%11100111 + !byte $7B,%11001011 + !byte $4D,%10001001; + !byte $4D,%01101000 + !byte $47,%11100111 + !byte $33,%11100101 + !byte $35,%11100111 + !byte $37,%10101011 + !byte $A1,%01001010 + !byte $A5,%10101001 + !byte $A5,%00001000 + !byte $9B,%10001001; + !byte $9B,%01101000 + !byte $97,%10101001 + !byte $91,%11101001 + !byte $8D,%00001010 + !byte $87,%01001010 + !byte $83,%10001011; + !byte $83,%01101010 + !byte $7F,%10101011 + !byte $9D,%10001001; + !byte $9D,%01101000 + !byte $9B,%10101001 + !byte $3B,%11000101 + !byte $39,%10100101 + !byte $35,%00100100 + !byte $33,%00000100 + !byte $33,%01000100 + !byte $35,%10000111; + !byte $35,%01100110 + !byte $A5,%11001001 + !byte $A9,%00001000 + !byte $A1,%01001000 + !byte $9F,%10001001; + !byte $9F,%01101000 + !byte $93,%11101001 + !byte $8F,%00001010 + !byte $81,%10101011 + !byte $49,%00001000 + !byte $43,%10000111; + !byte $43,%01100110 + !byte $35,%01000110 + !byte $35,%11000111 + !byte $37,%11001001 + !byte $37,%11101001 + !byte $39,%00001100 + !byte $39,%00101100 + !byte $39,%01001100 + !byte $39,%10001101; + !byte $39,%01101100 + !byte $A5,%00101000 + !byte $97,%11001001 + !byte $8D,%00101010 + !byte $89,%01001010 + !byte $85,%10001011; + !byte $85,%01101010 + !byte $7D,%11001011 + !byte $7B,%11101011 + !byte $A9,%01001000 + !byte $A5,%01001000 + !byte $99,%11001001 + !byte $95,%11101001 + !byte $35,%01000100 + !byte $37,%00001000 + !byte $37,%00101000 + !byte $37,%01001000 + !byte $39,%00101010 + !byte $39,%01001010 + !byte $39,%11001011 + !byte $39,%11101011 + !byte $9D,%10101001 + !byte $97,%11101001 + !byte $93,%00001010 + !byte $7F,%11001011 + !byte $4D,%01001000 + !byte $45,%10100111 + !byte $35,%10100101 + !byte $37,%11000111 + !byte $37,%11100111 + !byte $39,%10001011; + !byte $39,%01101010 + !byte $39,%10101011 + !byte $A3,%00101010 + !byte $A9,%00101000 + !byte $A1,%10001001; + !byte $A1,%01101000 + !byte $8F,%00101010 + !byte $8B,%01001010 + !byte $87,%10001011; + !byte $87,%01101010 + !byte $83,%10101011 + !byte $7D,%11101011 + !byte $A1,%11001011 + !byte $AB,%00101000 + !byte $89,%10001011; + !byte $89,%01101010 + !byte $49,%11100111 + !byte $37,%00000110 + !byte $37,%10000111; + !byte $37,%01100110 + !byte $39,%01001000 + !byte $39,%00001010 + !byte $A9,%10101001 + !byte $A7,%01001000 + !byte $A5,%10001001; + !byte $A5,%01101000 + !byte $9D,%11001001 + !byte $99,%11101001 + !byte $8D,%01001010 + !byte $85,%10101011 + !byte $83,%11001011 + !byte $45,%10000111; + !byte $45,%01100110 + !byte $37,%11100101 + !byte $37,%01000110 + !byte $3B,%01001100 + !byte $3B,%10001101; + !byte $3B,%01101100 + !byte $A9,%10001001; + !byte $A9,%01101000 + !byte $A1,%10101001 + !byte $95,%00001010 + !byte $91,%00101010 + !byte $81,%11001011 + !byte $7F,%11101011 + !byte $7B,%00001100 + !byte $A3,%10101001 + !byte $91,%01001010 + !byte $8F,%01001010 + !byte $3F,%11000101 + !byte $37,%00000100 + !byte $39,%10000111; + !byte $39,%01100110 + !byte $39,%00001000 + !byte $39,%00101000 + !byte $3B,%10101011 + !byte $3B,%00001100 + !byte $A5,%01001010 + !byte $9B,%11101001 + !byte $97,%00001010 + !byte $4D,%00101000 + !byte $3B,%01000100 + !byte $39,%00100100 + !byte $39,%01000110 + !byte $39,%11000111 + !byte $39,%11100111 + !byte $3B,%01001010 + !byte $3B,%10001011; + !byte $3B,%01101010 + !byte $3B,%11001011 + !byte $3B,%11101011 + !byte $3B,%00101100 + !byte $A7,%00001010 + !byte $A7,%10001001; + !byte $A7,%01101000 + !byte $9F,%11001001 + !byte $99,%00001010 + !byte $95,%00101010 + !byte $93,%00101010 + !byte $8D,%10001011; + !byte $8D,%01101010 + !byte $8B,%10001011; + !byte $8B,%01101010 + !byte $89,%10101011 + !byte $87,%10101011 + !byte $85,%11001011 + !byte $81,%11101011 + !byte $7D,%00001100 + !byte $A3,%10101011 + !byte $93,%01001010 + !byte $39,%00000100 + !byte $39,%01000100 + !byte $3B,%00101000 + !byte $3B,%01001000 + !byte $3B,%10001001; + !byte $3B,%01101000 + !byte $3B,%10101001 + !byte $3B,%11001001 + !byte $3B,%11101001 + !byte $3B,%00001010 + !byte $3B,%00101010 + !byte $9B,%11001101 + !byte $AB,%10001001; + !byte $AB,%01101000 + !byte $A3,%11001001 + !byte $8B,%10101011 + !byte $15,%11010011 + !byte $43,%00000110 + !byte $39,%11100101 + !byte $99,%00001110 + !byte $A7,%10101001 + !byte $9F,%11101001 + !byte $9B,%00001010 + !byte $97,%00101010 + !byte $8F,%10001011; + !byte $8F,%01101010 + !byte $87,%11001011 + !byte $83,%11101011 + !byte $7F,%00001100 + !byte $7B,%00101100 + !byte $11,%11110011 + !byte $AB,%11001001 + !byte $A1,%11101001 + !byte $9F,%00001010 + !byte $9B,%00101010 + !byte $95,%01001010 + !byte $3B,%00000110 + !byte $3B,%10000111; + !byte $3B,%01100110 + !byte $3D,%10101011 + !byte $3D,%00101100 + !byte $AB,%10101001 + !byte $A3,%11101001 + !byte $8D,%10101011 + !byte $3B,%00100100 + !byte $3B,%11100101 + !byte $3B,%01000110 + !byte $3B,%11000111 + !byte $3B,%11100111 + !byte $3D,%11001011 + !byte $3D,%11101011 + !byte $3D,%00001100 + !byte $3D,%01001100 + !byte $3D,%10001101; + !byte $3D,%01101100 + !byte $A7,%11001001 + !byte $99,%00101010 + !byte $91,%10001011; + !byte $91,%01101010 + !byte $89,%11001011 + !byte $85,%11101011 + !byte $81,%00001100 + !byte $7D,%00101100 + !byte $A7,%11101001 + !byte $9D,%00101010 + !byte $99,%01001010 + !byte $47,%01000110 + !byte $3F,%10000101; + !byte $3F,%01100100 + !byte $3B,%00000100 + !byte $3D,%00101000 + !byte $3D,%01001000 + !byte $3D,%10001001; + !byte $3D,%01101000 + !byte $3D,%10101001 + !byte $3D,%11001001 + !byte $3D,%11101001 + !byte $3D,%00001010 + !byte $A1,%00001010 + !byte $95,%10001011; + !byte $95,%01101010 + !byte $3D,%11100111 + !byte $3D,%00001000 + !byte $3D,%00101010 + !byte $3D,%01001010 + !byte $3D,%10001011; + !byte $3D,%01101010 + !byte $A1,%00101100 + !byte $A9,%00101010 + !byte $A5,%11101001 + !byte $91,%10101011 + !byte $8F,%10101011 + !byte $8B,%11001011 + !byte $87,%11101011 + !byte $83,%00001100 + !byte $7F,%00101100 + !byte $9B,%01001010 + !byte $4B,%10100111 + !byte $3D,%01000100 + !byte $3D,%10100101 + !byte $3D,%00000110 + !byte $3D,%10000111; + !byte $3D,%01100110 + !byte $A3,%00001100 + !byte $A9,%01001010 + !byte $A9,%11101001 + !byte $A1,%00101010 + !byte $9D,%01001010 + !byte $97,%10001011; + !byte $97,%01101010 + !byte $8F,%11001011 + !byte $8D,%11001011 + !byte $8B,%11101011 + !byte $0B,%11110011 + !byte $53,%10001001; + !byte $53,%01101000 + !byte $4F,%00001000 + !byte $43,%11000101 + !byte $3D,%00100100 + !byte $3D,%10000101; + !byte $3D,%01100100 + !byte $3D,%11100101 + !byte $3D,%01000110 + !byte $3F,%01001100 + !byte $3F,%10001101; + !byte $3F,%01101100 + !byte $AB,%00001010 + !byte $AB,%11101001 + !byte $A5,%00001010 + !byte $93,%10101011 + !byte $89,%11101011 + !byte $85,%00001100 + !byte $81,%00101100 + !byte $7D,%01001100 + !byte $AD,%11101001 + !byte $A5,%00101010 + !byte $3F,%00000110 + !byte $3F,%10000111; + !byte $3F,%01100110 + !byte $3F,%00001000 + !byte $3F,%00101000 + !byte $3F,%01001000 + !byte $3F,%10001001; + !byte $3F,%01101000 + !byte $3F,%10101001 + !byte $3F,%11001001 + !byte $3F,%11101001 + !byte $3F,%00001010 + !byte $3F,%10001011; + !byte $3F,%01101010 + !byte $3F,%11101011 + !byte $A7,%10101011 + !byte $A9,%00001010 + !byte $9F,%01001010 + !byte $9B,%10001011; + !byte $9B,%01101010 + !byte $95,%10101011 + !byte $91,%11001011 + !byte $43,%10100101 + !byte $3F,%00100100 + !byte $3F,%11100101 + !byte $3F,%01000110 + !byte $3F,%11000111 + !byte $3F,%11100111 + !byte $3F,%00101010 + !byte $3F,%01001010 + !byte $3F,%10101011 + !byte $3F,%11001011 + !byte $3F,%00001100 + !byte $3F,%00101100 + !byte $9D,%11101101 + !byte $97,%10101011 + !byte $8D,%11101011 + !byte $87,%00001100 + !byte $83,%00101100 + !byte $7F,%01001100 + !byte $0D,%11010011 + !byte $9B,%00101110 + !byte $AD,%00001010 + !byte $49,%00100110 + !byte $41,%01000100 + !byte $9D,%10001011; + !byte $9D,%01101010 + !byte $53,%01001000 + !byte $43,%10000101; + !byte $43,%01100100 + !byte $A1,%10001101; + !byte $A1,%01101100 + !byte $A9,%10001011; + !byte $A9,%01101010 + !byte $A3,%01001010 + !byte $9F,%10001011; + !byte $9F,%01101010 + !byte $9B,%10101011 + !byte $99,%10101011 + !byte $95,%11001011 + !byte $93,%11001011 + !byte $8F,%11101011 + !byte $8B,%00001100 + !byte $89,%00001100 + !byte $85,%00101100 + !byte $81,%01001100 + !byte $07,%11110011 + !byte $A3,%10001011; + !byte $A3,%01101010 + !byte $8F,%00001100 + !byte $17,%01010010 + !byte $09,%11010011 + !byte $49,%00000110 + !byte $43,%01000100 + !byte $41,%10100101 + !byte $41,%11100101 + !byte $41,%01000110 + !byte $41,%10000111; + !byte $41,%01100110 + !byte $41,%00001000 + !byte $41,%00101000 + !byte $41,%01001000 + !byte $41,%10001001; + !byte $41,%01101000 + !byte $41,%10101001 + !byte $41,%11001001 + !byte $41,%11101001 + !byte $41,%00001010 + !byte $41,%10001011; + !byte $41,%01101010 + !byte $A3,%01001100 + !byte $A7,%01001010 + !byte $93,%11101011 + !byte $8D,%00001100 + !byte $7D,%10001101; + !byte $7D,%01101100 + !byte $13,%10010011; + !byte $13,%01110010 + !byte $03,%11110011 + !byte $41,%10000101; + !byte $41,%01100100 + !byte $41,%11000101 + !byte $41,%00100110 + !byte $41,%11000111 + !byte $41,%11100111 + !byte $41,%00101010 + !byte $41,%01001010 + !byte $41,%10101011 + !byte $41,%11001011 + !byte $41,%11101011 + !byte $41,%00001100 + !byte $41,%00101100 + !byte $41,%01001100 + !byte $41,%10001101; + !byte $41,%01101100 + !byte $41,%10101101 + !byte $AD,%00101010 + !byte $AB,%00101010 + !byte $A1,%10001011; + !byte $A1,%01101010 + !byte $9D,%10101011 + !byte $99,%11001011 + !byte $97,%11001011 + !byte $89,%00101100 + !byte $87,%00101100 + !byte $83,%01001100 + !byte $AB,%01001010 + !byte $A5,%10001011; + !byte $A5,%01101010 + !byte $9D,%11001011 + !byte $95,%11101011 + !byte $7F,%10001101; + !byte $7F,%01101100 + !byte $AB,%10101011 + !byte $A7,%10001011; + !byte $A7,%01101010 + !byte $4F,%10100111 + !byte $4D,%10000111; + !byte $4D,%01100110 + !byte $4B,%00100110 + !byte $A7,%00001100 + !byte $AD,%01001010 + !byte $A1,%10101011 + !byte $9B,%11001011 + !byte $97,%11101011 + !byte $91,%00001100 + !byte $8B,%00101100 + !byte $87,%01001100 + !byte $85,%01001100 + !byte $81,%10001101; + !byte $81,%01101100 + !byte $AB,%10001011; + !byte $AB,%01101010 + !byte $9B,%11101011 + !byte $03,%11010011 + !byte $01,%11110011 + !byte $43,%11100101 + !byte $43,%01000110 + !byte $43,%11100111 + !byte $43,%00001000 + !byte $43,%00101000 + !byte $43,%11001001 + !byte $43,%11101001 + !byte $43,%00001010 + !byte $43,%10001011; + !byte $43,%01101010 + !byte $A9,%11101011 + !byte $A5,%10101011 + !byte $95,%00001100 + !byte $93,%00001100 + !byte $8F,%00101100 + !byte $8D,%00101100 + !byte $49,%11100101 + !byte $43,%00100110 + !byte $43,%10100111 + !byte $43,%11000111 + !byte $43,%00101010 + !byte $43,%01001010 + !byte $43,%10101011 + !byte $A1,%11001101 + !byte $AD,%10001011; + !byte $AD,%01101010 + !byte $9F,%11001011 + !byte $99,%11101011 + !byte $89,%01001100 + !byte $83,%10001101; + !byte $83,%01101100 + !byte $7D,%10101101 + !byte $09,%10110011 + !byte $9F,%11101011 + !byte $99,%00001100 + !byte $0B,%10010011; + !byte $0B,%01110010 + !byte $05,%11110011 + !byte $51,%11000111 + !byte $45,%00100100 + !byte $45,%10000101; + !byte $45,%01100100 + !byte $45,%11100101 + !byte $45,%01000110 + !byte $43,%00001100 + !byte $A5,%11001011 + !byte $A3,%11001011 + !byte $97,%00001100 + !byte $1D,%00010010 + !byte $05,%10110011 + !byte $45,%01000100 + !byte $45,%11000101 + !byte $45,%00000110 + !byte $45,%00100110 + !byte $43,%11001011 + !byte $43,%11101011 + !byte $43,%00101100 + !byte $43,%01001100 + !byte $43,%10001101; + !byte $43,%01101100 + !byte $43,%10101101 + !byte $A9,%10101011 + !byte $9D,%11101011 + !byte $93,%00101100 + !byte $91,%00101100 + !byte $8D,%01001100 + !byte $8B,%01001100 + !byte $87,%10001101; + !byte $87,%01101100 + !byte $85,%10001101; + !byte $85,%01101100 + !byte $81,%10101101 + !byte $7F,%10101101 + !byte $01,%11010011 + !byte $9D,%00001100 + !byte $9B,%00001100 + !byte $45,%11000111 + !byte $45,%11100111 + !byte $45,%00001000 + !byte $45,%11101001 + !byte $45,%00001010 + !byte $AD,%10101011 + !byte $A3,%11101011 + !byte $A1,%11101011 + !byte $97,%00101100 + !byte $91,%01001100 + !byte $89,%10001101; + !byte $89,%01101100 + !byte $0D,%01010010 + !byte $01,%10110011 + !byte $57,%10001001; + !byte $57,%01101000 + !byte $47,%01000100 + !byte $45,%10001001; + !byte $45,%01101000 + !byte $45,%10101001 + !byte $9B,%10101111 + !byte $A9,%11001011 + !byte $A7,%11001011 + !byte $95,%00101100 + !byte $8F,%01001100 + !byte $83,%10101101 + !byte $7D,%11001101 + !byte $05,%11010011 + !byte $09,%11110011 + !byte $05,%10010011; + !byte $05,%01110010 + !byte $03,%10110011 + !byte $0D,%11110011 + !byte $5D,%00101010 + !byte $57,%01001000 + !byte $4D,%00000110 + !byte $49,%10000101; + !byte $49,%01100100 + !byte $47,%11000101 + !byte $47,%00100110 + !byte $47,%11000111 + !byte $45,%10001011; + !byte $45,%01101010 + !byte $45,%00001100 + !byte $AD,%11001011 + !byte $A5,%11101011 + !byte $A1,%00001100 + !byte $9F,%00001100 + !byte $9B,%00101100 + !byte $99,%00101100 + !byte $8D,%10001101; + !byte $8D,%01101100 + !byte $8B,%10001101; + !byte $8B,%01101100 + !byte $87,%10101101 + !byte $07,%11010011 + !byte $4F,%01000110 + !byte $47,%10100101 + !byte $47,%00000110 + !byte $47,%10000111; + !byte $47,%01100110 + !byte $47,%10100111 + !byte $45,%00101010 + !byte $45,%01001010 + !byte $45,%10101011 + !byte $45,%11001011 + !byte $45,%11101011 + !byte $A1,%00001110 + !byte $A5,%10101101 + !byte $A7,%10001101; + !byte $A7,%01101100 + !byte $A9,%01001100 + !byte $A7,%11101011 + !byte $95,%01001100 + !byte $93,%01001100 + !byte $85,%10101101 + !byte $7F,%11001101 + !byte $9F,%01001110 + !byte $AB,%11101011 + !byte $49,%11000101 + !byte $45,%00101100 + !byte $AB,%00101100 + !byte $AD,%11101011 + !byte $A5,%00001100 + !byte $9F,%00101100 + !byte $9D,%00101100 + !byte $99,%01001100 + !byte $91,%10001101; + !byte $91,%01101100 + !byte $81,%11001101 + !byte $07,%01010010 + !byte $07,%10110011 + !byte $55,%11100111 + !byte $53,%10100111 + !byte $49,%10100101 + !byte $47,%00101000 + !byte $47,%01001000 + !byte $47,%10001001; + !byte $47,%01101000 + !byte $47,%10101001 + !byte $47,%11001001 + !byte $47,%11101001 + !byte $45,%01001100 + !byte $45,%10001101; + !byte $45,%01101100 + !byte $45,%10101101 + !byte $97,%01001100 + !byte $8F,%10001101; + !byte $8F,%01101100 + !byte $8B,%10101101 + !byte $89,%10101101 + !byte $83,%11001101 + !byte $03,%10010011; + !byte $03,%01110010 + !byte $0B,%11010011 + !byte $0F,%11110011 + !byte $A9,%00001100 + !byte $93,%10001101; + !byte $93,%01101100 + !byte $8F,%10101101 + !byte $49,%10100111 + !byte $49,%11000111 + !byte $47,%00001010 + !byte $47,%00101010 + !byte $A5,%11101101 + !byte $AB,%00001100 + !byte $A3,%00101100 + !byte $9D,%01001100 + !byte $9B,%01001100 + !byte $03,%01010010 + !byte $0B,%10110011 + !byte $0F,%11010011 + !byte $13,%11110011 + !byte $4F,%00000110 + !byte $4D,%10100101 + !byte $49,%01000110 + !byte $49,%10000111; + !byte $49,%01100110 + !byte $47,%01001010 + !byte $47,%10001011; + !byte $47,%01101010 + !byte $47,%10101011 + !byte $47,%11001011 + !byte $A5,%00101100 + !byte $95,%10001101; + !byte $95,%01101100 + !byte $8D,%10101101 + !byte $87,%11001101 + !byte $85,%11001101 + !byte $7F,%11101101 + !byte $7D,%11101101 + !byte $13,%00010010 + !byte $07,%10010011; + !byte $07,%01110010 + !byte $A9,%00101100 + !byte $07,%00110010 + !byte $4B,%10100101 + !byte $4B,%00000110 + !byte $47,%00001100 + !byte $A1,%01001100 + !byte $9F,%01001100 + !byte $9B,%10001101; + !byte $9B,%01101100 + !byte $97,%10001101; + !byte $97,%01101100 + !byte $93,%10101101 + !byte $8B,%11001101 + !byte $09,%10010011; + !byte $09,%01110010 + !byte $0D,%10110011 + !byte $11,%11010011 + !byte $15,%11110011 + !byte $5D,%11101001 + !byte $4F,%11100101 + !byte $4B,%10000101; + !byte $4B,%01100100 + !byte $4B,%11100101 + !byte $49,%00101000 + !byte $49,%01001000 + !byte $49,%10001001; + !byte $49,%01101000 + !byte $49,%10101001 + !byte $49,%11001001 + !byte $47,%11101011 + !byte $47,%00101100 + !byte $47,%01001100 + !byte $A1,%01001110 + !byte $A7,%00101100 + !byte $99,%10001101; + !byte $99,%01101100 + !byte $91,%10101101 + !byte $89,%11001101 + !byte $83,%11101101 + !byte $81,%11101101 + !byte $05,%01010010 + !byte $09,%01010010 + !byte $0F,%10110011 + !byte $53,%01000110 + !byte $4B,%10000111; + !byte $4B,%01100110 + !byte $49,%00101010 + !byte $AD,%00101100 + !byte $9F,%10001101; + !byte $9F,%01101100 + !byte $9D,%10001101; + !byte $9D,%01101100 + !byte $8F,%11001101 + !byte $17,%11110011 + !byte $4D,%10000101; + !byte $4D,%01100100 + !byte $4B,%01000110 + !byte $4B,%11000111 + !byte $4B,%11100111 + !byte $4B,%00001000 + !byte $49,%11101001 + !byte $49,%00001010 + !byte $49,%01001010 + !byte $49,%10001011; + !byte $49,%01101010 + !byte $47,%10001101; + !byte $47,%01101100 + !byte $47,%10101101 + !byte $A9,%11001101 + !byte $A7,%01001100 + !byte $A5,%01001100 + !byte $97,%10101101 + !byte $95,%10101101 + !byte $8D,%11001101 + !byte $87,%11101101 + !byte $85,%11101101 + !byte $7D,%00001110 + !byte $05,%00110010 + !byte $0D,%10010011; + !byte $0D,%01110010 + !byte $11,%10110011 + !byte $13,%11010011 + !byte $09,%00010010 + !byte $19,%11110011 + !byte $1B,%11110011 + !byte $53,%00100110 + !byte $4F,%10100101 + !byte $4D,%11100101 + !byte $4D,%01000110 + !byte $4B,%00101000 + !byte $4B,%01001000 + !byte $4B,%10001001; + !byte $4B,%01101000 + !byte $4B,%10101001 + !byte $49,%10101011 + !byte $A5,%00101110 + !byte $AB,%10101101 + !byte $AD,%01001100 + !byte $AB,%01001100 + !byte $A3,%10001101; + !byte $A3,%01101100 + !byte $9D,%10101101 + !byte $99,%10101101 + !byte $93,%11001101 + !byte $05,%00010010 + !byte $55,%10000111; + !byte $55,%01100110 + !byte $4D,%00100110 + !byte $4B,%11001001 + !byte $49,%11001011 + !byte $49,%11101011 + !byte $A5,%10001101; + !byte $A5,%01101100 + !byte $9B,%10101101 + !byte $91,%11001101 + !byte $8B,%11101101 + !byte $89,%11101101 + !byte $81,%00001110 + !byte $7F,%00001110 + !byte $09,%00110010 + !byte $0B,%01010010 + !byte $0F,%10010011; + !byte $0F,%01110010 + !byte $13,%10110011 + !byte $17,%11010011 + !byte $A9,%10001101; + !byte $A9,%01101100 + !byte $0F,%01010010 + !byte $4F,%10000101; + !byte $4F,%01100100 + !byte $4D,%11100111 + !byte $4D,%00001000 + !byte $AB,%10001101; + !byte $AB,%01101100 + !byte $A1,%10101101 + !byte $9F,%10101101 + !byte $0B,%11110001 + !byte $0B,%00110010 + !byte $11,%10010011; + !byte $11,%01110010 + !byte $15,%10110011 + !byte $4F,%11000101 + !byte $4D,%10100111 + !byte $4D,%11000111 + !byte $4B,%11101001 + !byte $4B,%00001010 + !byte $4B,%00101010 + !byte $49,%00001100 + !byte $49,%00101100 + !byte $49,%01001100 + !byte $A3,%10101101 + !byte $99,%11001101 + !byte $97,%11001101 + !byte $8F,%11101101 + !byte $8D,%11101101 + !byte $85,%00001110 + !byte $83,%00001110 + !byte $0D,%11110001 + !byte $07,%00010010 + !byte $19,%11010011 + !byte $A9,%10101101 + !byte $0B,%00010010 + !byte $0D,%00110010 + !byte $5B,%01001000 + !byte $57,%10100111 + !byte $4F,%00100110 + !byte $4D,%10101001 + !byte $4B,%01001010 + !byte $9F,%11001101 + !byte $9D,%11001101 + !byte $95,%11101101 + !byte $87,%00001110 + !byte $1B,%10110001 + !byte $07,%11110001 + !byte $17,%10110011 + !byte $1D,%11110011 + !byte $1F,%11110011 + !byte $55,%00100110 + !byte $4F,%10000111; + !byte $4F,%01100110 + !byte $4B,%10001011; + !byte $4B,%01101010 + !byte $4B,%10101011 + !byte $49,%10001101; + !byte $49,%01101100 + !byte $49,%10101101 + !byte $9B,%00110000 + !byte $A7,%00101110 + !byte $A7,%10101101 + !byte $93,%11101101 + !byte $91,%11101101 + !byte $8B,%00001110 + !byte $89,%00001110 + !byte $7F,%00101110 + !byte $7D,%00101110 + !byte $11,%01010010 + !byte $15,%10010011; + !byte $15,%01110010 + !byte $1B,%11010011 + !byte $81,%00101110 + !byte $0B,%11010001 + !byte $09,%11110001 + !byte $19,%10110011 + !byte $53,%11000101 + !byte $51,%11000101 + !byte $4F,%11000111 + !byte $4F,%11100111 + !byte $4D,%11101001 + !byte $AD,%10101101 + !byte $0D,%11010001 + !byte $11,%00110010 + !byte $21,%11110011 + !byte $55,%00000110 + !byte $51,%10100101 + !byte $51,%00000110 + !byte $4F,%00101000 + !byte $4D,%00001010 + !byte $4B,%11001011 + !byte $4B,%11101011 + !byte $4B,%00001100 + !byte $49,%11001101 + !byte $A7,%11001101 + !byte $A5,%11001101 + !byte $A3,%11001101 + !byte $9B,%11101101 + !byte $99,%11101101 + !byte $97,%11101101 + !byte $91,%00001110 + !byte $8F,%00001110 + !byte $8D,%00001110 + !byte $85,%00101110 + !byte $83,%00101110 + !byte $19,%10110001 + !byte $0D,%00010010 + !byte $0F,%00110010 + !byte $13,%01010010 + !byte $17,%10010011; + !byte $17,%01110010 + !byte $1D,%11010011 + !byte $A5,%10001111; + !byte $A5,%01101110 + !byte $AB,%11001101 + !byte $13,%10110001 + !byte $13,%00110010 + !byte $1B,%10110011 + !byte $53,%10100101 + !byte $51,%10100111 + !byte $4D,%10001011; + !byte $4D,%01101010 + !byte $AD,%11001101 + !byte $A3,%11101101 + !byte $A1,%11101101 + !byte $9F,%11101101 + !byte $95,%00001110 + !byte $0F,%00010010 + !byte $15,%01010010 + !byte $51,%01000110 + !byte $51,%10000111; + !byte $51,%01100110 + !byte $4F,%01001000 + !byte $4F,%10001001; + !byte $4F,%01101000 + !byte $4F,%10101001 + !byte $4D,%00101010 + !byte $4D,%01001010 + !byte $4B,%00101100 + !byte $4B,%01001100 + !byte $97,%00001110 + !byte $93,%00001110 + !byte $8B,%00101110 + !byte $89,%00101110 + !byte $87,%00101110 + !byte $7D,%01001110 + !byte $11,%10110001 + !byte $0F,%10110001 + !byte $09,%11010001 + !byte $19,%10010011; + !byte $19,%01110010 + !byte $1F,%11010011 + !byte $AB,%11101101 + !byte $11,%00010010 + !byte $1D,%10110011 + !byte $57,%00100110 + !byte $53,%00000110 + !byte $4F,%00001010 + !byte $4D,%11001011 + !byte $AD,%11101101 + !byte $9F,%00001110 + !byte $9D,%00001110 + !byte $8D,%00101110 + !byte $09,%10110001 + !byte $59,%10000111; + !byte $59,%01100110 + !byte $53,%11100101 + !byte $51,%11100111 + !byte $51,%00001000 + !byte $51,%00101000 + !byte $4F,%11001001 + !byte $4F,%11101001 + !byte $4D,%10101011 + !byte $4D,%11101011 + !byte $4B,%10001101; + !byte $4B,%01101100 + !byte $4B,%10101101 + !byte $A9,%11101101 + !byte $A7,%11101101 + !byte $9B,%00001110 + !byte $91,%00101110 + !byte $8F,%00101110 + !byte $83,%01001110 + !byte $81,%01001110 + !byte $7F,%01001110 + !byte $0F,%11110001 + !byte $15,%00110010 + !byte $1B,%10010011; + !byte $1B,%01110010 + !byte $21,%11010011 + !byte $23,%11110011 + !byte $A3,%11001111 + !byte $19,%01010010 + !byte $1F,%10110011 + !byte $25,%11110011 + !byte $5B,%11000111 + !byte $55,%11100101 + !byte $53,%10000111; + !byte $53,%01100110 + !byte $51,%01001000 + !byte $51,%10001001; + !byte $51,%01101000 + !byte $4F,%00101010 + !byte $A7,%10001111; + !byte $A7,%01101110 + !byte $AD,%00001110 + !byte $A3,%00001110 + !byte $95,%00101110 + !byte $93,%00101110 + !byte $0F,%11010001 + !byte $11,%11110001 + !byte $15,%00010010 + !byte $55,%11000101 + !byte $53,%11000111 + !byte $4F,%01001010 + !byte $4D,%00001100 + !byte $4B,%11001101 + !byte $A9,%00001110 + !byte $A7,%00001110 + !byte $A5,%00001110 + !byte $99,%00101110 + !byte $97,%00101110 + !byte $8B,%01001110 + !byte $89,%01001110 + !byte $87,%01001110 + !byte $85,%01001110 + !byte $15,%10010001; + !byte $15,%01110000 + !byte $0B,%10110001 + !byte $17,%00110010 + !byte $1D,%10010011; + !byte $1D,%01110010 + !byte $23,%11010011 + !byte $A5,%11001111 + !byte $11,%11010001 + !byte $13,%11110001 + !byte $17,%00010010 + !byte $1B,%01010010 + !byte $57,%11100101 + !byte $55,%01000110 + !byte $53,%11100111 + !byte $53,%00001000 + !byte $53,%00101000 + !byte $51,%10101001 + !byte $51,%11001001 + !byte $4F,%10101011 + !byte $A3,%00101110 + !byte $A1,%00101110 + !byte $9F,%00101110 + !byte $9D,%00101110 + !byte $91,%01001110 + !byte $0B,%10010001; + !byte $0B,%01110000 + !byte $0D,%10110001 + !byte $21,%10110011 + !byte $25,%11010011 + !byte $5F,%01001000 + !byte $5D,%00001000 + !byte $51,%11101001 + !byte $4F,%10001011; + !byte $4F,%01101010 + !byte $4D,%00101100 + !byte $4D,%01001100 + !byte $93,%01001110 + !byte $8F,%01001110 + !byte $8D,%01001110 + !byte $81,%10001111; + !byte $81,%01101110 + !byte $7F,%10001111; + !byte $7F,%01101110 + !byte $7D,%10001111; + !byte $7D,%01101110 + !byte $19,%00110010 + !byte $1F,%10010011; + !byte $1F,%01110010 + !byte $27,%11110011 + !byte $AB,%00101110 + !byte $19,%00010010 + !byte $1D,%01010010 + !byte $59,%00100110 + !byte $57,%11000101 + !byte $55,%11000111 + !byte $9D,%01001110 + !byte $95,%01001110 + !byte $1B,%00110010 + !byte $23,%10110011 + !byte $57,%00000110 + !byte $55,%10100111 + !byte $51,%00001010 + !byte $51,%00101010 + !byte $4F,%11001011 + !byte $4F,%11101011 + !byte $4D,%10001101; + !byte $4D,%01101100 + !byte $4D,%10101101 + !byte $A9,%10001111; + !byte $A9,%01101110 + !byte $AD,%00101110 + !byte $A9,%00101110 + !byte $9B,%01001110 + !byte $99,%01001110 + !byte $97,%01001110 + !byte $89,%10001111; + !byte $89,%01101110 + !byte $87,%10001111; + !byte $87,%01101110 + !byte $85,%10001111; + !byte $85,%01101110 + !byte $83,%10001111; + !byte $83,%01101110 + !byte $0D,%10010001; + !byte $0D,%01110000 + !byte $13,%11010001 + !byte $15,%11110001 + !byte $21,%10010011; + !byte $21,%01110010 + !byte $29,%11110011 + !byte $5F,%00101000 + !byte $53,%11101001 + !byte $A3,%00010000 + !byte $A5,%01001110 + !byte $A3,%01001110 + !byte $95,%10001111; + !byte $95,%01101110 + !byte $91,%10001111; + !byte $91,%01101110 + !byte $8B,%10001111; + !byte $8B,%01101110 + !byte $0D,%01010000 + !byte $0F,%10010001; + !byte $0F,%01110000 + !byte $15,%11010001 + !byte $1D,%00110010 + !byte $5B,%01000110 + !byte $57,%01000110 + !byte $57,%10000111; + !byte $57,%01100110 + !byte $55,%00001000 + !byte $55,%00101000 + !byte $53,%10101001 + !byte $53,%11001001 + !byte $51,%01001010 + !byte $51,%10001011; + !byte $51,%01101010 + !byte $4F,%00001100 + !byte $4F,%00101100 + !byte $4D,%11001101 + !byte $4D,%11101101 + !byte $A7,%11001111 + !byte $AD,%01001110 + !byte $AB,%01001110 + !byte $A9,%01001110 + !byte $A7,%01001110 + !byte $93,%10001111; + !byte $93,%01101110 + !byte $8F,%10001111; + !byte $8F,%01101110 + !byte $8D,%10001111; + !byte $8D,%01101110 + !byte $17,%11110001 + !byte $1B,%00010010 + !byte $1F,%01010010 + !byte $25,%10110011 + !byte $27,%11010011 + !byte $0F,%01010000 + !byte $11,%10010001; + !byte $11,%01110000 + !byte $17,%11010001 + !byte $59,%00000110 + !byte $53,%00001010 + !byte $A3,%10001111; + !byte $A3,%01101110 + !byte $A1,%10001111; + !byte $A1,%01101110 + !byte $9F,%10001111; + !byte $9F,%01101110 + !byte $9D,%10001111; + !byte $9D,%01101110 + !byte $9B,%10001111; + !byte $9B,%01101110 + !byte $1D,%00110000 + !byte $19,%11110001 + !byte $1F,%00110010 + !byte $61,%10001001; + !byte $61,%01101000 + !byte $59,%11100101 + !byte $57,%11000111 + !byte $57,%11100111 + !byte $55,%01001000 + !byte $55,%10001001; + !byte $55,%01101000 + !byte $53,%00101010 + !byte $51,%10101011 + !byte $51,%11001011 + !byte $4F,%01001100 + !byte $99,%10001111; + !byte $99,%01101110 + !byte $97,%10001111; + !byte $97,%01101110 + !byte $87,%10101111 + !byte $85,%10101111 + !byte $83,%10101111 + !byte $81,%10101111 + !byte $7F,%10101111 + !byte $7D,%10101111 + !byte $15,%10110001 + !byte $21,%01010010 + !byte $23,%10010011; + !byte $23,%01110010 + !byte $27,%10110011 + !byte $29,%11010011 + !byte $2B,%11110011 + !byte $A9,%11001111 + !byte $AD,%10001111; + !byte $AD,%01101110 + !byte $1B,%11110001 + !byte $21,%00110010 + !byte $5D,%10000111; + !byte $5D,%01100110 + !byte $5B,%11100101 + !byte $59,%01000110 + !byte $57,%00001000 + !byte $57,%00101000 + !byte $55,%10101001 + !byte $4F,%10001101; + !byte $4F,%01101100 + !byte $95,%10101111 + !byte $91,%10101111 + !byte $0F,%00110000 + !byte $17,%10110001 + !byte $63,%11001001 + !byte $5F,%11000111 + !byte $5B,%00000110 + !byte $59,%10100111 + !byte $55,%11001001 + !byte $53,%01001010 + !byte $53,%10001011; + !byte $53,%01101010 + !byte $51,%11101011 + !byte $51,%00001100 + !byte $4F,%10101101 + !byte $A5,%00010000 + !byte $AB,%10001111; + !byte $AB,%01101110 + !byte $99,%10101111 + !byte $97,%10101111 + !byte $93,%10101111 + !byte $8F,%10101111 + !byte $8D,%10101111 + !byte $8B,%10101111 + !byte $89,%10101111 + !byte $11,%01010000 + !byte $13,%10010001; + !byte $13,%01110000 + !byte $19,%11010001 + !byte $23,%01010010 + !byte $25,%10010011; + !byte $25,%01110010 + !byte $2D,%11110011 + !byte $AD,%10101111 + !byte $A3,%10101111 + !byte $A1,%10101111 + !byte $9F,%10101111 + !byte $21,%00010000 + !byte $11,%00110000 + !byte $13,%01010000 + !byte $63,%10101001 + !byte $5B,%00100110 + !byte $59,%11000111 + !byte $59,%11100111 + !byte $55,%11101001 + !byte $53,%10101011 + !byte $A9,%10101111 + !byte $A7,%10101111 + !byte $A5,%10101111 + !byte $9D,%10101111 + !byte $1F,%00010010 + !byte $29,%10110011 + !byte $55,%00001010 + !byte $51,%00101100 + !byte $4F,%11001101 + !byte $AB,%10101111 + !byte $7F,%11001111 + !byte $7D,%11001111 + !byte $1B,%11010001 + !byte $1D,%11110001 + !byte $25,%01010010 + !byte $27,%10010011; + !byte $27,%01110010 + !byte $2B,%11010011 + !byte $9F,%11001111 + !byte $9D,%11001111 + !byte $11,%00010000 + !byte $17,%10010001; + !byte $17,%01110000 + !byte $23,%00110010 + !byte $2F,%11110011 + !byte $5D,%00000110 + !byte $5B,%10100111 + !byte $A1,%10010001; + !byte $A1,%01110000 + !byte $A7,%00010000 + !byte $AB,%11001111 + !byte $9B,%11001111 + !byte $15,%00010000 + !byte $1D,%11010001 + !byte $21,%00010010 + !byte $2D,%11010011 + !byte $5B,%10000111; + !byte $5B,%01100110 + !byte $59,%00001000 + !byte $59,%00101000 + !byte $57,%10101001 + !byte $57,%11001001 + !byte $55,%00101010 + !byte $55,%01001010 + !byte $53,%11001011 + !byte $53,%11101011 + !byte $51,%01001100 + !byte $4F,%11101101 + !byte $A1,%11001111 + !byte $99,%11001111 + !byte $97,%11001111 + !byte $95,%11001111 + !byte $93,%11001111 + !byte $91,%11001111 + !byte $8F,%11001111 + !byte $8D,%11001111 + !byte $8B,%11001111 + !byte $89,%11001111 + !byte $87,%11001111 + !byte $85,%11001111 + !byte $83,%11001111 + !byte $81,%11001111 + !byte $17,%00010000 + !byte $13,%00110000 + !byte $15,%01010000 + !byte $1F,%11110001 + !byte $2B,%10110011 + !byte $13,%00010000 + !byte $57,%00001010 + !byte $55,%10001011; + !byte $55,%01101010 + !byte $15,%00110000 + !byte $17,%01010000 + !byte $19,%10010001; + !byte $19,%01110000 + !byte $25,%00110010 + !byte $27,%01010010 + !byte $29,%10010011; + !byte $29,%01110010 + !byte $61,%11100111 + !byte $5D,%01000110 + !byte $5B,%11100111 + !byte $59,%01001000 + !byte $59,%10001001; + !byte $59,%01101000 + !byte $57,%11101001 + !byte $53,%00001100 + !byte $51,%10001101; + !byte $51,%01101100 + !byte $51,%10101101 + !byte $21,%11110001 + !byte $23,%00010010 + !byte $31,%11110011 + !byte $A9,%11101111 + !byte $A7,%11101111 + !byte $9B,%11101111 + !byte $15,%11101111 + !byte $13,%11101111 + !byte $1F,%11010001 + !byte $2F,%11010011 + !byte $63,%00101000 + !byte $5B,%00001000 + !byte $5B,%00101000 + !byte $59,%10101001 + !byte $59,%11001001 + !byte $57,%00101010 + !byte $55,%11001011 + !byte $99,%11101111 + !byte $17,%11101111 + !byte $1B,%10010001; + !byte $1B,%01110000 + !byte $27,%00110010 + !byte $2D,%10110011 + !byte $61,%10100111 + !byte $5F,%00100110 + !byte $5D,%10100111 + !byte $5D,%11000111 + !byte $55,%10101011 + !byte $53,%00101100 + !byte $51,%11001101 + !byte $A9,%00010000 + !byte $AB,%11101111 + !byte $A5,%11101111 + !byte $A3,%11101111 + !byte $A1,%11101111 + !byte $9F,%11101111 + !byte $9D,%11101111 + !byte $97,%11101111 + !byte $95,%11101111 + !byte $93,%11101111 + !byte $91,%11101111 + !byte $8F,%11101111 + !byte $8D,%11101111 + !byte $8B,%11101111 + !byte $89,%11101111 + !byte $87,%11101111 + !byte $85,%11101111 + !byte $83,%11101111 + !byte $81,%11101111 + !byte $7F,%11101111 + !byte $7D,%11101111 + !byte $1F,%11101111 + !byte $17,%00110000 + !byte $19,%01010000 + !byte $1D,%10110001 + !byte $29,%01010010 + !byte $2B,%10010011; + !byte $2B,%01110010 + !byte $5D,%11100111 + !byte $59,%11101001 + !byte $57,%01001010 + !byte $19,%00110000 + !byte $1F,%10110001 + !byte $25,%00010010 + !byte $2D,%10010011; + !byte $2D,%01110010 + !byte $5F,%10000111; + !byte $5F,%01100110 + !byte $5B,%10001001; + !byte $5B,%01101000 + !byte $57,%10001011; + !byte $57,%01101010 + !byte $55,%11101011 + !byte $53,%01001100 + !byte $53,%10001101; + !byte $53,%01101100 + !byte $51,%11101101 + !byte $AB,%00010000 + !byte $1B,%01010000 + !byte $1D,%10010001; + !byte $1D,%01110000 + !byte $21,%11010001 + !byte $23,%11110001 + !byte $2F,%10110011 + !byte $31,%11010011 + !byte $33,%11110011 + !byte $1B,%00110000 + !byte $5F,%10100111 + !byte $59,%00001010 + !byte $55,%00001100 + !byte $99,%00010000 + !byte $97,%00010000 + !byte $93,%00010000 + !byte $8D,%00010000 + !byte $1D,%01010000 + !byte $21,%10110001 + !byte $63,%11000111 + !byte $61,%01000110 + !byte $5D,%00101000 + !byte $5B,%10101001 + !byte $5B,%11001001 + !byte $59,%00101010 + !byte $57,%10101011 + !byte $55,%00101100 + !byte $53,%10101101 + !byte $51,%00001110 + !byte $A7,%01010000 + !byte $A1,%00010000 + !byte $9F,%00010000 + !byte $9D,%00010000 + !byte $9B,%00010000 + !byte $95,%00010000 + !byte $91,%00010000 + !byte $8F,%00010000 + !byte $8B,%00010000 + !byte $89,%00010000 + !byte $15,%11001111 + !byte $1F,%10010001; + !byte $1F,%01110000 + !byte $23,%11010001 + !byte $25,%11110001 + !byte $27,%00010010 + !byte $29,%00110010 + !byte $2B,%01010010 + !byte $AB,%00110000 + !byte $65,%01001000 + !byte $61,%10000111; + !byte $61,%01100110 + !byte $5D,%01001000 + !byte $5D,%10001001; + !byte $5D,%01101000 + !byte $57,%11001011 + !byte $A3,%00110000 + !byte $A1,%00110000 + !byte $9F,%00110000 + !byte $9D,%00110000 + !byte $5F,%11100111 + !byte $5F,%00001000 + !byte $5B,%11101001 + !byte $59,%01001010 + !byte $57,%11101011 + !byte $55,%01001100 + !byte $53,%11001101 + !byte $A9,%00110000 + !byte $A7,%00110000 + !byte $A5,%00110000 + !byte $87,%00010000 + !byte $85,%00010000 + !byte $83,%00010000 + !byte $81,%00010000 + !byte $7F,%00010000 + !byte $7D,%00010000 + !byte $1D,%11001111 + !byte $19,%00010000 + !byte $27,%11110001 + !byte $29,%00010010 + !byte $2B,%00110010 + !byte $2D,%01010010 + !byte $2F,%10010011; + !byte $2F,%01110010 + !byte $31,%10110011 + !byte $33,%11010011 + !byte $35,%11110011 + !byte $17,%11001111 + !byte $19,%11101111 + !byte $1F,%01010000 + !byte $23,%10110001 + !byte $63,%01000110 + !byte $5D,%10101001 + !byte $5D,%11001001 + !byte $59,%10101011 + !byte $A9,%01010000 + !byte $97,%00110000 + !byte $8F,%00110000 + !byte $1B,%00010000 + !byte $21,%10010001; + !byte $21,%01110000 + !byte $63,%10000111; + !byte $63,%01100110 + !byte $61,%11000111 + !byte $5B,%00001010 + !byte $5B,%00101010 + !byte $59,%10001011; + !byte $59,%01101010 + !byte $57,%00001100 + !byte $55,%10001101; + !byte $55,%01101100 + !byte $53,%11101101 + !byte $99,%00110000 + !byte $95,%00110000 + !byte $93,%00110000 + !byte $91,%00110000 + !byte $8D,%00110000 + !byte $25,%11010001 + !byte $65,%11000111 + !byte $63,%10100111 + !byte $A5,%01010000 + !byte $A3,%01010000 + !byte $A1,%01010000 + !byte $9F,%01010000 + !byte $9D,%01010000 + !byte $17,%10101111 + !byte $1F,%00110000 + !byte $23,%10010001; + !byte $23,%01110000 + !byte $37,%11110011 + !byte $65,%11100111 + !byte $61,%00001000 + !byte $5F,%10001001; + !byte $5F,%01101000 + !byte $5B,%01001010 + !byte $59,%11001011 + !byte $57,%00101100 + !byte $55,%10101101 + !byte $53,%00001110 + !byte $9B,%01010000 + !byte $99,%01010000 + !byte $8B,%00110000 + !byte $89,%00110000 + !byte $87,%00110000 + !byte $85,%00110000 + !byte $83,%00110000 + !byte $1D,%10101111 + !byte $19,%11001111 + !byte $1B,%11101111 + !byte $1D,%00010000 + !byte $21,%01010000 + !byte $25,%10110001 + !byte $27,%11010001 + !byte $29,%11110001 + !byte $2B,%00010010 + !byte $2D,%00110010 + !byte $2F,%01010010 + !byte $31,%10010011; + !byte $31,%01110010 + !byte $33,%10110011 + !byte $35,%11010011 + !byte $A5,%10010001; + !byte $A5,%01110000 + !byte $A3,%10010001; + !byte $A3,%01110000 + !byte $1B,%11001111 + !byte $25,%10010001; + !byte $25,%01110000 + !byte $65,%10000111; + !byte $65,%01100110 + !byte $61,%00101000 + !byte $61,%01001000 + !byte $5F,%10101001 + !byte $A1,%11110001 + !byte $A9,%10010001; + !byte $A9,%01110000 + !byte $A7,%10010001; + !byte $A7,%01110000 + !byte $95,%01010000 + !byte $1D,%11101111 + !byte $23,%01010000 + !byte $63,%11100111 + !byte $5D,%00001010 + !byte $5B,%10001011; + !byte $5B,%01101010 + !byte $59,%11101011 + !byte $57,%01001100 + !byte $55,%11001101 + !byte $9F,%00010010 + !byte $97,%01010000 + !byte $93,%01010000 + !byte $91,%01010000 + !byte $8F,%01010000 + !byte $81,%00110000 + !byte $7F,%00110000 + !byte $7D,%00110000 + !byte $19,%10101111 + !byte $1F,%00010000 + !byte $21,%00110000 + !byte $29,%11010001 + !byte $7B,%00110000 + !byte $2D,%00010010 + !byte $63,%00001000 + !byte $5F,%11001001 + !byte $5F,%11101001 + !byte $5D,%01001010 + !byte $5B,%10101011 + !byte $9B,%10010001; + !byte $9B,%01110000 + !byte $99,%10010001; + !byte $99,%01110000 + !byte $97,%10010001; + !byte $97,%01110000 + !byte $19,%10001111; + !byte $19,%01101110 + !byte $1B,%10101111 + !byte $2F,%00110010 + !byte $39,%11110011 + !byte $67,%00001000 + !byte $65,%10100111 + !byte $59,%00001100 + !byte $57,%10001101; + !byte $57,%01101100 + !byte $55,%11101101 + !byte $53,%00101110 + !byte $A9,%10110001 + !byte $9F,%10010001; + !byte $9F,%01110000 + !byte $9D,%10010001; + !byte $9D,%01110000 + !byte $8D,%01010000 + !byte $8B,%01010000 + !byte $89,%01010000 + !byte $87,%01010000 + !byte $27,%10110001 + !byte $2B,%11110001 + !byte $31,%01010010 + !byte $33,%10010011; + !byte $33,%01110010 + !byte $35,%10110011 + !byte $37,%11010011 + !byte $A7,%10110001 + !byte $25,%01010000 + !byte $67,%10100111 + !byte $5F,%00001010 + !byte $5D,%10001011; + !byte $5D,%01101010 + !byte $5B,%11101011 + !byte $63,%01001000 + !byte $61,%10101001 + !byte $5B,%11001011 + !byte $59,%00101100 + !byte $57,%10101101 + !byte $A5,%10110001 + !byte $A3,%10110001 + !byte $A1,%10110001 + !byte $9F,%10110001 + !byte $95,%10010001; + !byte $95,%01110000 + !byte $93,%10010001; + !byte $93,%01110000 + !byte $91,%10010001; + !byte $91,%01110000 + !byte $85,%01010000 + !byte $83,%01010000 + !byte $81,%01010000 + !byte $1B,%10001111; + !byte $1B,%01101110 + !byte $23,%00110000 + !byte $27,%10010001; + !byte $27,%01110000 + !byte $29,%10110001 + !byte $2B,%11010001 + !byte $2D,%11110001 + !byte $2F,%00010010 + !byte $A9,%11010001 + !byte $1F,%11001111 + !byte $65,%00101000 + !byte $63,%10001001; + !byte $63,%01101000 + !byte $5F,%00101010 + !byte $A5,%11010001 + !byte $97,%10110001 + !byte $21,%10001111; + !byte $21,%01101110 + !byte $21,%11101111 + !byte $25,%00110000 + !byte $67,%11000111 + !byte $65,%00001000 + !byte $61,%11001001 + !byte $61,%11101001 + !byte $5D,%10101011 + !byte $59,%01001100 + !byte $55,%00001110 + !byte $A7,%11010001 + !byte $9D,%10110001 + !byte $9B,%10110001 + !byte $99,%10110001 + !byte $8F,%10010001; + !byte $8F,%01110000 + !byte $8D,%10010001; + !byte $8D,%01110000 + !byte $8B,%10010001; + !byte $8B,%01110000 + !byte $89,%10010001; + !byte $89,%01110000 + !byte $7F,%01010000 + !byte $7D,%01010000 + !byte $23,%00010000 + !byte $27,%01010000 + !byte $29,%10010001; + !byte $29,%01110000 + !byte $31,%00110010 + !byte $33,%01010010 + !byte $35,%10010011; + !byte $35,%01110010 + !byte $37,%10110011 + !byte $23,%11101111 + !byte $3B,%11110011 + !byte $67,%11100111 + !byte $5F,%01001010 + !byte $57,%11001101 + !byte $A3,%11010001 + !byte $A1,%11010001 + !byte $9F,%11010001 + !byte $9D,%11010001 + !byte $1D,%10001111; + !byte $1D,%01101110 + !byte $1F,%10101111 + !byte $25,%00010000 + !byte $39,%11010011 + !byte $61,%00001010 + !byte $5D,%11001011 + !byte $5B,%00001100 + !byte $59,%10001101; + !byte $59,%01101100 + !byte $55,%00101110 + !byte $95,%10110001 + !byte $93,%10110001 + !byte $91,%10110001 + !byte $87,%10010001; + !byte $87,%01110000 + !byte $85,%10010001; + !byte $85,%01110000 + !byte $7B,%01010000 + !byte $29,%10001111; + !byte $29,%01101110 + !byte $21,%11001111 + !byte $2B,%10110001 + !byte $2D,%11010001 + !byte $2F,%11110001 + !byte $31,%00010010 + !byte $A3,%11110001 + !byte $27,%00110000 + !byte $69,%11000111 + !byte $61,%00101010 + !byte $5F,%10001011; + !byte $5F,%01101010 + !byte $5B,%00101100 + !byte $A7,%11110001 + !byte $A5,%11110001 + !byte $9B,%11010001 + !byte $8F,%10110001 + !byte $21,%01001110 + !byte $23,%11001111 + !byte $33,%00110010 + !byte $6B,%10101001 + !byte $69,%11100111 + !byte $67,%00101000 + !byte $65,%10001001; + !byte $65,%01101000 + !byte $63,%11101001 + !byte $5F,%10101011 + !byte $5D,%11101011 + !byte $59,%10101101 + !byte $57,%11101101 + !byte $55,%01001110 + !byte $A5,%00010010 + !byte $99,%11010001 + !byte $97,%11010001 + !byte $8D,%10110001 + !byte $8B,%10110001 + !byte $83,%10010001; + !byte $83,%01110000 + !byte $81,%10010001; + !byte $81,%01110000 + !byte $1D,%01001110 + !byte $1F,%10001111; + !byte $1F,%01101110 + !byte $21,%10101111 + !byte $29,%01010000 + !byte $2B,%10010001; + !byte $2B,%01110000 + !byte $2D,%10110001 + !byte $35,%01010010 + !byte $37,%10010011; + !byte $37,%01110010 + !byte $39,%10110011 + !byte $9B,%11110001 + !byte $1F,%01001110 + !byte $69,%00001000 + !byte $67,%01001000 + !byte $65,%10101001 + !byte $65,%11001001 + !byte $61,%01001010 + !byte $95,%11010001 + !byte $91,%11010001 + !byte $27,%00010000 + !byte $31,%11110001 + !byte $3B,%11010011 + !byte $3D,%11110011 + !byte $6B,%01001000 + !byte $63,%00001010 + !byte $5D,%00001100 + !byte $5B,%01001100 + !byte $59,%11001101 + !byte $57,%00001110 + !byte $A3,%00110010 + !byte $A7,%00010010 + !byte $9F,%11110001 + !byte $9D,%11110001 + !byte $93,%11010001 + !byte $89,%10110001 + !byte $87,%10110001 + !byte $7F,%10010001; + !byte $7F,%01110000 + !byte $7D,%10010001; + !byte $7D,%01110000 + !byte $25,%11101111 + !byte $29,%00110000 + !byte $2B,%01010000 + !byte $2F,%11010001 + !byte $33,%00010010 + !byte $6B,%11100111 + !byte $61,%10001011; + !byte $61,%01101010 + !byte $99,%11110001 + !byte $1F,%00101110 + !byte $23,%10101111 + !byte $27,%11101111 + !byte $6B,%00101000 + !byte $69,%00101000 + !byte $67,%10001001; + !byte $67,%01101000 + !byte $67,%10101001 + !byte $65,%11101001 + !byte $63,%00101010 + !byte $5F,%11001011 + !byte $5F,%11101011 + !byte $5D,%00101100 + !byte $5B,%10001101; + !byte $5B,%01101100 + !byte $A3,%00010010 + !byte $A1,%00010010 + !byte $97,%11110001 + !byte $8F,%11010001 + !byte $8D,%11010001 + !byte $85,%10110001 + !byte $83,%10110001 + !byte $7B,%10010001; + !byte $7B,%01110000 + !byte $25,%11001111 + !byte $2D,%10010001; + !byte $2D,%01110000 + !byte $2F,%10110001 + !byte $31,%11010001 + !byte $35,%00110010 + !byte $37,%01010010 + !byte $69,%01001000 + !byte $69,%10001001; + !byte $69,%01101000 + !byte $67,%11001001 + !byte $63,%01001010 + !byte $61,%10101011 + !byte $57,%00101110 + !byte $A5,%00110010 + !byte $93,%11110001 + !byte $27,%11001111 + !byte $3B,%10110011 + !byte $6B,%00001000 + !byte $65,%00001010 + !byte $5D,%01001100 + !byte $5B,%10101101 + !byte $59,%11101101 + !byte $9D,%00010010 + !byte $9B,%00010010 + !byte $95,%11110001 + !byte $8B,%11010001 + !byte $89,%11010001 + !byte $81,%10110001 + !byte $23,%10001111; + !byte $23,%01101110 + !byte $25,%10101111 + !byte $29,%00010000 + !byte $2B,%00110000 + !byte $2D,%01010000 + !byte $33,%11110001 + !byte $35,%00010010 + !byte $39,%10010011; + !byte $39,%01110010 + !byte $91,%11110001 + !byte $3D,%11010011 + !byte $67,%11101001 + !byte $63,%10001011; + !byte $63,%01101010 + !byte $5F,%00001100 + !byte $A1,%00110010 + !byte $9F,%00110010 + !byte $25,%00101110 + !byte $25,%10001111; + !byte $25,%01101110 + !byte $2F,%10010001; + !byte $2F,%01110000 + !byte $3F,%11110011 + !byte $69,%10101001 + !byte $65,%00101010 + !byte $61,%11001011 + !byte $59,%00001110 + !byte $57,%01001110 + !byte $99,%00010010 + !byte $97,%00010010 + !byte $8F,%11110001 + !byte $87,%11010001 + !byte $7F,%10110001 + !byte $7D,%10110001 + !byte $21,%00101110 + !byte $23,%01001110 + !byte $29,%11101111 + !byte $2B,%00010000 + !byte $31,%10110001 + !byte $37,%00110010 + !byte $A5,%01010010 + !byte $9D,%00110010 + !byte $33,%11010001 + !byte $39,%01010010 + !byte $63,%10101011 + !byte $5D,%10001101; + !byte $5D,%01101100 + !byte $9B,%00110010 + !byte $99,%00110010 + !byte $95,%00010010 + !byte $8D,%11110001 + !byte $23,%00101110 + !byte $25,%01001110 + !byte $27,%10101111 + !byte $2D,%00110000 + !byte $2F,%01010000 + !byte $3B,%10010011; + !byte $3B,%01110010 + !byte $6D,%00101000 + !byte $6B,%10001001; + !byte $6B,%01101000 + !byte $69,%11001001 + !byte $67,%00001010 + !byte $65,%01001010 + !byte $61,%11101011 + !byte $5F,%00101100 + !byte $5B,%11001101 + !byte $A3,%01010010 + !byte $A1,%01010010 + !byte $93,%00010010 + !byte $8B,%11110001 + !byte $85,%11010001 + !byte $83,%11010001 + !byte $7B,%10110001 + !byte $29,%11001111 + !byte $35,%11110001 + !byte $A5,%10010011; + !byte $A5,%01110010 + !byte $29,%10101111 + !byte $6D,%01001000 + !byte $69,%11101001 + !byte $65,%10001011; + !byte $65,%01101010 + !byte $91,%00010010 + !byte $23,%00001110 + !byte $2B,%11101111 + !byte $2D,%00010000 + !byte $31,%10010001; + !byte $31,%01110000 + !byte $3D,%10110011 + !byte $3F,%11010011 + !byte $67,%00101010 + !byte $63,%11001011 + !byte $61,%00001100 + !byte $5F,%01001100 + !byte $5D,%10101101 + !byte $5B,%11101101 + !byte $59,%00101110 + !byte $57,%10001111; + !byte $57,%01101110 + !byte $9F,%01010010 + !byte $9D,%01010010 + !byte $97,%00110010 + !byte $8F,%00010010 + !byte $89,%11110001 + !byte $87,%11110001 + !byte $81,%11010001 + !byte $79,%10110001 + !byte $27,%10001111; + !byte $27,%01101110 + !byte $33,%10110001 + !byte $37,%00010010 + !byte $39,%00110010 + !byte $95,%00110010 + !byte $2F,%00110000 + !byte $6F,%11001001 + !byte $65,%10101011 + !byte $9D,%11010011 + !byte $A3,%10010011; + !byte $A3,%01110010 + !byte $A1,%10010011; + !byte $A1,%01110010 + !byte $93,%00110010 + !byte $2B,%11001111 + !byte $35,%11010001 + !byte $6F,%00001010 + !byte $6D,%10001001; + !byte $6D,%01101000 + !byte $6B,%11001001 + !byte $69,%00001010 + !byte $67,%01001010 + !byte $63,%11101011 + !byte $61,%00101100 + !byte $5F,%10001101; + !byte $5F,%01101100 + !byte $5D,%11001101 + !byte $99,%11110011 + !byte $9B,%01010010 + !byte $99,%01010010 + !byte $8D,%00010010 + !byte $8B,%00010010 + !byte $85,%11110001 + !byte $7F,%11010001 + !byte $27,%01001110 + !byte $2D,%11101111 + !byte $31,%01010000 + !byte $37,%11110001 + !byte $3B,%01010010 + !byte $6F,%01001000 + !byte $6D,%10101001 + !byte $6B,%11101001 + !byte $67,%10001011; + !byte $67,%01101010 + !byte $5B,%00001110 + !byte $9F,%10010011; + !byte $9F,%01110010 + !byte $9D,%10010011; + !byte $9D,%01110010 + !byte $8F,%00110010 + !byte $7D,%11010001 + !byte $29,%01001110 + !byte $33,%10010001; + !byte $33,%01110000 + !byte $3D,%10010011; + !byte $3D,%01110010 + !byte $69,%00101010 + !byte $65,%11001011 + !byte $63,%00001100 + !byte $59,%01001110 + !byte $A3,%10110011 + !byte $97,%01010010 + !byte $91,%00110010 + !byte $89,%00010010 + !byte $83,%11110001 + !byte $25,%00001110 + !byte $27,%00101110 + !byte $2B,%10101111 + !byte $2F,%00010000 + !byte $31,%00110000 + !byte $35,%10110001 + !byte $39,%00010010 + !byte $2D,%11001111 + !byte $67,%10101011 + !byte $63,%00101100 + !byte $9B,%10010011; + !byte $9B,%01110010 + !byte $99,%10010011; + !byte $99,%01110010 + !byte $95,%01010010 + !byte $7B,%11010001 + !byte $27,%00001110 + !byte $3F,%10110011 + !byte $6F,%10001001; + !byte $6F,%01101000 + !byte $6D,%11001001 + !byte $6B,%00001010 + !byte $69,%01001010 + !byte $61,%01001100 + !byte $5F,%10101101 + !byte $5D,%11101101 + !byte $5B,%00101110 + !byte $59,%10001111; + !byte $59,%01101110 + !byte $A1,%10110011 + !byte $9F,%10110011 + !byte $93,%01010010 + !byte $8D,%00110010 + !byte $87,%00010010 + !byte $81,%11110001 + !byte $2B,%10001111; + !byte $2B,%01101110 + !byte $2F,%11101111 + !byte $33,%01010000 + !byte $37,%11010001 + !byte $3B,%00110010 + !byte $2D,%10101111 + !byte $71,%10001001; + !byte $71,%01101000 + !byte $6F,%10101001 + !byte $6D,%11101001 + !byte $69,%10001011; + !byte $69,%01101010 + !byte $67,%11001011 + !byte $65,%11101011 + !byte $61,%10001101; + !byte $61,%01101100 + !byte $A1,%11010011 + !byte $97,%10010011; + !byte $97,%01110010 + !byte $27,%11101101 + !byte $29,%00101110 + !byte $35,%10010001; + !byte $35,%01110000 + !byte $3D,%01010010 + !byte $41,%11010011 + !byte $6B,%00101010 + !byte $5F,%11001101 + !byte $9D,%10110011 + !byte $9B,%10110011 + !byte $95,%10010011; + !byte $95,%01110010 + !byte $91,%01010010 + !byte $8B,%00110010 + !byte $85,%00010010 + !byte $7F,%11110001 + !byte $79,%11010001 + !byte $2B,%01001110 + !byte $2F,%11001111 + !byte $31,%00010000 + !byte $33,%00110000 + !byte $39,%11110001 + !byte $89,%00110010 + !byte $3B,%00010010 + !byte $3F,%10010011; + !byte $3F,%01110010 + !byte $6B,%01001010 + !byte $69,%10101011 + !byte $67,%11101011 + !byte $65,%00001100 + !byte $5D,%00001110 + !byte $9F,%11010011 + !byte $2D,%10001111; + !byte $2D,%01101110 + !byte $71,%10101001 + !byte $6D,%00001010 + !byte $63,%01001100 + !byte $61,%10101101 + !byte $5B,%01001110 + !byte $99,%10110011 + !byte $93,%10010011; + !byte $93,%01110010 + !byte $8F,%01010010 + !byte $8D,%01010010 + !byte $87,%00110010 + !byte $83,%00010010 + !byte $7D,%11110001 + !byte $29,%00001110 + !byte $2B,%00101110 + !byte $2F,%10101111 + !byte $31,%11101111 + !byte $35,%01010000 + !byte $37,%10110001 + !byte $39,%11010001 + !byte $A1,%11110011 + !byte $2B,%00001110 + !byte $71,%11001001 + !byte $6F,%11101001 + !byte $6B,%10001011; + !byte $6B,%01101010 + !byte $5F,%11101101 + !byte $9B,%11010011 + !byte $95,%10110011 + !byte $91,%10010011; + !byte $91,%01110010 + !byte $2D,%01001110 + !byte $31,%11001111 + !byte $33,%00010000 + !byte $41,%10110011 + !byte $6D,%00101010 + !byte $65,%00101100 + !byte $5D,%00101110 + !byte $59,%10101111 + !byte $97,%10110011 + !byte $8B,%01010010 + !byte $85,%00110010 + !byte $81,%00010010 + !byte $7B,%11110001 + !byte $29,%11101101 + !byte $37,%10010001; + !byte $37,%01110000 + !byte $3B,%11110001 + !byte $3D,%00110010 + !byte $6D,%01001010 + !byte $99,%11010011 + !byte $93,%10110011 + !byte $2D,%00101110 + !byte $2F,%10001111; + !byte $2F,%01101110 + !byte $35,%00110000 + !byte $3F,%01010010 + !byte $43,%11010011 + !byte $71,%11101001 + !byte $6B,%10101011 + !byte $69,%11001011 + !byte $67,%00001100 + !byte $65,%01001100 + !byte $63,%10001101; + !byte $63,%01101100 + !byte $61,%11001101 + !byte $5B,%10001111; + !byte $5B,%01101110 + !byte $9F,%11110011 + !byte $9D,%11110011 + !byte $8F,%10010011; + !byte $8F,%01110010 + !byte $8D,%10010011; + !byte $8D,%01110010 + !byte $89,%01010010 + !byte $83,%00110010 + !byte $7F,%00010010 + !byte $79,%11110001 + !byte $33,%11101111 + !byte $37,%01010000 + !byte $39,%10110001 + !byte $3D,%00010010 + !byte $2B,%11101101 + !byte $31,%10101111 + !byte $73,%11001001 + !byte $71,%00001010 + !byte $5F,%00001110 + !byte $97,%11010011 + !byte $2B,%11001101 + !byte $2D,%00001110 + !byte $3F,%00110010 + !byte $41,%10010011; + !byte $41,%01110010 + !byte $6F,%00101010 + !byte $6D,%10001011; + !byte $6D,%01101010 + !byte $6B,%11001011 + !byte $69,%11101011 + !byte $67,%00101100 + !byte $63,%10101101 + !byte $5D,%01001110 + !byte $9B,%11110011 + !byte $95,%11010011 + !byte $91,%10110011 + !byte $8B,%10010011; + !byte $8B,%01110010 + !byte $87,%01010010 + !byte $81,%00110010 + !byte $7D,%00010010 + !byte $2F,%01001110 + !byte $33,%11001111 + !byte $35,%00010000 + !byte $39,%10010001; + !byte $39,%01110000 + !byte $3B,%11010001 + !byte $8F,%10110011 + !byte $31,%10001111; + !byte $31,%01101110 + !byte $6F,%01001010 + !byte $61,%11101101 + !byte $77,%11110001 + !byte $2D,%11101101 + !byte $37,%00110000 + !byte $73,%11101001 + !byte $71,%00101010 + !byte $6D,%10101011 + !byte $69,%00001100 + !byte $65,%10001101; + !byte $65,%01101100 + !byte $5F,%00101110 + !byte $5B,%10101111 + !byte $97,%11110011 + !byte $93,%11010011 + !byte $89,%10010011; + !byte $89,%01110010 + !byte $85,%01010010 + !byte $7B,%00010010 + !byte $2F,%00101110 + !byte $33,%10101111 + !byte $35,%11101111 + !byte $3D,%11110001 + !byte $7F,%00110010 + !byte $3B,%10110001 + !byte $73,%00001010 + !byte $71,%01001010 + !byte $6B,%11101011 + !byte $67,%01001100 + !byte $2D,%11001101 + !byte $35,%11001111 + !byte $41,%01010010 + !byte $43,%10110011 + !byte $6F,%10001011; + !byte $6F,%01101010 + !byte $69,%00101100 + !byte $63,%11001101 + !byte $61,%00001110 + !byte $5D,%10001111; + !byte $5D,%01101110 + !byte $95,%11110011 + !byte $91,%11010011 + !byte $8D,%10110011 + !byte $87,%10010011; + !byte $87,%01110010 + !byte $83,%01010010 + !byte $2F,%00001110 + !byte $31,%01001110 + !byte $37,%00010000 + !byte $39,%01010000 + !byte $3F,%00010010 + !byte $6D,%11001011 + !byte $65,%10101101 + !byte $8F,%11010011 + !byte $8B,%10110011 + !byte $79,%00010010 + !byte $33,%10001111; + !byte $33,%01101110 + !byte $3D,%11010001 + !byte $73,%00101010 + !byte $6F,%10101011 + !byte $6B,%00001100 + !byte $67,%10001101; + !byte $67,%01101100 + !byte $63,%11101101 + !byte $5F,%01001110 + !byte $5B,%11001111 + !byte $93,%11110011 + !byte $85,%10010011; + !byte $85,%01110010 + !byte $81,%01010010 + !byte $7D,%00110010 + !byte $2F,%11101101 + !byte $31,%00101110 + !byte $39,%00110000 + !byte $3B,%10010001; + !byte $3B,%01110000 + !byte $89,%10110011 + !byte $35,%10101111 + !byte $37,%11101111 + !byte $41,%00110010 + !byte $43,%10010011; + !byte $43,%01110010 + !byte $75,%00001010 + !byte $73,%01001010 + !byte $6F,%11001011 + !byte $6D,%11101011 + !byte $6B,%00101100 + !byte $33,%01001110 + !byte $71,%10001011; + !byte $71,%01101010 + !byte $69,%01001100 + !byte $65,%11001101 + !byte $61,%00101110 + !byte $5D,%10101111 + !byte $91,%11110011 + !byte $8D,%11010011 + !byte $7B,%00110010 + !byte $77,%00010010 + !byte $2F,%11001101 + !byte $31,%00001110 + !byte $39,%00010000 + !byte $3B,%01010000 + !byte $3D,%10110001 + !byte $3F,%11110001 + !byte $7F,%01010010 + !byte $71,%10101011 + !byte $8F,%11110011 + !byte $8B,%11010011 + !byte $33,%00101110 + !byte $43,%01010010 + !byte $45,%10110011 + !byte $75,%00101010 + !byte $6D,%00001100 + !byte $69,%10001101; + !byte $69,%01101100 + !byte $67,%10101101 + !byte $63,%00001110 + !byte $87,%10110011 + !byte $83,%10010011; + !byte $83,%01110010 + !byte $31,%11101101 + !byte $35,%10001111; + !byte $35,%01101110 + !byte $37,%11001111 + !byte $33,%00001110 + !byte $3D,%10010001; + !byte $3D,%01110000 + !byte $41,%00010010 + !byte $75,%01001010 + !byte $71,%11001011 + !byte $65,%11101101 + !byte $37,%10101111 + !byte $3F,%11010001 + !byte $73,%10001011; + !byte $73,%01101010 + !byte $6F,%11101011 + !byte $6B,%01001100 + !byte $61,%01001110 + !byte $5F,%10001111; + !byte $5F,%01101110 + !byte $8D,%11110011 + !byte $89,%11010011 + !byte $85,%10110011 + !byte $81,%10010011; + !byte $81,%01110010 + !byte $7D,%01010010 + !byte $79,%00110010 + !byte $31,%11001101 + !byte $35,%01001110 + !byte $39,%11101111 + !byte $3B,%00110000 + !byte $33,%11101101 + !byte $77,%01001010 + !byte $73,%10101011 + !byte $37,%10001111; + !byte $37,%01101110 + !byte $39,%11001111 + !byte $43,%00110010 + !byte $45,%10010011; + !byte $45,%01110010 + !byte $75,%10001011; + !byte $75,%01101010 + !byte $6F,%00001100 + !byte $6D,%00101100 + !byte $69,%10101101 + !byte $67,%11001101 + !byte $63,%00101110 + !byte $5D,%11001111 + !byte $8B,%11110011 + !byte $87,%11010011 + !byte $83,%10110011 + !byte $7F,%10010011; + !byte $7F,%01110010 + !byte $35,%00101110 + !byte $3B,%00010000 + !byte $3D,%01010000 + !byte $3F,%10110001 + !byte $41,%11110001 + !byte $7B,%01010010 + !byte $33,%11001101 + !byte $75,%10101011 + !byte $71,%11101011 + !byte $6F,%00101100 + !byte $35,%00001110 + !byte $73,%11001011 + !byte $6D,%01001100 + !byte $6B,%10001101; + !byte $6B,%01101100 + !byte $67,%11101101 + !byte $65,%00001110 + !byte $5F,%10101111 + !byte $89,%11110011 + !byte $85,%11010011 + !byte $77,%00110010 + !byte $37,%01001110 + !byte $39,%10101111 + !byte $3B,%11101111 + !byte $3D,%00110000 + !byte $3F,%10010001; + !byte $3F,%01110000 + !byte $81,%10110011 + !byte $73,%11101011 + !byte $71,%00001100 + !byte $35,%11101101 + !byte $43,%00010010 + !byte $45,%01010010 + !byte $47,%10110011 + !byte $77,%10001011; + !byte $77,%01101010 + !byte $6B,%10101101 + !byte $69,%11001101 + !byte $63,%01001110 + !byte $61,%10001111; + !byte $61,%01101110 + !byte $7D,%10010011; + !byte $7D,%01110010 + !byte $79,%01010010 + !byte $37,%00101110 + !byte $39,%10001111; + !byte $39,%01101110 + !byte $3B,%11001111 + !byte $41,%11010001 + !byte $77,%10101011 + !byte $6D,%10001101; + !byte $6D,%01101100 + !byte $65,%00101110 + !byte $35,%10101101 + !byte $35,%11001101 + !byte $39,%01001110 + !byte $3B,%10101111 + !byte $3D,%00010000 + !byte $75,%11001011 + !byte $6F,%01001100 + !byte $67,%00001110 + !byte $5F,%11001111 + !byte $5D,%11101111 + !byte $87,%11110011 + !byte $83,%11010011 + !byte $7F,%10110011 + !byte $75,%00110010 + !byte $37,%00001110 + !byte $3F,%01010000 + !byte $41,%10110001 + !byte $43,%11110001 + !byte $75,%11101011 + !byte $45,%00110010 + !byte $47,%10010011; + !byte $47,%01110010 + !byte $73,%00001100 + !byte $71,%00101100 + !byte $6D,%10101101 + !byte $6B,%11001101 + !byte $69,%11101101 + !byte $63,%10001111; + !byte $63,%01101110 + !byte $61,%10101111 + !byte $85,%11110011 + !byte $81,%11010011 + !byte $7B,%10010011; + !byte $7B,%01110010 + !byte $77,%01010010 + !byte $37,%11101101 + !byte $39,%00101110 + !byte $3B,%10001111; + !byte $3B,%01101110 + !byte $3D,%11101111 + !byte $3F,%00110000 + !byte $41,%10010001; + !byte $41,%01110000 + !byte $77,%11001011 + !byte $37,%11001101 + !byte $3B,%01001110 + !byte $73,%00101100 + !byte $71,%01001100 + !byte $6F,%10001101; + !byte $6F,%01101100 + !byte $69,%00001110 + !byte $67,%00101110 + !byte $65,%01001110 + !byte $83,%11110011 + !byte $7D,%10110011 + !byte $39,%00001110 + !byte $3D,%11001111 + !byte $3F,%00010000 + !byte $43,%11010001 + !byte $79,%11001011 + !byte $75,%00001100 + !byte $37,%10101101 + !byte $45,%00010010 + !byte $47,%01010010 + !byte $77,%11101011 + !byte $6F,%10101101 + !byte $6D,%11001101 + !byte $6B,%11101101 + !byte $61,%11001111 + !byte $5F,%11101111 + !byte $5D,%00010000 + !byte $7F,%11010011 + !byte $79,%10010011; + !byte $79,%01110010 + !byte $39,%11101101 + !byte $3B,%00101110 + !byte $3D,%10101111 + !byte $3F,%11101111 + !byte $41,%01010000 + !byte $43,%10110001 + !byte $77,%00001100 + !byte $39,%11001101 + !byte $45,%11110001 + !byte $49,%10110011 + !byte $75,%00101100 + !byte $73,%01001100 + !byte $71,%10001101; + !byte $71,%01101100 + !byte $67,%01001110 + !byte $65,%10001111; + !byte $65,%01101110 + !byte $63,%10101111 + !byte $81,%11110011 + !byte $7B,%10110011 + !byte $75,%01010010 + !byte $3B,%00001110 + !byte $3D,%10001111; + !byte $3D,%01101110 + !byte $3F,%11001111 + !byte $41,%00110000 + !byte $79,%11101011 + !byte $69,%00101110 + !byte $39,%10101101 + !byte $47,%00110010 + !byte $6F,%11001101 + !byte $6D,%11101101 + !byte $6B,%00001110 + !byte $7D,%11010011 + !byte $77,%10010011; + !byte $77,%01110010 + !byte $3B,%11101101 + !byte $3D,%01001110 + !byte $41,%00010000 + !byte $43,%10010001; + !byte $43,%01110000 + !byte $45,%11010001 + !byte $75,%01001100 + !byte $73,%10001101; + !byte $73,%01101100 + !byte $71,%10101101 + !byte $3D,%00101110 + !byte $3F,%10101111 + !byte $43,%01010000 + !byte $47,%00010010 + !byte $49,%10010011; + !byte $49,%01110010 + !byte $79,%00001100 + !byte $77,%00101100 + !byte $63,%11001111 + !byte $61,%11101111 + !byte $5F,%00010000 + !byte $7F,%11110011 + !byte $79,%10110011 + !byte $3B,%11001101 + !byte $3F,%10001111; + !byte $3F,%01101110 + !byte $41,%11101111 + !byte $79,%00101100 + !byte $3B,%10101101 + !byte $45,%10110001 + !byte $75,%10001101; + !byte $75,%01101100 + !byte $73,%10101101 + !byte $71,%11001101 + !byte $6F,%11101101 + !byte $6D,%00001110 + !byte $6B,%00101110 + !byte $69,%01001110 + !byte $67,%10001111; + !byte $67,%01101110 + !byte $65,%10101111 + !byte $7B,%11010011 + !byte $75,%10010011; + !byte $75,%01110010 + !byte $3D,%00001110 + !byte $3F,%01001110 + !byte $41,%11001111 + !byte $43,%00110000 + !byte $7D,%11110011 + !byte $3D,%11001101 + !byte $3D,%11101101 + !byte $3F,%00101110 + !byte $47,%11110001 + !byte $49,%01010010 + !byte $77,%01001100 + !byte $77,%10110011 + !byte $41,%10101111 + !byte $43,%00010000 + !byte $45,%10010001; + !byte $45,%01110000 + !byte $77,%10001101; + !byte $77,%01101100 + !byte $75,%10101101 + !byte $3D,%10101101 + !byte $41,%10001111; + !byte $41,%01101110 + !byte $49,%00110010 + !byte $79,%01001100 + !byte $73,%11001101 + !byte $71,%11101101 + !byte $6F,%00001110 + !byte $6D,%00101110 + !byte $6B,%01001110 + !byte $69,%10001111; + !byte $69,%01101110 + !byte $67,%10101111 + !byte $65,%11001111 + !byte $63,%11101111 + !byte $61,%00010000 + !byte $5F,%00110000 + !byte $79,%11010011 + !byte $3F,%00001110 + !byte $43,%11101111 + !byte $45,%01010000 + !byte $47,%11010001 + !byte $7B,%01001100 + !byte $3F,%11001101 + !byte $49,%00010010 + !byte $7B,%11110011 + !byte $73,%10010011; + !byte $73,%01110010 + !byte $3F,%11101101 + !byte $41,%01001110 + !byte $43,%11001111 + !byte $45,%00110000 + !byte $47,%10110001 + !byte $3F,%10101101 + !byte $41,%00101110 + !byte $4B,%10010011; + !byte $4B,%01110010 + !byte $79,%10001101; + !byte $79,%01101100 + !byte $77,%10101101 + !byte $75,%11001101 + !byte $73,%11101101 + !byte $71,%00001110 + !byte $6F,%00101110 + !byte $6D,%01001110 + !byte $6B,%10001111; + !byte $6B,%01101110 + !byte $75,%10110011 + !byte $43,%10101111 + !byte $45,%00010000 + !byte $47,%10010001; + !byte $47,%01110000 + !byte $79,%10101101 + !byte $77,%11010011 + !byte $41,%11101101 + !byte $41,%00001110 + !byte $43,%10001111; + !byte $43,%01101110 + !byte $49,%11110001 + !byte $4B,%01010010 + !byte $7B,%10001101; + !byte $7B,%01101100 + !byte $69,%10101111 + !byte $67,%11001111 + !byte $65,%11101111 + !byte $63,%00010000 + !byte $61,%00110000 + !byte $79,%11110011 + !byte $45,%11101111 + !byte $73,%00001110 + !byte $41,%11001101 + !byte $43,%01001110 + !byte $77,%11001101 + !byte $75,%11101101 + !byte $71,%00101110 + !byte $5F,%01010000 + !byte $43,%00101110 + !byte $45,%11001111 + !byte $47,%01010000 + !byte $49,%11010001 + !byte $47,%00110000 + !byte $4B,%00110010 + !byte $77,%11101101 + !byte $6F,%01001110 + !byte $7B,%10101101 + !byte $79,%11001101 + !byte $75,%00001110 + !byte $6D,%10001111; + !byte $6D,%01101110 + !byte $6B,%10101111 + !byte $69,%11001111 + !byte $75,%11010011 + !byte $73,%10110011 + !byte $43,%00001110 + !byte $45,%10101111 + !byte $47,%00010000 + !byte $49,%10110001 + !byte $67,%11101111 + !byte $43,%11101101 + !byte $4B,%00010010 + !byte $73,%00101110 + !byte $71,%01001110 + !byte $6F,%10001111; + !byte $6F,%01101110 + !byte $65,%00010000 + !byte $77,%11110011 + !byte $43,%11001101 + !byte $45,%01001110 + !byte $45,%10001111; + !byte $45,%01101110 + !byte $47,%11101111 + !byte $49,%10010001; + !byte $49,%01110000 + !byte $4B,%11110001 + !byte $4D,%10010011; + !byte $4D,%01110010 + !byte $7B,%11001101 + !byte $79,%11101101 + !byte $77,%00001110 + !byte $6D,%10101111 + !byte $63,%00110000 + !byte $61,%01010000 + !byte $45,%00101110 + !byte $47,%11001111 + !byte $49,%01010000 + !byte $75,%00101110 + !byte $6B,%11001111 + !byte $45,%00001110 + !byte $4D,%01010010 + !byte $73,%01001110 + !byte $69,%11101111 + !byte $71,%10110011 + !byte $45,%11101101 + !byte $47,%10101111 + !byte $49,%00110000 + !byte $4B,%11010001 + !byte $71,%10001111; + !byte $71,%01101110 + !byte $73,%11010011 + !byte $47,%10001111; + !byte $47,%01101110 + !byte $7B,%11101101 + !byte $79,%00001110 + !byte $77,%00101110 + !byte $6F,%10101111 + !byte $67,%00010000 + !byte $65,%00110000 + !byte $75,%11110011 + !byte $45,%11001101 + !byte $47,%01001110 + !byte $49,%00010000 + !byte $4B,%10110001 + !byte $49,%11101111 + !byte $4D,%00110010 + !byte $6D,%11001111 + !byte $47,%00101110 + !byte $75,%01001110 + !byte $73,%10001111; + !byte $73,%01101110 + !byte $6B,%11101111 + !byte $63,%01010000 + !byte $47,%00001110 + !byte $49,%11001111 + !byte $4B,%10010001; + !byte $4B,%01110000 + !byte $4D,%00010010 + !byte $47,%11001101 + !byte $7B,%00001110 + !byte $79,%00101110 + !byte $71,%10101111 + !byte $6F,%11001111 + !byte $69,%00010000 + !byte $61,%10010001; + !byte $61,%01110000 + !byte $47,%11101101 + !byte $49,%10101111 + !byte $4B,%01010000 + !byte $49,%10001111; + !byte $49,%01101110 + !byte $4D,%11110001 + !byte $7B,%00101110 + !byte $77,%01001110 + !byte $75,%10001111; + !byte $75,%01101110 + !byte $6D,%11101111 + !byte $67,%00110000 + !byte $73,%11110011 + !byte $71,%11010011 + !byte $49,%01001110 + !byte $4B,%00010000 + !byte $4B,%00110000 + !byte $4D,%11010001 + !byte $73,%10101111 + !byte $79,%01001110 + !byte $71,%11001111 + !byte $6B,%00010000 + !byte $65,%01010000 + !byte $49,%00001110 + !byte $49,%00101110 + !byte $4B,%11101111 + !byte $4D,%10110001 + !byte $4B,%11001111 + !byte $4F,%01010010 + !byte $7B,%01001110 + !byte $77,%10001111; + !byte $77,%01101110 + !byte $75,%10101111 + !byte $6F,%11101111 + !byte $69,%00110000 + !byte $63,%10010001; + !byte $63,%01110000 + !byte $49,%11101101 + !byte $4B,%10101111 + !byte $4D,%10010001; + !byte $4D,%01110000 + !byte $4F,%00110010 + !byte $79,%10001111; + !byte $79,%01101110 + !byte $73,%11001111 + !byte $6D,%00010000 + !byte $67,%01010000 + !byte $4B,%01001110 + !byte $4B,%10001111; + !byte $4B,%01101110 + !byte $4D,%00110000 + !byte $4D,%01010000 + !byte $4B,%00101110 + !byte $4F,%11110001 + !byte $4F,%00010010 + !byte $77,%10101111 + !byte $71,%11101111 + !byte $6B,%00110000 + !byte $4F,%10010011; + !byte $4F,%01110010 + !byte $71,%11110011 + !byte $4B,%11101101 + !byte $4B,%00001110 + !byte $4D,%00010000 + !byte $65,%10010001; + !byte $65,%01110000 + !byte $7B,%10001111; + !byte $7B,%01101110 + !byte $79,%10101111 + !byte $75,%11001111 + !byte $6F,%00010000 + !byte $69,%01010000 + !byte $61,%10110001 + !byte $4D,%10101111 + !byte $4D,%11001111 + !byte $4D,%11101111 + !byte $4F,%11010001 + !byte $73,%11101111 + !byte $4D,%01001110 + !byte $77,%11001111 + !byte $6D,%00110000 + !byte $63,%10110001 + !byte $4D,%10001111; + !byte $4D,%01101110 + !byte $4F,%10010001; + !byte $4F,%01110000 + !byte $4F,%10110001 + !byte $7B,%10101111 + !byte $75,%11101111 + !byte $71,%00010000 + !byte $67,%10010001; + !byte $67,%01110000 + !byte $4D,%00001110 + !byte $4D,%00101110 + !byte $4F,%00110000 + !byte $4F,%01010000 + !byte $79,%11001111 + !byte $6B,%01010000 + !byte $51,%00110010 + !byte $51,%01010010 + !byte $73,%00010000 + !byte $6F,%00110000 + !byte $6F,%11110011 + !byte $4F,%11101111 + !byte $4F,%00010000 + !byte $77,%11101111 + !byte $4F,%11001111 + !byte $51,%11110001 + !byte $51,%00010010 + !byte $7B,%11001111 + !byte $6D,%01010000 + !byte $69,%10010001; + !byte $69,%01110000 + !byte $65,%10110001 + !byte $4F,%10001111; + !byte $4F,%01101110 + !byte $4F,%10101111 + !byte $71,%00110000 + !byte $4F,%00001110 + !byte $79,%11101111 + !byte $75,%00010000 + !byte $4F,%00101110 + !byte $4F,%01001110 + !byte $51,%10110001 + !byte $51,%11010001 + !byte $63,%11010001 + !byte $5F,%10010001; + !byte $5F,%01110000 + !byte $7B,%11101111 + !byte $77,%00010000 + !byte $73,%00110000 + !byte $6F,%01010000 + !byte $6B,%10010001; + !byte $6B,%01110000 + !byte $67,%10110001 + !byte $51,%00110000 + !byte $51,%01010000 + !byte $51,%10010001; + !byte $51,%01110000 + !byte $6F,%11010011 + !byte $51,%00010000 + !byte $79,%00010000 + !byte $75,%00110000 + !byte $51,%10101111 + !byte $51,%11001111 + !byte $51,%11101111 + !byte $7B,%00010000 + !byte $51,%10001111; + !byte $51,%01101110 + !byte $71,%01010000 + !byte $6D,%10010001; + !byte $6D,%01110000 + !byte $69,%10110001 + !byte $65,%11010001 + !byte $51,%00101110 + !byte $51,%01001110 + !byte $53,%11110001 + !byte $53,%00010010 + !byte $53,%00110010 + !byte $53,%01010010 + !byte $77,%00110000 + !byte $73,%01010000 + !byte $6F,%10010001; + !byte $6F,%01110000 + !byte $79,%00110000 + !byte $75,%01010000 + !byte $6B,%10110001 + !byte $67,%11010001 + !byte $53,%00110000 + !byte $53,%01010000 + !byte $53,%10010001; + !byte $53,%01110000 + !byte $53,%10110001 + !byte $53,%11010001 + !byte $53,%10101111 + !byte $53,%00010000 + !byte $71,%10010001; + !byte $71,%01110000 + !byte $6D,%10110001 + !byte $63,%11110001 + !byte $53,%01001110 + !byte $53,%10001111; + !byte $53,%01101110 + !byte $53,%11001111 + !byte $53,%11101111 + !byte $77,%01010000 + !byte $73,%10010001; + !byte $73,%01110000 + !byte $69,%11010001 + !byte $51,%10010011; + !byte $51,%01110010 + !byte $65,%11110001 + !byte $79,%01010000 + !byte $75,%10010001; + !byte $75,%01110000 + !byte $6F,%10110001 + !byte $6B,%11010001 + !byte $77,%10010001; + !byte $77,%01110000 + !byte $71,%10110001 + !byte $67,%11110001 + !byte $55,%10001111; + !byte $55,%01101110 + !byte $55,%10101111 + !byte $55,%11001111 + !byte $55,%11101111 + !byte $55,%00010010 + !byte $55,%00110010 + !byte $55,%01010010 + !byte $79,%10010001; + !byte $79,%01110000 + !byte $73,%10110001 + !byte $6D,%11010001 + !byte $55,%00010000 + !byte $55,%00110000 + !byte $55,%01010000 + !byte $55,%10010001; + !byte $55,%01110000 + !byte $55,%10110001 + !byte $55,%11010001 + !byte $55,%11110001 + !byte $75,%10110001 + !byte $6F,%11010001 + !byte $69,%11110001 + !byte $6D,%11110011 + !byte $61,%11010001 + !byte $77,%10110001 + !byte $71,%11010001 + !byte $6B,%11110001 + !byte $73,%11010001 + !byte $65,%00010010 + !byte $41,%11110011 + !byte $57,%10101111 + !byte $57,%11001111 + !byte $57,%11101111 + !byte $63,%00010010 + !byte $75,%11010001 + !byte $6D,%11110001 + !byte $67,%00010010 + !byte $57,%00010000 + !byte $57,%00110000 + !byte $57,%01010000 + !byte $57,%10010001; + !byte $57,%01110000 + !byte $53,%10010011; + !byte $53,%01110010 + !byte $77,%11010001 + !byte $6F,%11110001 + !byte $69,%00010010 + !byte $43,%11110011 + !byte $57,%10110001 + !byte $57,%11010001 + !byte $57,%11110001 + !byte $57,%00010010 + !byte $57,%00110010 + !byte $71,%11110001 + !byte $45,%11110011 + !byte $59,%11001111 + !byte $57,%01010010 + !byte $75,%11110001 + !byte $73,%11110001 + !byte $6B,%00010010 + !byte $59,%11101111 + !byte $6D,%00010010 + !byte $65,%00110010 + !byte $47,%11110011 + !byte $59,%00010000 + !byte $59,%00110000 + !byte $6F,%00010010 + !byte $71,%00010010 + !byte $67,%00110010 + !byte $55,%10010011; + !byte $55,%01110010 + !byte $45,%11010011 + !byte $59,%01010000 + !byte $59,%10010001; + !byte $59,%01110000 + !byte $5B,%11101111 + !byte $73,%00010010 + !byte $69,%00110010 + !byte $49,%11110011 + !byte $59,%10110001 + !byte $59,%11010001 + !byte $75,%00010010 + !byte $6B,%00110010 + !byte $47,%11010011 + !byte $63,%00110010 + !byte $59,%11110001 + !byte $6F,%00110010 + !byte $6D,%00110010 + !byte $57,%10010011; + !byte $57,%01110010 + !byte $4B,%11110011 + !byte $5B,%00010000 + !byte $59,%00010010 + !byte $59,%00110010 + !byte $71,%00110010 + !byte $65,%01010010 + !byte $49,%11010011 + !byte $5B,%00110000 + !byte $5B,%01010000 + !byte $59,%01010010 + !byte $73,%00110010 + !byte $67,%01010010 + !byte $4D,%11110011 + !byte $5B,%10010001; + !byte $5B,%01110000 + !byte $59,%10010011; + !byte $59,%01110010 + !byte $6B,%01010010 + !byte $69,%01010010 + !byte $4B,%11010011 + !byte $5D,%00110000 + !byte $5B,%10110001 + !byte $73,%01010010 + !byte $6F,%01010010 + !byte $6D,%01010010 + !byte $61,%11110001 + !byte $5B,%11010001 + !byte $71,%01010010 + !byte $4B,%10110011 + !byte $4F,%11110011 + !byte $63,%01010010 + !byte $5B,%11110001 + !byte $4D,%11010011 + !byte $5D,%01010000 + !byte $5B,%00010010 + !byte $67,%10010011; + !byte $67,%01110010 + !byte $65,%10010011; + !byte $65,%01110010 + !byte $5D,%10010001; + !byte $5D,%01110000 + !byte $5B,%00110010 + !byte $71,%10010011; + !byte $71,%01110010 + !byte $6F,%10010011; + !byte $6F,%01110010 + !byte $6D,%10010011; + !byte $6D,%01110010 + !byte $6B,%10010011; + !byte $6B,%01110010 + !byte $69,%10010011; + !byte $69,%01110010 + !byte $4D,%10110011 + !byte $51,%11110011 + !byte $5D,%10110001 + !byte $4F,%11010011 + !byte $5B,%01010010 + !byte $5D,%11010001 + !byte $5B,%10010011; + !byte $5B,%01110010 + !byte $6B,%11110011 + !byte $63,%10010011; + !byte $63,%01110010 + !byte $5D,%11110001 + !byte $6F,%10110011 + !byte $4F,%10110011 + !byte $53,%11110011 + !byte $5F,%10110001 + !byte $51,%11010011 + !byte $5D,%00010010 + !byte $61,%00010010 + !byte $6D,%10110011 + !byte $6B,%10110011 + !byte $69,%10110011 + !byte $67,%10110011 + !byte $65,%10110011 + !byte $63,%10110011 + !byte $5D,%00110010 + !byte $6D,%11010011 + !byte $5B,%10110011 + !byte $51,%10110011 + !byte $5F,%11010001 + !byte $59,%10110011 + !byte $53,%11010011 + !byte $55,%11110011 + !byte $5D,%01010010 + !byte $57,%10110011 + !byte $5F,%11110001 + !byte $53,%10110011 + !byte $5F,%00010010 + !byte $6B,%11010011 + !byte $69,%11010011 + !byte $55,%10110011 + !byte $61,%00110010 + !byte $5D,%10010011; + !byte $5D,%01110010 + !byte $67,%11010011 + !byte $65,%11010011 + !byte $55,%11010011 + !byte $57,%11110011 + !byte $5F,%00110010 + !byte $5D,%10110011 + !byte $63,%11010011 + !byte $69,%11110011 + !byte $61,%01010010 + !byte $5F,%01010010 + !byte $57,%11010011 + !byte $67,%11110011 + !byte $5D,%11010011 + !byte $59,%11110011 + !byte $61,%10010011; + !byte $61,%01110010 + !byte $5F,%10010011; + !byte $5F,%01110010 + !byte $65,%11110011 + !byte $5B,%11010011 + !byte $61,%10110011 + !byte $63,%11110011 + !byte $59,%11010011 + !byte $61,%11010011 + !byte $5F,%10110011 + !byte $61,%11110011 + !byte $5B,%11110011 + !byte $5F,%11010011 + !byte $5D,%11110011 + !byte $5F,%11110011 diff --git a/src/fx/fx.hgr.star.data.a b/src/fx/fx.hgr.star.data.a new file mode 100644 index 0000000..13d838a --- /dev/null +++ b/src/fx/fx.hgr.star.data.a @@ -0,0 +1,7683 @@ +!cpu 6502 +!to "build/FX/STAR.DATA",plain +*=$8100 + !byte $5F,%11110011 + !byte $61,%11110011 + !byte $5F,%11010011 + !byte $5D,%11110011 + !byte $5D,%11010011 + !byte $5D,%10110011 + !byte $63,%11010011 + !byte $63,%11110011 + !byte $5D,%01110010 + !byte $5D,%10010011; + !byte $61,%11010011 + !byte $5B,%11110011 + !byte $5F,%10110011 + !byte $65,%11010011 + !byte $65,%10110011 + !byte $5D,%01010010 + !byte $59,%11110011 + !byte $63,%10110011 + !byte $67,%10110011 + !byte $65,%11110011 + !byte $5F,%01110010 + !byte $5F,%10010011; + !byte $67,%01110010 + !byte $67,%10010011; + !byte $5B,%11010011 + !byte $5B,%10110011 + !byte $5B,%01110010 + !byte $5B,%10010011; + !byte $5B,%01010010 + !byte $5B,%00110010 + !byte $57,%11110011 + !byte $61,%10110011 + !byte $5B,%00010010 + !byte $69,%01110010 + !byte $69,%10010011; + !byte $5D,%00110010 + !byte $65,%01110010 + !byte $65,%10010011; + !byte $67,%11010011 + !byte $55,%11110011 + !byte $5B,%11110001 + !byte $5F,%01010010 + !byte $69,%01010010 + !byte $59,%11010011 + !byte $6B,%01010010 + !byte $63,%01110010 + !byte $63,%10010011; + !byte $69,%10110011 + !byte $5D,%00010010 + !byte $53,%11110011 + !byte $67,%11110011 + !byte $61,%01110010 + !byte $61,%10010011; + !byte $67,%01010010 + !byte $5B,%11010001 + !byte $57,%11010011 + !byte $6D,%00110010 + !byte $6B,%01110010 + !byte $6B,%10010011; + !byte $5F,%00110010 + !byte $6B,%00110010 + !byte $59,%10110011 + !byte $59,%01110010 + !byte $59,%10010011; + !byte $59,%01010010 + !byte $59,%00110010 + !byte $59,%00010010 + !byte $59,%11110001 + !byte $59,%11010001 + !byte $59,%10110001 + !byte $51,%11110011 + !byte $65,%01010010 + !byte $69,%11010011 + !byte $5D,%11110001 + !byte $55,%11010011 + !byte $59,%01110000 + !byte $59,%10010001; + !byte $61,%01010010 + !byte $6D,%01010010 + !byte $69,%00110010 + !byte $6F,%00010010 + !byte $5B,%10110001 + !byte $4F,%11110011 + !byte $63,%01010010 + !byte $6B,%10110011 + !byte $5F,%00010010 + !byte $6D,%00010010 + !byte $53,%11010011 + !byte $59,%01010000 + !byte $6F,%00110010 + !byte $69,%11110011 + !byte $67,%00110010 + !byte $5D,%11010001 + !byte $4D,%11110011 + !byte $57,%10110011 + !byte $61,%00110010 + !byte $71,%11110001 + !byte $6D,%01110010 + !byte $6D,%10010011; + !byte $5B,%01110000 + !byte $5B,%10010001; + !byte $51,%11010011 + !byte $6B,%00010010 + !byte $71,%00010010 + !byte $65,%00110010 + !byte $6B,%11010011 + !byte $5F,%11110001 + !byte $4B,%11110011 + !byte $55,%10110011 + !byte $6F,%11110001 + !byte $59,%00110000 + !byte $57,%01110010 + !byte $57,%10010011; + !byte $57,%01010010 + !byte $57,%00110010 + !byte $57,%00010010 + !byte $57,%11110001 + !byte $57,%11010001 + !byte $57,%10110001 + !byte $57,%01110000 + !byte $57,%10010001; + !byte $57,%00110000 + !byte $69,%00010010 + !byte $6F,%01010010 + !byte $57,%01010000 + !byte $4F,%11010011 + !byte $57,%00010000 + !byte $5D,%10110001 + !byte $63,%00110010 + !byte $73,%11010001 + !byte $6D,%10110011 + !byte $61,%00010010 + !byte $6D,%11110001 + !byte $73,%11110001 + !byte $49,%11110011 + !byte $5B,%01010000 + !byte $53,%10110011 + !byte $57,%11101111 + !byte $67,%00010010 + !byte $5F,%11010001 + !byte $4D,%11010011 + !byte $71,%00110010 + !byte $6B,%11110011 + !byte $71,%11010001 + !byte $59,%00010000 + !byte $6B,%11110001 + !byte $75,%11010001 + !byte $6F,%01110010 + !byte $6F,%10010011; + !byte $57,%11001111 + !byte $47,%11110011 + !byte $51,%10110011 + !byte $75,%10110001 + !byte $5D,%01110000 + !byte $5D,%10010001; + !byte $65,%00010010 + !byte $6F,%11010001 + !byte $6D,%11010011 + !byte $61,%11110001 + !byte $73,%00010010 + !byte $4B,%11010011 + !byte $55,%01110010 + !byte $55,%10010011; + !byte $5B,%00110000 + !byte $69,%11110001 + !byte $45,%11110011 + !byte $4F,%10110011 + !byte $73,%10110001 + !byte $71,%01010010 + !byte $5F,%10110001 + !byte $77,%10110001 + !byte $59,%11101111 + !byte $63,%00010010 + !byte $75,%11110001 + !byte $6F,%10110011 + !byte $55,%01010010 + !byte $55,%00110010 + !byte $55,%00010010 + !byte $55,%11110001 + !byte $55,%11010001 + !byte $55,%10110001 + !byte $55,%01110000 + !byte $55,%10010001; + !byte $55,%01010000 + !byte $55,%00110000 + !byte $55,%00010000 + !byte $55,%10101111 + !byte $49,%11010011 + !byte $6D,%11010001 + !byte $55,%11101111 + !byte $55,%11001111 + !byte $5D,%01010000 + !byte $53,%01110010 + !byte $53,%10010011; + !byte $77,%01110000 + !byte $77,%10010001; + !byte $57,%10101111 + !byte $55,%01101110 + !byte $55,%10001111; + !byte $67,%11110001 + !byte $43,%11110011 + !byte $4D,%10110011 + !byte $71,%10110001 + !byte $73,%00110010 + !byte $6D,%11110011 + !byte $5B,%00010000 + !byte $61,%11010001 + !byte $79,%01110000 + !byte $79,%10010001; + !byte $47,%11010011 + !byte $6B,%11010001 + !byte $77,%11010001 + !byte $71,%01110010 + !byte $71,%10010011; + !byte $59,%11001111 + !byte $51,%01110010 + !byte $51,%10010011; + !byte $55,%01001110 + !byte $5F,%01110000 + !byte $5F,%10010001; + !byte $65,%11110001 + !byte $75,%01110000 + !byte $75,%10010001; + !byte $75,%00010010 + !byte $6F,%11010011 + !byte $6F,%10110001 + !byte $63,%11110001 + !byte $41,%11110011 + !byte $4B,%10110011 + !byte $5D,%00110000 + !byte $79,%01010000 + !byte $7B,%01010000 + !byte $57,%01101110 + !byte $57,%10001111; + !byte $69,%11010001 + !byte $79,%10110001 + !byte $45,%11010011 + !byte $4F,%01110010 + !byte $4F,%10010011; + !byte $73,%01110000 + !byte $73,%10010001; + !byte $73,%01010010 + !byte $61,%10110001 + !byte $55,%00101110 + !byte $5B,%11101111 + !byte $3F,%11110011 + !byte $6D,%10110001 + !byte $77,%01010000 + !byte $71,%10110011 + !byte $49,%10110011 + !byte $77,%11110001 + !byte $5F,%01010000 + !byte $53,%01010010 + !byte $59,%10101111 + !byte $43,%11010011 + !byte $67,%11010001 + !byte $7B,%01110000 + !byte $7B,%10010001; + !byte $71,%01110000 + !byte $71,%10010001; + !byte $7D,%00110000 + !byte $75,%00110010 + !byte $6F,%11110011 + !byte $53,%00110010 + !byte $53,%00010010 + !byte $53,%11110001 + !byte $53,%11010001 + !byte $53,%10110001 + !byte $53,%01110000 + !byte $53,%10010001; + !byte $53,%01010000 + !byte $53,%00110000 + !byte $53,%00010000 + !byte $53,%11101111 + !byte $53,%11001111 + !byte $53,%10101111 + !byte $53,%01001110 + !byte $53,%00101110 + !byte $63,%11010001 + !byte $4D,%01110010 + !byte $4D,%10010011; + !byte $7B,%00110000 + !byte $53,%00001110 + !byte $5D,%00010000 + !byte $53,%01101110 + !byte $53,%10001111; + !byte $57,%01001110 + !byte $6B,%10110001 + !byte $47,%10110011 + !byte $73,%01110010 + !byte $73,%10010011; + !byte $3D,%11110011 + !byte $51,%01010010 + !byte $79,%11010001 + !byte $75,%01010000 + !byte $53,%11101101 + !byte $61,%01110000 + !byte $61,%10010001; + !byte $65,%11010001 + !byte $5B,%11001111 + !byte $55,%00001110 + !byte $41,%11010011 + !byte $4B,%01110010 + !byte $4B,%10010011; + !byte $6F,%01110000 + !byte $6F,%10010001; + !byte $7D,%01010000 + !byte $77,%00010010 + !byte $71,%11010011 + !byte $5F,%00110000 + !byte $3B,%11110011 + !byte $79,%00110000 + !byte $7F,%00010000 + !byte $59,%01101110 + !byte $59,%10001111; + !byte $69,%10110001 + !byte $45,%10110011 + !byte $7B,%10110001 + !byte $4F,%01010010 + !byte $73,%01010000 + !byte $7D,%00010000 + !byte $63,%10110001 + !byte $75,%01010010 + !byte $53,%11001101 + !byte $5D,%11101111 + !byte $6D,%01110000 + !byte $6D,%10010001; + !byte $79,%11110001 + !byte $3F,%11010011 + !byte $49,%01110010 + !byte $49,%10010011; + !byte $7F,%00110000 + !byte $73,%10110011 + !byte $57,%00101110 + !byte $61,%01010000 + !byte $77,%00110000 + !byte $39,%11110011 + !byte $43,%10110011 + !byte $67,%10110001 + !byte $5B,%10101111 + !byte $4D,%01010010 + !byte $71,%11110011 + !byte $55,%11101101 + !byte $7D,%01110000 + !byte $7D,%10010001; + !byte $77,%00110010 + !byte $5F,%00010000 + !byte $71,%01010000 + !byte $81,%11101111 + !byte $7B,%00010000 + !byte $81,%00010000 + !byte $59,%01001110 + !byte $3D,%11010011 + !byte $51,%00110010 + !byte $6B,%01110000 + !byte $6B,%10010001; + !byte $75,%01110010 + !byte $75,%10010011; + !byte $47,%01110010 + !byte $47,%10010011; + !byte $53,%10101101 + !byte $75,%00110000 + !byte $7B,%11010001 + !byte $51,%00010010 + !byte $51,%11110001 + !byte $51,%11010001 + !byte $51,%10110001 + !byte $51,%01110000 + !byte $51,%10010001; + !byte $51,%01010000 + !byte $51,%00110000 + !byte $51,%00010000 + !byte $51,%11101111 + !byte $51,%11001111 + !byte $51,%10101111 + !byte $51,%01101110 + !byte $51,%10001111; + !byte $51,%01001110 + !byte $51,%00101110 + !byte $51,%11101101 + !byte $5D,%11001111 + !byte $63,%01110000 + !byte $63,%10010001; + !byte $65,%10110001 + !byte $51,%11001101 + !byte $51,%10101101 + !byte $7F,%11101111 + !byte $51,%00001110 + !byte $37,%11110011 + !byte $41,%10110011 + !byte $4B,%01010010 + !byte $6F,%01010000 + !byte $51,%01101100 + !byte $51,%10001101; + !byte $57,%00001110 + !byte $7F,%01010000 + !byte $79,%00010000 + !byte $79,%00010010 + !byte $73,%11010011 + !byte $61,%00110000 + !byte $3B,%11010011 + !byte $69,%01110000 + !byte $69,%10010001; + !byte $77,%01010010 + !byte $55,%11001101 + !byte $5B,%01101110 + !byte $5B,%10001111; + !byte $45,%01110010 + !byte $45,%10010011; + !byte $83,%11001111 + !byte $7D,%10110001 + !byte $4F,%00110010 + !byte $83,%11101111 + !byte $73,%00110000 + !byte $51,%01001100 + !byte $7D,%11101111 + !byte $5F,%11101111 + !byte $59,%00101110 + !byte $3F,%10110011 + !byte $6D,%01010000 + !byte $53,%01101100 + !byte $53,%10001101; + !byte $35,%11110011 + !byte $49,%01010010 + !byte $77,%00010000 + !byte $75,%10110011 + !byte $63,%01010000 + !byte $81,%00110000 + !byte $7B,%11110001 + !byte $67,%01110000 + !byte $67,%10010001; + !byte $81,%11001111 + !byte $7F,%01110000 + !byte $7F,%10010001; + !byte $5D,%10101111 + !byte $39,%11010011 + !byte $51,%00101100 + !byte $43,%01110010 + !byte $43,%10010011; + !byte $4D,%00110010 + !byte $79,%00110010 + !byte $73,%11110011 + !byte $57,%11101101 + !byte $71,%00110000 + !byte $85,%11001111 + !byte $7B,%11101111 + !byte $33,%11110011 + !byte $61,%00010000 + !byte $5B,%01001110 + !byte $3D,%10110011 + !byte $6B,%01010000 + !byte $85,%10101111 + !byte $47,%01010010 + !byte $83,%00010000 + !byte $77,%01110010 + !byte $77,%10010011; + !byte $65,%01110000 + !byte $65,%10010001; + !byte $75,%00010000 + !byte $7D,%11010001 + !byte $7F,%11001111 + !byte $55,%10101101 + !byte $37,%11010011 + !byte $5F,%11001111 + !byte $41,%01110010 + !byte $41,%10010011; + !byte $53,%01001100 + !byte $59,%00001110 + !byte $4B,%00110010 + !byte $6F,%00110000 + !byte $87,%10101111 + !byte $81,%01010000 + !byte $7B,%00010010 + !byte $75,%11010011 + !byte $79,%11101111 + !byte $83,%10101111 + !byte $31,%11110011 + !byte $3B,%10110011 + !byte $63,%00110000 + !byte $4F,%00010010 + !byte $4F,%11110001 + !byte $4F,%11010001 + !byte $4F,%10110001 + !byte $4F,%01110000 + !byte $4F,%10010001; + !byte $4F,%01010000 + !byte $4F,%00010000 + !byte $4F,%11101111 + !byte $4F,%11001111 + !byte $4F,%10101111 + !byte $4F,%01101110 + !byte $4F,%10001111; + !byte $4F,%00101110 + !byte $4F,%11101101 + !byte $4F,%00101100 + !byte $4F,%00001100 + !byte $5D,%01101110 + !byte $5D,%10001111; + !byte $69,%01010000 + !byte $7F,%10110001 + !byte $4F,%00110000 + !byte $4F,%01001110 + !byte $4F,%00001110 + !byte $4F,%11001101 + !byte $4F,%01101100 + !byte $4F,%10001101; + !byte $57,%11001101 + !byte $45,%01010010 + !byte $73,%00010000 + !byte $4F,%01001100 + !byte $4F,%10101101 + !byte $51,%00001100 + !byte $79,%01010010 + !byte $7D,%11001111 + !byte $85,%11101111 + !byte $4F,%11101011 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $61,%11101111 + !byte $35,%11010011 + !byte $6D,%00110000 + !byte $87,%01101110 + !byte $87,%10001111; + !byte $7D,%11110001 + !byte $55,%01101100 + !byte $55,%10001101; + !byte $49,%00110010 + !byte $5B,%00101110 + !byte $77,%10110011 + !byte $77,%11101111 + !byte $83,%00110000 + !byte $89,%01101110 + !byte $89,%10001111; + !byte $65,%01010000 + !byte $2F,%11110011 + !byte $67,%01010000 + !byte $81,%10101111 + !byte $43,%01010010 + !byte $5F,%10101111 + !byte $53,%00101100 + !byte $39,%10110011 + !byte $4D,%00010010 + !byte $71,%00010000 + !byte $7B,%11001111 + !byte $75,%11110011 + !byte $4F,%11001011 + !byte $59,%11101101 + !byte $87,%11001111 + !byte $81,%01110000 + !byte $81,%10010001; + !byte $7B,%00110010 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $5D,%01001110 + !byte $63,%00010000 + !byte $33,%11010011 + !byte $6B,%00110000 + !byte $47,%00110010 + !byte $85,%01101110 + !byte $85,%10001111; + !byte $75,%11101111 + !byte $85,%00010000 + !byte $7F,%11010001 + !byte $51,%11101011 + !byte $2D,%11110011 + !byte $37,%10110011 + !byte $79,%01110010 + !byte $79,%10010011; + !byte $57,%10101101 + !byte $7F,%10101111 + !byte $61,%11001111 + !byte $41,%01010010 + !byte $4B,%00010010 + !byte $6F,%00010000 + !byte $8B,%01001110 + !byte $5B,%00001110 + !byte $79,%11001111 + !byte $83,%01010000 + !byte $7D,%00010010 + !byte $77,%11010011 + !byte $55,%01001100 + !byte $83,%01101110 + !byte $83,%10001111; + !byte $89,%01001110 + !byte $89,%10101111 + !byte $31,%11010011 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $69,%00110000 + !byte $4F,%10101011 + !byte $45,%00110010 + !byte $65,%00110000 + !byte $59,%11001101 + !byte $5F,%01101110 + !byte $5F,%10001111; + !byte $53,%00001100 + !byte $2B,%11110011 + !byte $73,%11101111 + !byte $7B,%01010010 + !byte $3F,%01010010 + !byte $7D,%10101111 + !byte $87,%11101111 + !byte $81,%10110001 + !byte $63,%11101111 + !byte $35,%10110011 + !byte $49,%00010010 + !byte $6D,%00010000 + !byte $87,%01001110 + !byte $5D,%00101110 + !byte $4D,%11110001 + !byte $4D,%11010001 + !byte $4D,%10110001 + !byte $4D,%01110000 + !byte $4D,%10010001; + !byte $4D,%01010000 + !byte $4D,%00110000 + !byte $4D,%00010000 + !byte $4D,%11001111 + !byte $4D,%01101110 + !byte $4D,%10001111; + !byte $4D,%01001110 + !byte $4D,%00001110 + !byte $4D,%11101101 + !byte $4D,%11001101 + !byte $4D,%10101101 + !byte $4D,%01001100 + !byte $57,%01101100 + !byte $57,%10001101; + !byte $77,%11001111 + !byte $8B,%01101110 + !byte $8B,%10001111; + !byte $4D,%11101111 + !byte $4D,%10101111 + !byte $4D,%00001100 + !byte $4D,%11101011 + !byte $4D,%11001011 + !byte $4D,%10101011 + !byte $4D,%01101010 + !byte $4D,%10001011; + !byte $4D,%00101110 + !byte $4D,%01101100 + !byte $4D,%10001101; + !byte $4D,%00101100 + !byte $51,%11001011 + !byte $39,%01110010 + !byte $39,%10010011; + !byte $8D,%00101110 + !byte $85,%00110000 + !byte $7F,%11110001 + !byte $79,%10110011 + !byte $67,%00110000 + !byte $81,%01101110 + !byte $81,%10001111; + !byte $2F,%11010011 + !byte $43,%00110010 + !byte $8B,%00101110 + !byte $61,%10101111 + !byte $4F,%01101010 + !byte $4F,%10001011; + !byte $5B,%11101101 + !byte $71,%11101111 + !byte $89,%11001111 + !byte $4D,%01001010 + !byte $29,%11110011 + !byte $33,%10110011 + !byte $7D,%00110010 + !byte $77,%11110011 + !byte $55,%00101100 + !byte $7B,%10101111 + !byte $83,%01110000 + !byte $83,%10010001; + !byte $65,%00010000 + !byte $47,%00010010 + !byte $6B,%00010000 + !byte $85,%01001110 + !byte $3D,%01010010 + !byte $59,%10101101 + !byte $5F,%01001110 + !byte $75,%11001111 + !byte $8D,%01001110 + !byte $53,%11101011 + !byte $87,%00010000 + !byte $81,%11010001 + !byte $7B,%01110010 + !byte $7B,%10010011; + !byte $2D,%11010011 + !byte $7F,%01101110 + !byte $7F,%10001111; + !byte $37,%01110010 + !byte $37,%10010011; + !byte $41,%00110010 + !byte $89,%00101110 + !byte $4D,%00101010 + !byte $5D,%00001110 + !byte $63,%11001111 + !byte $4B,%11110001 + !byte $6F,%11101111 + !byte $7F,%00010010 + !byte $8F,%00001110 + !byte $8B,%10101111 + !byte $57,%01001100 + !byte $79,%10101111 + !byte $85,%01010000 + !byte $79,%11010011 + !byte $51,%10101011 + !byte $27,%11110011 + !byte $45,%00010010 + !byte $69,%00010000 + !byte $31,%10110011 + !byte $3B,%01010010 + !byte $83,%01001110 + !byte $8D,%00001110 + !byte $8F,%00101110 + !byte $61,%01101110 + !byte $61,%10001111; + !byte $73,%11001111 + !byte $55,%00001100 + !byte $89,%11101111 + !byte $83,%10110001 + !byte $7D,%01010010 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $7D,%01101110 + !byte $7D,%10001111; + !byte $5B,%11001101 + !byte $4F,%01001010 + !byte $2B,%11010011 + !byte $3F,%00110010 + !byte $87,%00101110 + !byte $6D,%11101111 + !byte $65,%11101111 + !byte $49,%11110001 + !byte $5F,%00101110 + !byte $2F,%10110011 + !byte $77,%10101111 + !byte $8D,%01101110 + !byte $8D,%10001111; + !byte $59,%01101100 + !byte $59,%10001101; + !byte $25,%11110011 + !byte $87,%00110000 + !byte $81,%11110001 + !byte $4D,%00001010 + !byte $39,%01010010 + !byte $81,%01001110 + !byte $8B,%00001110 + !byte $91,%11101101 + !byte $7B,%10110011 + !byte $53,%11001011 + !byte $43,%00010010 + !byte $67,%00010000 + !byte $63,%10101111 + !byte $29,%11010011 + !byte $71,%11001111 + !byte $7B,%01101110 + !byte $7B,%10001111; + !byte $5D,%11101101 + !byte $85,%01110000 + !byte $85,%10010001; + !byte $4B,%11010001 + !byte $4B,%10110001 + !byte $4B,%01110000 + !byte $4B,%10010001; + !byte $4B,%01010000 + !byte $4B,%00010000 + !byte $4B,%11101111 + !byte $4B,%11001111 + !byte $4B,%10101111 + !byte $4B,%01101110 + !byte $4B,%10001111; + !byte $4B,%00101110 + !byte $4B,%00001110 + !byte $4B,%11101101 + !byte $4B,%11001101 + !byte $4B,%01001100 + !byte $4B,%00101100 + !byte $4B,%11101011 + !byte $4B,%01101010 + !byte $4B,%10001011; + !byte $4B,%00101010 + !byte $4B,%00001010 + !byte $91,%00001110 + !byte $7F,%00110010 + !byte $79,%11110011 + !byte $8B,%11001111 + !byte $4B,%00110000 + !byte $4B,%01001110 + !byte $4B,%11001011 + !byte $57,%00101100 + !byte $4B,%10101101 + !byte $4B,%01101100 + !byte $4B,%10001101; + !byte $4B,%10101011 + !byte $4B,%01001010 + !byte $61,%01001110 + !byte $33,%01110010 + !byte $33,%10010011; + !byte $3D,%00110010 + !byte $6B,%11101111 + !byte $4B,%00001100 + !byte $47,%11110001 + !byte $85,%00101110 + !byte $4B,%11101001 + !byte $51,%01101010 + !byte $51,%10001011; + !byte $5B,%10101101 + !byte $75,%10101111 + !byte $8F,%11101101 + !byte $8F,%01001110 + !byte $89,%00010000 + !byte $83,%11010001 + !byte $7D,%01110010 + !byte $7D,%10010011; + !byte $4F,%00101010 + !byte $55,%11101011 + !byte $23,%11110011 + !byte $2D,%10110011 + !byte $37,%01010010 + !byte $41,%00010010 + !byte $7F,%01001110 + !byte $89,%00001110 + !byte $6F,%11001111 + !byte $65,%11001111 + !byte $87,%01010000 + !byte $79,%01101110 + !byte $79,%10001111; + !byte $93,%11101101 + !byte $8D,%10101111 + !byte $4B,%11001001 + !byte $5F,%00001110 + !byte $31,%01110010 + !byte $31,%10010011; + !byte $83,%00101110 + !byte $53,%10101011 + !byte $59,%01001100 + !byte $93,%11001101 + !byte $81,%00010010 + !byte $27,%11010011 + !byte $3B,%00110010 + !byte $45,%11110001 + !byte $69,%11101111 + !byte $7B,%11010011 + !byte $63,%01101110 + !byte $63,%10001111; + !byte $8D,%11101101 + !byte $4D,%11101001 + !byte $73,%10101111 + !byte $5D,%11001101 + !byte $91,%00101110 + !byte $8B,%11101111 + !byte $85,%10110001 + !byte $2B,%10110011 + !byte $7D,%01001110 + !byte $7F,%01010010 + !byte $51,%01001010 + !byte $57,%00001100 + !byte $35,%01010010 + !byte $4B,%10101001 + !byte $67,%11101111 + !byte $21,%11110011 + !byte $3F,%00010010 + !byte $49,%11010001 + !byte $6D,%11001111 + !byte $87,%00001110 + !byte $95,%11001101 + !byte $61,%00101110 + !byte $77,%01101110 + !byte $77,%10001111; + !byte $55,%11001011 + !byte $5B,%01101100 + !byte $5B,%10001101; + !byte $81,%00101110 + !byte $8B,%11101101 + !byte $8F,%01101110 + !byte $8F,%10001111; + !byte $89,%00110000 + !byte $83,%11110001 + !byte $7D,%10110011 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $39,%00110010 + !byte $43,%11110001 + !byte $91,%11001101 + !byte $25,%11010011 + !byte $1F,%11110011 + !byte $4F,%00001010 + !byte $65,%10101111 + !byte $5F,%11101101 + !byte $29,%10110011 + !byte $71,%10101111 + !byte $7B,%01001110 + !byte $8D,%11001111 + !byte $95,%10101101 + !byte $87,%01110000 + !byte $87,%10010001; + !byte $59,%00101100 + !byte $85,%00001110 + !byte $33,%01010010 + !byte $7B,%11110011 + !byte $4D,%11001001 + !byte $3D,%00010010 + !byte $47,%11010001 + !byte $6B,%11001111 + !byte $8F,%11001101 + !byte $93,%00001110 + !byte $81,%00110010 + !byte $53,%01101010 + !byte $53,%10001011; + !byte $23,%11010011 + !byte $5D,%10101101 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $75,%01101110 + !byte $75,%10001111; + !byte $63,%01001110 + !byte $51,%00101010 + !byte $7F,%00101110 + !byte $97,%10101101 + !byte $8B,%00010000 + !byte $85,%11010001 + !byte $37,%00110010 + !byte $91,%01001110 + !byte $57,%11101011 + !byte $49,%10110001 + !byte $49,%01110000 + !byte $49,%10010001; + !byte $49,%01010000 + !byte $49,%00110000 + !byte $49,%00010000 + !byte $49,%11101111 + !byte $49,%11001111 + !byte $49,%10101111 + !byte $49,%01001110 + !byte $49,%00101110 + !byte $49,%11001101 + !byte $49,%10101101 + !byte $49,%01001100 + !byte $49,%00001100 + !byte $49,%11101011 + !byte $49,%10101011 + !byte $49,%00001010 + !byte $67,%11001111 + !byte $7F,%01110010 + !byte $7F,%10010011; + !byte $49,%01101110 + !byte $49,%10001111; + !byte $49,%11101101 + !byte $49,%00101100 + !byte $49,%10101001 + !byte $49,%01101000 + !byte $49,%10001001; + !byte $1D,%11110011 + !byte $41,%11110001 + !byte $89,%11101101 + !byte $49,%00001110 + !byte $49,%01101010 + !byte $49,%10001011; + !byte $49,%01001010 + !byte $49,%11101001 + !byte $49,%01101100 + !byte $49,%10001101; + !byte $6F,%10101111 + !byte $49,%11001011 + !byte $49,%11001001 + !byte $49,%00101010 + !byte $49,%01001000 + !byte $4B,%01101000 + !byte $4B,%10001001; + !byte $5B,%01001100 + !byte $55,%10101011 + !byte $61,%00001110 + !byte $79,%01001110 + !byte $89,%01010000 + !byte $83,%00010010 + !byte $7D,%11010011 + !byte $83,%00001110 + !byte $93,%10101101 + !byte $95,%11101101 + !byte $8F,%10101111 + !byte $27,%10110011 + !byte $31,%01010010 + !byte $3B,%00010010 + !byte $69,%11001111 + !byte $8D,%11001101 + !byte $4F,%11101001 + !byte $45,%11010001 + !byte $73,%01101110 + !byte $73,%10001111; + !byte $65,%01101110 + !byte $65,%10001111; + !byte $5F,%11001101 + !byte $35,%00110010 + !byte $7D,%00101110 + !byte $97,%01101100 + !byte $97,%10001101; + !byte $87,%10110001 + !byte $59,%00001100 + !byte $21,%11010011 + !byte $87,%11101101 + !byte $91,%10101101 + !byte $93,%00101110 + !byte $8D,%11101111 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $3F,%11110001 + !byte $81,%01010010 + !byte $49,%00101000 + !byte $53,%01001010 + !byte $6D,%10101111 + !byte $99,%01101100 + !byte $99,%10001101; + !byte $1B,%11110011 + !byte $25,%10110011 + !byte $4D,%10101001 + !byte $63,%00101110 + !byte $2F,%01010010 + !byte $77,%01001110 + !byte $97,%11001101 + !byte $91,%01101110 + !byte $91,%10001111; + !byte $8B,%00110000 + !byte $7F,%10110011 + !byte $57,%11001011 + !byte $5D,%01101100 + !byte $5D,%10001101; + !byte $39,%00010010 + !byte $81,%00001110 + !byte $51,%00001010 + !byte $1F,%11010011 + !byte $43,%11010001 + !byte $71,%01101110 + !byte $71,%10001111; + !byte $85,%11110001 + !byte $4B,%01001000 + !byte $8B,%11001101 + !byte $29,%01110010 + !byte $29,%10010011; + !byte $61,%11101101 + !byte $67,%10101111 + !byte $7B,%00101110 + !byte $95,%01101100 + !byte $95,%10001101; + !byte $95,%00001110 + !byte $33,%00110010 + !byte $3D,%11110001 + !byte $8F,%10101101 + !byte $8F,%11001111 + !byte $5B,%00101100 + !byte $89,%01110000 + !byte $89,%10010001; + !byte $83,%00110010 + !byte $55,%01101010 + !byte $55,%10001011; + !byte $49,%00001000 + !byte $4F,%11001001 + !byte $47,%10110001 + !byte $6B,%10101111 + !byte $7D,%11110011 + !byte $19,%11110011 + !byte $85,%11101101 + !byte $99,%10101101 + !byte $5F,%10101101 + !byte $75,%01001110 + !byte $99,%01001100 + !byte $9B,%01001100 + !byte $93,%01001110 + !byte $2D,%01010010 + !byte $87,%11010001 + !byte $65,%01001110 + !byte $23,%10110011 + !byte $37,%00010010 + !byte $81,%01110010 + !byte $81,%10010011; + !byte $53,%00101010 + !byte $7F,%00001110 + !byte $59,%11101011 + !byte $41,%11010001 + !byte $6F,%01101110 + !byte $6F,%10001111; + !byte $8D,%00010000 + !byte $4D,%01101000 + !byte $4D,%10001001; + !byte $89,%11001101 + !byte $1D,%11010011 + !byte $79,%00101110 + !byte $91,%10101111 + !byte $63,%00001110 + !byte $31,%00110010 + !byte $83,%11101101 + !byte $8D,%10101101 + !byte $97,%11101101 + !byte $8B,%01010000 + !byte $5D,%01001100 + !byte $3B,%11110001 + !byte $93,%01101100 + !byte $93,%10001101; + !byte $57,%10101011 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $45,%10110001 + !byte $69,%10101111 + !byte $85,%00010010 + !byte $7F,%11010011 + !byte $51,%11101001 + !byte $47,%01110000 + !byte $47,%10010001; + !byte $47,%01010000 + !byte $47,%00110000 + !byte $47,%00010000 + !byte $47,%11101111 + !byte $47,%11001111 + !byte $47,%10101111 + !byte $47,%01101110 + !byte $47,%10001111; + !byte $47,%01001110 + !byte $47,%11101101 + !byte $47,%10101101 + !byte $47,%01101100 + !byte $47,%10001101; + !byte $47,%11001011 + !byte $47,%01001010 + !byte $47,%00101010 + !byte $47,%00101000 + !byte $4B,%00101000 + !byte $67,%01101110 + !byte $67,%10001111; + !byte $21,%10110011 + !byte $73,%01001110 + !byte $47,%00001110 + !byte $47,%01001100 + !byte $47,%00001100 + !byte $47,%01101000 + !byte $47,%10001001; + !byte $47,%01001000 + !byte $47,%11100111 + !byte $17,%11110011 + !byte $97,%01001100 + !byte $95,%00101110 + !byte $47,%11001101 + !byte $47,%00101100 + !byte $47,%10101011 + !byte $47,%01101010 + !byte $47,%10001011; + !byte $47,%00001010 + !byte $47,%11101001 + !byte $47,%10101001 + !byte $47,%00101110 + !byte $47,%11101011 + !byte $35,%00010010 + !byte $61,%11001101 + !byte $7D,%00001110 + !byte $9B,%01101100 + !byte $9B,%10001101; + !byte $47,%11001001 + !byte $47,%00001000 + !byte $2B,%01010010 + !byte $3F,%11010001 + !byte $87,%11001101 + !byte $8F,%11101111 + !byte $89,%10110001 + !byte $55,%01001010 + !byte $5B,%00001100 + !byte $6D,%01101110 + !byte $6D,%10001111; + !byte $9D,%00101100 + !byte $83,%01010010 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $99,%11001101 + !byte $47,%11000111 + !byte $49,%11100111 + !byte $4F,%10101001 + !byte $5F,%01101100 + !byte $5F,%10001101; + !byte $65,%00101110 + !byte $1B,%11010011 + !byte $77,%00101110 + !byte $2F,%00110010 + !byte $81,%11101101 + !byte $91,%01101100 + !byte $91,%10001101; + !byte $93,%01101110 + !byte $93,%10001111; + !byte $53,%00001010 + !byte $59,%11001011 + !byte $39,%11110001 + !byte $9B,%00101100 + !byte $87,%11110001 + !byte $43,%10110001 + !byte $8D,%00110000 + !byte $81,%10110011 + !byte $15,%11110011 + !byte $71,%01001110 + !byte $7B,%00001110 + !byte $8B,%10101101 + !byte $29,%01010010 + !byte $9D,%01001100 + !byte $97,%00001110 + !byte $95,%01001100 + !byte $63,%11101101 + !byte $1F,%10110011 + !byte $33,%00010010 + !byte $8F,%01101100 + !byte $8F,%10001101; + !byte $8B,%01110000 + !byte $8B,%10010001; + !byte $7F,%11110011 + !byte $4D,%01001000 + !byte $57,%01101010 + !byte $57,%10001011; + !byte $3D,%11010001 + !byte $6B,%01101110 + !byte $6B,%10001111; + !byte $85,%11001101 + !byte $47,%10100111 + !byte $5D,%00101100 + !byte $51,%11001001 + !byte $91,%11001111 + !byte $85,%00110010 + !byte $75,%00101110 + !byte $61,%10101101 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $37,%11110001 + !byte $99,%00101100 + !byte $7F,%11101101 + !byte $4B,%00001000 + !byte $67,%01001110 + !byte $19,%11010011 + !byte $83,%01110010 + !byte $83,%10010011; + !byte $2D,%00110010 + !byte $89,%10101101 + !byte $9F,%00001100 + !byte $8F,%00010000 + !byte $55,%00101010 + !byte $5B,%11101011 + !byte $41,%10110001 + !byte $95,%01001110 + !byte $1D,%10110011 + !byte $9B,%10101101 + !byte $89,%11010001 + !byte $65,%00001110 + !byte $6F,%01001110 + !byte $49,%11000111 + !byte $4F,%01101000 + !byte $4F,%10001001; + !byte $13,%11110011 + !byte $79,%00001110 + !byte $99,%11101101 + !byte $5F,%01001100 + !byte $87,%00010010 + !byte $3B,%11010001 + !byte $93,%01001100 + !byte $9D,%00001100 + !byte $27,%01010010 + !byte $31,%00010010 + !byte $69,%01101110 + !byte $69,%10001111; + !byte $73,%00101110 + !byte $9F,%00101100 + !byte $93,%10101111 + !byte $45,%01110000 + !byte $45,%10010001; + !byte $83,%11001101 + !byte $59,%10101011 + !byte $97,%00101110 + !byte $8D,%01010000 + !byte $81,%11010011 + !byte $8D,%01101100 + !byte $8D,%10001101; + !byte $97,%00101100 + !byte $4D,%00101000 + !byte $53,%11101001 + !byte $2B,%00110010 + !byte $3F,%10110001 + !byte $7D,%11101101 + !byte $87,%10101101 + !byte $47,%01100110 + !byte $47,%10000111; + !byte $63,%11001101 + !byte $91,%11101111 + !byte $5D,%00001100 + !byte $17,%11010011 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $35,%11110001 + !byte $91,%01001100 + !byte $9D,%01101100 + !byte $9D,%10001101; + !byte $85,%01010010 + !byte $8B,%10110001 + !byte $57,%01001010 + !byte $11,%11110011 + !byte $6D,%01001110 + !byte $1B,%10110011 + !byte $A1,%11101011 + !byte $A1,%00001100 + !byte $51,%10101001 + !byte $45,%01010000 + !byte $45,%00110000 + !byte $45,%00010000 + !byte $45,%11101111 + !byte $45,%11001111 + !byte $45,%01001110 + !byte $45,%00101110 + !byte $45,%00001110 + !byte $45,%10101101 + !byte $45,%00001100 + !byte $45,%10101011 + !byte $45,%01001010 + !byte $45,%00101010 + !byte $45,%00001010 + !byte $45,%11101001 + !byte $45,%11001001 + !byte $45,%01100110 + !byte $45,%10000111; + !byte $25,%01010010 + !byte $77,%00001110 + !byte $81,%11001101 + !byte $9B,%00001100 + !byte $9B,%11001101 + !byte $95,%01101110 + !byte $95,%10001111; + !byte $45,%01101110 + !byte $45,%10001111; + !byte $45,%11101101 + !byte $45,%11001101 + !byte $45,%01001100 + !byte $45,%01101010 + !byte $45,%10001011; + !byte $45,%00101000 + !byte $45,%00001000 + !byte $45,%10100111 + !byte $4B,%11100111 + !byte $15,%11010011 + !byte $45,%10101111 + !byte $45,%11101011 + !byte $45,%10101001 + !byte $45,%01101000 + !byte $45,%10001001; + !byte $67,%00101110 + !byte $45,%01101100 + !byte $45,%10001101; + !byte $45,%11001011 + !byte $45,%11100111 + !byte $61,%01101100 + !byte $61,%10001101; + !byte $2F,%00010010 + !byte $43,%01110000 + !byte $43,%10010001; + !byte $45,%00101100 + !byte $45,%01001000 + !byte $39,%11010001 + !byte $8F,%00110000 + !byte $45,%11000111 + !byte $45,%01000110 + !byte $71,%00101110 + !byte $7B,%11101101 + !byte $89,%11110001 + !byte $83,%10110011 + !byte $55,%00001010 + !byte $5B,%11001011 + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $8B,%01101100 + !byte $8B,%10001101; + !byte $49,%10100111 + !byte $4F,%01001000 + !byte $0F,%11110011 + !byte $29,%00110010 + !byte $33,%11110001 + !byte $95,%00101100 + !byte $9F,%11101011 + !byte $9F,%01001100 + !byte $59,%01101010 + !byte $59,%10001011; + !byte $19,%10110011 + !byte $85,%10101101 + !byte $8F,%01001100 + !byte $87,%00110010 + !byte $65,%11101101 + !byte $3D,%10110001 + !byte $6B,%01001110 + !byte $93,%11001111 + !byte $81,%11110011 + !byte $45,%00100110 + !byte $75,%00001110 + !byte $8D,%01110000 + !byte $8D,%10010001; + !byte $5F,%00101100 + !byte $47,%01000110 + !byte $7F,%11001101 + !byte $99,%00001110 + !byte $4D,%00001000 + !byte $53,%11001001 + !byte $99,%00001100 + !byte $69,%01001110 + !byte $5D,%11101011 + !byte $63,%10101101 + !byte $23,%01010010 + !byte $2D,%00010010 + !byte $37,%11010001 + !byte $41,%01110000 + !byte $41,%10010001; + !byte $91,%00010000 + !byte $13,%11010011 + !byte $89,%01101100 + !byte $89,%10001101; + !byte $A3,%11101011 + !byte $97,%01001110 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $93,%00101100 + !byte $9D,%10101101 + !byte $8B,%11010001 + !byte $85,%01110010 + !byte $85,%10010011; + !byte $57,%00101010 + !byte $6F,%00101110 + !byte $A3,%11001011 + !byte $31,%11110001 + !byte $79,%11101101 + !byte $51,%01101000 + !byte $51,%10001001; + !byte $4B,%11000111 + !byte $0D,%11110011 + !byte $9B,%11101101 + !byte $27,%00110010 + !byte $3B,%10110001 + !byte $95,%10101111 + !byte $45,%00000110 + !byte $61,%01001100 + !byte $67,%00001110 + !byte $17,%10110011 + !byte $83,%10101101 + !byte $4F,%00101000 + !byte $9D,%11101011 + !byte $A1,%00101100 + !byte $8F,%01010000 + !byte $89,%00010010 + !byte $83,%11010011 + !byte $55,%11101001 + !byte $2B,%00010010 + !byte $73,%00001110 + !byte $7D,%11001101 + !byte $21,%01010010 + !byte $8D,%01001100 + !byte $A1,%11001011 + !byte $5B,%10101011 + !byte $35,%11010001 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $A5,%11001011 + !byte $97,%00001100 + !byte $49,%01100110 + !byte $49,%10000111; + !byte $65,%11001101 + !byte $91,%00101100 + !byte $93,%11101111 + !byte $8D,%10110001 + !byte $87,%01010010 + !byte $59,%01001010 + !byte $5F,%00001100 + !byte $11,%11010011 + !byte $6D,%00101110 + !byte $87,%01101100 + !byte $87,%10001101; + !byte $9F,%01101100 + !byte $9F,%10001101; + !byte $25,%00110010 + !byte $2F,%11110001 + !byte $99,%00101110 + !byte $77,%11101101 + !byte $9B,%11101011 + !byte $9D,%11001101 + !byte $53,%10101001 + !byte $4D,%11100111 + !byte $0B,%11110011 + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $81,%10101101 + !byte $69,%00101110 + !byte $39,%10110001 + !byte $43,%01010000 + !byte $A3,%00001100 + !byte $8B,%01001100 + !byte $A5,%10101011 + !byte $85,%10110011 + !byte $63,%01101100 + !byte $63,%10001101; + !byte $1F,%01010010 + !byte $71,%00001110 + !byte $95,%00001100 + !byte $97,%01101110 + !byte $97,%10001111; + !byte $91,%00110000 + !byte $4B,%10100111 + !byte $5D,%11001011 + !byte $8B,%11110001 + !byte $47,%00100110 + !byte $51,%01001000 + !byte $57,%00001010 + !byte $15,%10110011 + !byte $29,%00010010 + !byte $9B,%00001110 + !byte $45,%11100101 + !byte $7B,%11001101 + !byte $85,%01101100 + !byte $85,%10001101; + !byte $43,%00110000 + !byte $43,%00010000 + !byte $43,%11101111 + !byte $43,%11001111 + !byte $43,%10101111 + !byte $43,%01001110 + !byte $43,%00101110 + !byte $43,%00001110 + !byte $43,%11101101 + !byte $43,%10101101 + !byte $43,%01101100 + !byte $43,%10001101; + !byte $43,%01001100 + !byte $43,%11001011 + !byte $43,%10101011 + !byte $43,%01001010 + !byte $43,%00001010 + !byte $43,%11101001 + !byte $43,%11001001 + !byte $43,%10101001 + !byte $43,%01101000 + !byte $43,%10001001; + !byte $43,%01001000 + !byte $43,%10100111 + !byte $43,%00100110 + !byte $33,%11010001 + !byte $8F,%00101100 + !byte $A7,%10101011 + !byte $A1,%01001100 + !byte $95,%11001111 + !byte $89,%00110010 + !byte $43,%01101110 + !byte $43,%10001111; + !byte $43,%11000111 + !byte $43,%01000110 + !byte $43,%11100101 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $6B,%00101110 + !byte $9F,%11001011 + !byte $43,%11001101 + !byte $43,%00101000 + !byte $43,%00001000 + !byte $43,%01100110 + !byte $43,%10000111; + !byte $5B,%01101010 + !byte $5B,%10001011; + !byte $61,%00101100 + !byte $67,%11101101 + !byte $43,%00101100 + !byte $43,%00001100 + !byte $43,%11101011 + !byte $43,%00101010 + !byte $83,%11110011 + !byte $43,%01101010 + !byte $43,%10001011; + !byte $43,%11100111 + !byte $55,%11001001 + !byte $0F,%11010011 + !byte $23,%00110010 + !byte $8F,%01110000 + !byte $8F,%10010001; + !byte $43,%11000101 + !byte $4F,%00001000 + !byte $2D,%11110001 + !byte $75,%11101101 + !byte $7F,%10101101 + !byte $9F,%10101101 + !byte $43,%00000110 + !byte $37,%10110001 + !byte $65,%10101101 + !byte $09,%11110011 + !byte $41,%01010000 + !byte $A3,%10101011 + !byte $8D,%11010001 + !byte $89,%01001100 + !byte $99,%11101011 + !byte $93,%00001100 + !byte $99,%01001110 + !byte $87,%01110010 + !byte $87,%10010011; + !byte $49,%01000110 + !byte $5F,%11101011 + !byte $1D,%01010010 + !byte $27,%00010010 + !byte $6F,%00001110 + !byte $79,%11001101 + !byte $9D,%11001011 + !byte $59,%00101010 + !byte $0D,%11010011 + !byte $A5,%11101011 + !byte $93,%00010000 + !byte $31,%11010001 + !byte $A7,%01101010 + !byte $A7,%10001011; + !byte $9D,%11101101 + !byte $47,%00000110 + !byte $69,%00001110 + !byte $13,%10110011 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $8D,%00101100 + !byte $53,%01101000 + !byte $53,%10001001; + !byte $63,%01001100 + !byte $83,%01101100 + !byte $83,%10001101; + !byte $43,%10100101 + !byte $97,%11101011 + !byte $97,%10101111 + !byte $5D,%10101011 + !byte $4D,%11000111 + !byte $21,%00110010 + !byte $2B,%11110001 + !byte $73,%11101101 + !byte $7D,%10101101 + !byte $A9,%01101010 + !byte $A9,%10001011; + !byte $A3,%00101100 + !byte $91,%01010000 + !byte $8B,%00010010 + !byte $85,%11010011 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $07,%11110011 + !byte $3F,%01010000 + !byte $87,%01001100 + !byte $51,%00101000 + !byte $57,%11101001 + !byte $11,%10110011 + !byte $91,%00001100 + !byte $A7,%11001011 + !byte $67,%11001101 + !byte $45,%11000101 + !byte $5B,%01001010 + !byte $35,%10110001 + !byte $6D,%00001110 + !byte $89,%01010010 + !byte $A1,%10101011 + !byte $9B,%00101110 + !byte $95,%11101111 + !byte $8F,%10110001 + !byte $1B,%01010010 + !byte $81,%01101100 + !byte $81,%10001101; + !byte $A1,%01101100 + !byte $A1,%10001101; + !byte $77,%11001101 + !byte $55,%10101001 + !byte $61,%00001100 + !byte $0B,%11010011 + !byte $25,%00010010 + !byte $2F,%11010001 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $A5,%01101010 + !byte $A5,%10001011; + !byte $99,%01101110 + !byte $99,%10001111; + !byte $9B,%11001011 + !byte $49,%00100110 + !byte $43,%01100100 + !byte $43,%10000101; + !byte $59,%00001010 + !byte $15,%01110010 + !byte $15,%10010011; + !byte $9F,%11001101 + !byte $87,%10110011 + !byte $65,%01101100 + !byte $65,%10001101; + !byte $1F,%00110010 + !byte $A5,%00001100 + !byte $93,%00110000 + !byte $8D,%11110001 + !byte $4F,%11100111 + !byte $29,%11110001 + !byte $71,%11101101 + !byte $95,%11101011 + !byte $5F,%11001011 + !byte $8B,%00101100 + !byte $4D,%10100111 + !byte $33,%10110001 + !byte $9F,%10101011 + !byte $7B,%10101101 + !byte $85,%01001100 + !byte $9D,%00001110 + !byte $53,%01001000 + !byte $63,%00101100 + !byte $69,%11101101 + !byte $05,%11110011 + !byte $3D,%01010000 + !byte $6B,%00001110 + !byte $A9,%01001010 + !byte $AB,%01001010 + !byte $0F,%10110011 + !byte $A3,%01001100 + !byte $97,%11001111 + !byte $19,%01010010 + !byte $23,%00010010 + !byte $2D,%11010001 + !byte $8F,%00001100 + !byte $99,%11001011 + !byte $A9,%10101011 + !byte $8B,%00110010 + !byte $85,%11110011 + !byte $47,%11100101 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $75,%11001101 + !byte $7F,%01101100 + !byte $7F,%10001101; + !byte $91,%01110000 + !byte $91,%10010001; + !byte $A1,%10101101 + !byte $51,%00001000 + !byte $5D,%01101010 + !byte $5D,%10001011; + !byte $67,%10101101 + !byte $09,%11010011 + !byte $A7,%11101011 + !byte $89,%00101100 + !byte $A3,%01101010 + !byte $A3,%10001011; + !byte $9B,%01001110 + !byte $57,%11001001 + !byte $41,%00110000 + !byte $41,%00010000 + !byte $41,%11101111 + !byte $41,%11001111 + !byte $41,%10101111 + !byte $41,%01101110 + !byte $41,%10001111; + !byte $41,%01001110 + !byte $41,%00101110 + !byte $41,%11101101 + !byte $41,%11001101 + !byte $41,%10101101 + !byte $41,%01001100 + !byte $41,%00101100 + !byte $41,%00001100 + !byte $41,%01001010 + !byte $41,%11100111 + !byte $41,%01100100 + !byte $41,%10000101; + !byte $1D,%00110010 + !byte $6F,%11101101 + !byte $95,%00010000 + !byte $89,%01110010 + !byte $89,%10010011; + !byte $41,%00001110 + !byte $41,%00001010 + !byte $41,%11101001 + !byte $41,%11001001 + !byte $41,%01001000 + !byte $41,%00000110 + !byte $41,%10100101 + !byte $41,%01000100 + !byte $61,%11101011 + !byte $27,%11110001 + !byte $79,%10101101 + !byte $93,%11101011 + !byte $8F,%11010001 + !byte $41,%11101011 + !byte $41,%01101000 + !byte $41,%10001001; + !byte $41,%11000111 + !byte $41,%10100111 + !byte $41,%00100110 + !byte $4B,%01000110 + !byte $41,%01101100 + !byte $41,%10001101; + !byte $41,%11001011 + !byte $41,%10101011 + !byte $41,%00101010 + !byte $41,%00001000 + !byte $41,%01000110 + !byte $41,%11100101 + !byte $4F,%11000111 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $41,%01101010 + !byte $41,%10001011; + !byte $41,%10101001 + !byte $41,%00101000 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $5B,%00101010 + !byte $41,%11000101 + !byte $45,%10100101 + !byte $03,%11110011 + !byte $0D,%10110011 + !byte $31,%10110001 + !byte $3B,%01010000 + !byte $8D,%00001100 + !byte $AB,%01101010 + !byte $AB,%10001011; + !byte $55,%01101000 + !byte $55,%10001001; + !byte $83,%01001100 + !byte $9D,%10101011 + !byte $99,%10101111 + !byte $41,%00100100 + !byte $65,%01001100 + !byte $2B,%11010001 + !byte $A5,%00101100 + !byte $9F,%11101101 + !byte $93,%01010000 + !byte $49,%00000110 + !byte $59,%11101001 + !byte $5F,%10101011 + !byte $17,%01010010 + !byte $97,%11001011 + !byte $53,%00101000 + !byte $73,%11001101 + !byte $7D,%01101100 + !byte $7D,%10001101; + !byte $8D,%00010010 + !byte $21,%00010010 + !byte $A7,%01001010 + !byte $87,%11010011 + !byte $43,%01000100 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $87,%00101100 + !byte $A1,%01101010 + !byte $A1,%10001011; + !byte $AB,%00101010 + !byte $AD,%00101010 + !byte $A3,%01101100 + !byte $A3,%10001101; + !byte $69,%11001101 + !byte $07,%11010011 + !byte $3F,%00110000 + !byte $6D,%11101101 + !byte $91,%11101011 + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $63,%00001100 + !byte $81,%01001100 + !byte $9B,%10101011 + !byte $A9,%11001011 + !byte $97,%11101111 + !byte $8B,%01010010 + !byte $47,%11000101 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $1B,%00110010 + !byte $25,%11110001 + !byte $2F,%10110001 + !byte $77,%10101101 + !byte $A7,%00001100 + !byte $5D,%01001010 + !byte $57,%10101001 + !byte $0B,%10110011 + !byte $8B,%00001100 + !byte $9D,%00101110 + !byte $91,%10110001 + !byte $39,%01010000 + !byte $A5,%01001010 + !byte $9B,%01101110 + !byte $9B,%10001111; + !byte $41,%00000100 + !byte $45,%01100100 + !byte $45,%10000101; + !byte $01,%11110011 + !byte $1F,%00010010 + !byte $51,%11100111 + !byte $67,%01101100 + !byte $67,%10001101; + !byte $A1,%11001101 + !byte $29,%11010001 + !byte $71,%11001101 + !byte $AD,%01001010 + !byte $89,%10110011 + !byte $4B,%00100110 + !byte $61,%11001011 + !byte $15,%01010010 + !byte $95,%11001011 + !byte $3D,%00110000 + !byte $7B,%01101100 + !byte $7B,%10001101; + !byte $95,%00110000 + !byte $8F,%11110001 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $85,%00101100 + !byte $9F,%01101010 + !byte $9F,%10001011; + !byte $AB,%10101011 + !byte $49,%11100101 + !byte $5B,%00001010 + !byte $43,%00100100 + !byte $6B,%11101101 + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $8F,%11101011 + !byte $55,%01001000 + !byte $05,%11010011 + !byte $19,%00110010 + !byte $75,%10101101 + !byte $9F,%00001110 + !byte $99,%11001111 + !byte $93,%01110000 + !byte $93,%10010001; + !byte $5F,%01101010 + !byte $5F,%10001011; + !byte $99,%10101011 + !byte $A9,%00101010 + !byte $AF,%00001010 + !byte $8D,%00110010 + !byte $87,%11110011 + !byte $4F,%10100111 + !byte $65,%00101100 + !byte $23,%11110001 + !byte $2D,%10110001 + !byte $7F,%01001100 + !byte $A3,%01001010 + !byte $A5,%01001100 + !byte $37,%01010000 + !byte $59,%11001001 + !byte $4D,%01000110 + !byte $09,%10110011 + !byte $13,%01010010 + !byte $1D,%00010010 + !byte $6F,%11001101 + !byte $89,%00001100 + !byte $53,%00001000 + !byte $69,%10101101 + !byte $27,%11010001 + !byte $A3,%10101101 + !byte $79,%01101100 + !byte $79,%10001101; + !byte $93,%11001011 + !byte $A9,%11101011 + !byte $97,%00010000 + !byte $47,%10100101 + !byte $5D,%00101010 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $9D,%01101010 + !byte $9D,%10001011; + !byte $AD,%01101010 + !byte $AD,%10001011; + !byte $9D,%01001110 + !byte $91,%11010001 + !byte $8B,%01110010 + !byte $8B,%10010011; + !byte $3B,%00110000 + !byte $A7,%00101010 + !byte $AD,%00001010 + !byte $63,%11101011 + !byte $AF,%00101010 + !byte $41,%11100011 + !byte $57,%01101000 + !byte $57,%10001001; + !byte $83,%00101100 + !byte $8D,%11101011 + !byte $51,%11000111 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $21,%11110001 + !byte $2B,%10110001 + !byte $73,%10101101 + !byte $A7,%00101100 + !byte $A1,%11101101 + !byte $95,%01010000 + !byte $4B,%00000110 + !byte $67,%01001100 + !byte $3F,%00010000 + !byte $3F,%11101111 + !byte $3F,%11001111 + !byte $3F,%10101111 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $3F,%01001110 + !byte $3F,%00101110 + !byte $3F,%11101101 + !byte $3F,%11001101 + !byte $3F,%10101101 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $3F,%01001100 + !byte $3F,%11001011 + !byte $3F,%01001010 + !byte $3F,%10101001 + !byte $3F,%01001000 + !byte $3F,%00001000 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $3F,%00100100 + !byte $03,%11010011 + !byte $17,%00110010 + !byte $7D,%01001100 + !byte $9B,%10101111 + !byte $8F,%00010010 + !byte $89,%11010011 + !byte $3F,%00101100 + !byte $3F,%11101011 + !byte $3F,%00001010 + !byte $3F,%10100101 + !byte $3F,%01000100 + !byte $61,%10101011 + !byte $35,%01010000 + !byte $87,%00001100 + !byte $97,%10101011 + !byte $3F,%00001110 + !byte $3F,%00001100 + !byte $3F,%10101011 + !byte $3F,%11101001 + !byte $3F,%11100111 + !byte $3F,%00100110 + !byte $3F,%11000101 + !byte $45,%01000100 + !byte $5B,%11101001 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $3F,%00101010 + !byte $3F,%11001001 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $3F,%00101000 + !byte $3F,%11100101 + !byte $3F,%11100011 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $55,%00101000 + !byte $3F,%11000111 + !byte $3F,%10100111 + !byte $3F,%00000110 + !byte $A1,%01001010 + !byte $B1,%11101001 + !byte $B1,%00001010 + !byte $3F,%01000110 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $65,%00001100 + !byte $1B,%00010010 + !byte $77,%01101100 + !byte $77,%10001101; + !byte $AB,%11001011 + !byte $9F,%00101110 + !byte $3F,%00000100 + !byte $3F,%11000011 + !byte $49,%11000101 + !byte $6D,%11001101 + !byte $AB,%00001010 + !byte $A5,%01101100 + !byte $A5,%10001101; + !byte $6B,%11001101 + !byte $59,%10101001 + !byte $07,%10110011 + !byte $11,%01010010 + !byte $93,%10110001 + !byte $8D,%01010010 + !byte $5F,%01001010 + !byte $25,%11010001 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $91,%11001011 + !byte $9B,%01101010 + !byte $9B,%10001011; + !byte $99,%11101111 + !byte $53,%11100111 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $39,%00110000 + !byte $81,%00101100 + !byte $A5,%00101010 + !byte $4D,%00100110 + !byte $15,%00110010 + !byte $3F,%10100011 + !byte $43,%00000100 + !byte $71,%10101101 + !byte $8B,%11101011 + !byte $AF,%01001010 + !byte $5D,%00001010 + !byte $69,%01101100 + !byte $69,%10001101; + !byte $01,%11010011 + !byte $29,%10110001 + !byte $B3,%11101001 + !byte $A9,%00001100 + !byte $9D,%01101110 + !byte $9D,%10001111; + !byte $97,%00110000 + !byte $63,%11001011 + !byte $1F,%11110001 + !byte $AF,%11101001 + !byte $8B,%10110011 + !byte $51,%10100111 + !byte $9F,%01001010 + !byte $A3,%11001101 + !byte $91,%11110001 + !byte $47,%01100100 + !byte $47,%10000101; + !byte $0F,%01010010 + !byte $33,%01010000 + !byte $3D,%00010000 + !byte $7B,%01001100 + !byte $95,%10101011 + !byte $41,%11000011 + !byte $45,%00100100 + !byte $4B,%11100101 + !byte $A9,%00001010 + !byte $9B,%11001111 + !byte $19,%00010010 + !byte $75,%01101100 + !byte $75,%10001101; + !byte $85,%00001100 + !byte $57,%01001000 + !byte $61,%01101010 + !byte $61,%10001011; + !byte $67,%00101100 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $A7,%01001100 + !byte $95,%01110000 + !byte $95,%10010001; + !byte $23,%11010001 + !byte $7F,%00101100 + !byte $8F,%11001011 + !byte $B3,%11001001 + !byte $A1,%00001110 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $5B,%11001001 + !byte $05,%10110011 + !byte $13,%00110010 + !byte $AD,%10101011 + !byte $89,%11110011 + !byte $4F,%01000110 + !byte $99,%01101010 + !byte $99,%10001011; + !byte $8F,%00110010 + !byte $37,%00110000 + !byte $93,%10101011 + !byte $A5,%10101101 + !byte $55,%00001000 + !byte $A3,%00101010 + !byte $AD,%11101001 + !byte $AB,%11101011 + !byte $49,%10100101 + !byte $43,%11100011 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $1D,%11110001 + !byte $27,%10110001 + !byte $6F,%10101101 + !byte $9F,%01001110 + !byte $6B,%10101101 + !byte $89,%11101011 + !byte $65,%11101011 + !byte $31,%01010000 + !byte $79,%01001100 + !byte $83,%00001100 + !byte $A7,%00001010 + !byte $B1,%00101010 + !byte $93,%11010001 + !byte $5F,%00101010 + !byte $9D,%01001010 + !byte $8D,%01110010 + !byte $8D,%10010011; + !byte $17,%00010010 + !byte $3B,%00010000 + !byte $B5,%11001001 + !byte $99,%00010000 + !byte $53,%11000111 + !byte $59,%01101000 + !byte $59,%10001001; + !byte $03,%10110011 + !byte $AF,%01101010 + !byte $AF,%10001011; + !byte $A9,%00101100 + !byte $4D,%00000110 + !byte $63,%10101011 + !byte $69,%01001100 + !byte $0D,%01010010 + !byte $73,%01101100 + !byte $73,%10001101; + !byte $97,%01101010 + !byte $97,%10001011; + !byte $9D,%10101111 + !byte $8B,%11010011 + !byte $7D,%00101100 + !byte $8D,%11001011 + !byte $B1,%11001001 + !byte $5D,%11101001 + !byte $21,%11010001 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $A1,%00101010 + !byte $91,%00010010 + !byte $47,%01000100 + !byte $35,%00110000 + !byte $AD,%11001011 + !byte $A3,%11101101 + !byte $97,%01010000 + !byte $1B,%11110001 + !byte $6D,%10101101 + !byte $87,%11101011 + !byte $57,%00101000 + !byte $11,%00110010 + !byte $25,%10110001 + !byte $91,%10101011 + !byte $9B,%01001010 + !byte $AB,%11101001 + !byte $41,%10100011 + !byte $B5,%10101001 + !byte $9B,%11101111 + !byte $8F,%01010010 + !byte $61,%01001010 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $77,%01001100 + !byte $95,%10110001 + !byte $67,%00001100 + !byte $01,%10110011 + !byte $2F,%01010000 + !byte $81,%00001100 + !byte $A1,%00101110 + !byte $4B,%11000101 + !byte $51,%01100110 + !byte $51,%10000111; + !byte $3D,%11101111 + !byte $3D,%11001111 + !byte $3D,%10101111 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $3D,%01001110 + !byte $3D,%00101110 + !byte $3D,%00001110 + !byte $3D,%11001101 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $3D,%01001100 + !byte $3D,%00101100 + !byte $3D,%10101011 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $3D,%00101010 + !byte $3D,%00001010 + !byte $3D,%11101001 + !byte $3D,%10100111 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $3D,%11100101 + !byte $3D,%00100100 + !byte $0B,%01010010 + !byte $39,%00010000 + !byte $B1,%01001010 + !byte $A7,%01101100 + !byte $A7,%10001101; + !byte $3D,%10101101 + !byte $3D,%11101011 + !byte $3D,%11001011 + !byte $3D,%11001001 + !byte $3D,%01001000 + !byte $3D,%00101000 + !byte $3D,%00001000 + !byte $3D,%00000110 + !byte $3D,%11100011 + !byte $3D,%10100011 + !byte $3D,%01000010 + !byte $3F,%01000010 + !byte $8B,%11001011 + !byte $A5,%00001010 + !byte $AF,%11001001 + !byte $3D,%11101101 + !byte $3D,%00001100 + !byte $3D,%01001010 + !byte $3D,%10101001 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $3D,%11000101 + !byte $3D,%00000100 + !byte $45,%00000100 + !byte $3D,%11000111 + !byte $1F,%11010001 + !byte $AB,%00001100 + !byte $9F,%01101110 + !byte $9F,%10001111; + !byte $99,%00110000 + !byte $3D,%11100111 + !byte $3D,%00100110 + !byte $3D,%01000100 + !byte $5B,%10101001 + !byte $6B,%01101100 + !byte $6B,%10001101; + !byte $71,%01101100 + !byte $71,%10001101; + !byte $95,%01101010 + !byte $95,%10001011; + !byte $3D,%01000110 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $3D,%11000011 + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $3D,%00100010 + !byte $55,%11100111 + !byte $3D,%10100101 + !byte $4F,%00100110 + !byte $7B,%00101100 + !byte $A9,%11101001 + !byte $B7,%10101001 + !byte $B3,%00001010 + !byte $A5,%11001101 + !byte $49,%01100100 + !byte $49,%10000101; + !byte $5F,%00001010 + !byte $65,%11001011 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $15,%00010010 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $33,%00110000 + !byte $85,%11101011 + !byte $93,%11110001 + !byte $8D,%10110011 + !byte $0F,%00110010 + !byte $9F,%00101010 + !byte $47,%00100100 + !byte $23,%10110001 + !byte $8F,%10101011 + !byte $A9,%01001100 + !byte $97,%01110000 + !byte $97,%10010001; + !byte $4D,%11100101 + !byte $99,%01001010 + !byte $B3,%10101001 + !byte $A3,%00001110 + !byte $43,%11000011 + !byte $53,%10100111 + !byte $59,%01001000 + !byte $19,%11110001 + !byte $2D,%01010000 + !byte $75,%01001100 + !byte $AF,%10101011 + !byte $91,%00110010 + !byte $69,%00101100 + !byte $B5,%11101001 + !byte $9D,%11001111 + !byte $63,%01101010 + !byte $63,%10001011; + !byte $37,%00010000 + !byte $7F,%00001100 + !byte $A3,%00001010 + !byte $8B,%11110011 + !byte $3D,%00000010 + !byte $89,%11001011 + !byte $AD,%11001001 + !byte $5D,%11001001 + !byte $13,%00010010 + !byte $1D,%11010001 + !byte $6F,%01101100 + !byte $6F,%10001101; + !byte $93,%01101010 + !byte $93,%10001011; + !byte $B7,%01101000 + !byte $B7,%10001001; + !byte $41,%01100010 + !byte $41,%10000011; + !byte $45,%11100011 + !byte $4B,%10100101 + !byte $51,%01000110 + !byte $09,%01010010 + !byte $79,%00101100 + !byte $9D,%00101010 + !byte $B3,%00101010 + !byte $57,%00001000 + !byte $A7,%10101101 + !byte $67,%11101011 + !byte $61,%00101010 + !byte $31,%00110000 + !byte $3B,%11101111 + !byte $9B,%00010000 + !byte $95,%11010001 + !byte $8F,%01110010 + !byte $8F,%10010011; + !byte $03,%01110010 + !byte $03,%10010011; + !byte $27,%01110000 + !byte $27,%10010001; + !byte $83,%11101011 + !byte $A1,%01001110 + !byte $3F,%00100010 + !byte $55,%11000111 + !byte $73,%01001100 + !byte $8D,%10101011 + !byte $B9,%01101000 + !byte $B9,%10001001; + !byte $B7,%11001001 + !byte $AD,%11101011 + !byte $5B,%01101000 + !byte $5B,%10001001; + !byte $17,%11110001 + !byte $A7,%11101001 + !byte $0D,%00110010 + !byte $B1,%10101001 + !byte $4F,%00000110 + !byte $6B,%01001100 + !byte $21,%10110001 + !byte $97,%01001010 + !byte $49,%01000100 + !byte $43,%10100011 + !byte $65,%10101011 + !byte $2B,%01010000 + !byte $35,%00010000 + !byte $A5,%11101101 + !byte $5F,%11101001 + !byte $7D,%00001100 + !byte $9F,%10101111 + !byte $8D,%11010011 + !byte $3D,%11100001 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $11,%00010010 + !byte $6D,%01101100 + !byte $6D,%10001101; + !byte $AB,%00101100 + !byte $99,%01010000 + !byte $93,%00010010 + !byte $07,%01010010 + !byte $87,%11001011 + !byte $A1,%00001010 + !byte $59,%00101000 + !byte $B1,%01101010 + !byte $B1,%10001011; + !byte $77,%00101100 + !byte $91,%01101010 + !byte $91,%10001011; + !byte $A5,%11101001 + !byte $AF,%11001011 + !byte $A3,%00101110 + !byte $4D,%11000101 + !byte $41,%01000010 + !byte $1B,%11010001 + !byte $B5,%01101000 + !byte $B5,%10001001; + !byte $A9,%01101100 + !byte $A9,%10001101; + !byte $97,%10110001 + !byte $69,%00001100 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $2F,%00110000 + !byte $39,%11101111 + !byte $9B,%00101010 + !byte $AB,%11001001 + !byte $91,%01010010 + !byte $63,%01001010 + !byte $0B,%00110010 + !byte $AF,%10101001 + !byte $9D,%11101111 + !byte $57,%11100111 + !byte $5D,%10101001 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $81,%11101011 + !byte $47,%00000100 + !byte $15,%11110001 + !byte $71,%01001100 + !byte $B5,%00001010 + !byte $A7,%11001101 + !byte $45,%11000011 + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $51,%00100110 + !byte $1F,%10110001 + !byte $8B,%10101011 + !byte $33,%00010000 + !byte $B9,%01001000 + !byte $BB,%01001000 + !byte $B9,%10101001 + !byte $67,%11001011 + !byte $29,%01010000 + !byte $7B,%00001100 + !byte $85,%11001011 + !byte $95,%01001010 + !byte $B3,%01001010 + !byte $AD,%00001100 + !byte $A1,%01101110 + !byte $A1,%10001111; + !byte $9B,%00110000 + !byte $8F,%10110011 + !byte $61,%00001010 + !byte $9F,%00001010 + !byte $05,%01010010 + !byte $3B,%11001111 + !byte $3B,%10101111 + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $3B,%01001110 + !byte $3B,%00101110 + !byte $3B,%00001110 + !byte $3B,%11101101 + !byte $3B,%11001101 + !byte $3B,%10101101 + !byte $3B,%00101100 + !byte $3B,%00001100 + !byte $3B,%11101011 + !byte $3B,%10101011 + !byte $3B,%01001010 + !byte $3B,%00101010 + !byte $3B,%11101001 + !byte $3B,%11001001 + !byte $3B,%10101001 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $3B,%01001000 + !byte $3B,%00001000 + !byte $3B,%11100111 + !byte $3B,%10100111 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $3B,%00000110 + !byte $3B,%11100101 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $3B,%11000011 + !byte $3B,%00100010 + !byte $3B,%11100001 + !byte $19,%11010001 + !byte $75,%00101100 + !byte $B3,%01101000 + !byte $B3,%10001001; + !byte $95,%11110001 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $3B,%01001100 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $3B,%00100110 + !byte $3B,%10100101 + !byte $3B,%11100011 + !byte $3F,%00000010 + !byte $55,%10100111 + !byte $0F,%00010010 + !byte $8F,%01101010 + !byte $8F,%10001011; + !byte $A9,%11001001 + !byte $B7,%11101001 + !byte $3B,%00001010 + !byte $3B,%01000110 + !byte $3B,%01000100 + !byte $5B,%01001000 + !byte $3B,%11001011 + !byte $3B,%00101000 + !byte $3B,%11000111 + !byte $3B,%00100100 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $2D,%00110000 + !byte $7F,%11101011 + !byte $B1,%10101011 + !byte $8D,%11110011 + !byte $3B,%11000101 + !byte $3B,%10100011 + !byte $3B,%01000010 + !byte $3B,%00000010 + !byte $3B,%11000001 + !byte $43,%01100010 + !byte $43,%10000011; + !byte $6B,%00101100 + !byte $AB,%01001100 + !byte $9F,%11001111 + !byte $3B,%00000100 + !byte $4F,%11100101 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $37,%11101111 + !byte $93,%00110010 + !byte $3D,%11000001 + !byte $5F,%11001001 + !byte $13,%11110001 + !byte $99,%00101010 + !byte $99,%01110000 + !byte $99,%10010001; + !byte $3B,%10100001 + !byte $65,%01101010 + !byte $65,%10001011; + !byte $59,%00001000 + !byte $6F,%01001100 + !byte $89,%10101011 + !byte $A5,%00001110 + !byte $49,%00100100 + !byte $53,%01000110 + !byte $A3,%11101001 + !byte $A9,%10101101 + !byte $03,%01010010 + !byte $09,%00110010 + !byte $1D,%10110001 + !byte $31,%00010000 + !byte $79,%00001100 + !byte $B7,%01001000 + !byte $B5,%00101010 + !byte $27,%01010000 + !byte $A7,%11001001 + !byte $AD,%10101001 + !byte $A3,%01001110 + !byte $91,%01110010 + !byte $91,%10010011; + !byte $69,%11101011 + !byte $47,%11100011 + !byte $BB,%01101000 + !byte $BB,%10001001; + !byte $B9,%11001001 + !byte $AF,%11101011 + !byte $9D,%00010000 + !byte $4D,%10100101 + !byte $5D,%01101000 + !byte $5D,%10001001; + !byte $63,%00101010 + !byte $93,%01001010 + !byte $9D,%00001010 + !byte $83,%11001011 + !byte $B1,%01101000 + !byte $B1,%10001001; + !byte $97,%11010001 + !byte $0D,%00010010 + !byte $8D,%01101010 + !byte $8D,%10001011; + !byte $57,%11000111 + !byte $73,%00101100 + !byte $7D,%11101011 + !byte $97,%00101010 + !byte $BB,%00101000 + !byte $BD,%00101000 + !byte $17,%11010001 + !byte $A1,%11101001 + !byte $A1,%10101111 + !byte $95,%00010010 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $41,%00100010 + !byte $4B,%01000100 + !byte $51,%00000110 + !byte $6D,%01001100 + !byte $11,%11110001 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $35,%11101111 + !byte $AD,%00101100 + !byte $A7,%11101101 + !byte $07,%00110010 + !byte $2B,%00110000 + !byte $61,%11101001 + !byte $67,%10101011 + !byte $45,%10100011 + !byte $1B,%10110001 + !byte $87,%10101011 + !byte $91,%01001010 + !byte $B5,%01001000 + !byte $B3,%01101010 + !byte $B3,%10001011; + !byte $9B,%01010000 + !byte $8F,%11010011 + !byte $AB,%10101001 + !byte $A5,%00101110 + !byte $3F,%11100001 + !byte $5B,%00101000 + !byte $4F,%11000101 + !byte $77,%00001100 + !byte $9B,%00001010 + !byte $25,%01010000 + !byte $2F,%00010000 + !byte $B1,%11001011 + !byte $55,%01100110 + !byte $55,%10000111; + !byte $01,%01010010 + !byte $15,%11010001 + !byte $81,%11001011 + !byte $AB,%01101100 + !byte $AB,%10001101; + !byte $99,%10110001 + !byte $39,%11001111 + !byte $8B,%01101010 + !byte $8B,%10001011; + !byte $3D,%10100001 + !byte $6B,%00001100 + !byte $0B,%00010010 + !byte $B7,%00001010 + !byte $9F,%11101111 + !byte $93,%01010010 + !byte $65,%01001010 + !byte $95,%00101010 + !byte $49,%00000100 + !byte $43,%01000010 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $7B,%11101011 + !byte $B9,%00101000 + !byte $BB,%10101001 + !byte $59,%11100111 + !byte $71,%00101100 + !byte $A5,%11001001 + !byte $A3,%01101110 + !byte $A3,%10001111; + !byte $53,%00100110 + !byte $5F,%10101001 + !byte $29,%00110000 + !byte $BD,%01001000 + !byte $47,%11000011 + !byte $AF,%01101000 + !byte $AF,%10001001; + !byte $B5,%01001010 + !byte $AF,%00001100 + !byte $A9,%11001101 + !byte $9D,%00110000 + !byte $97,%11110001 + !byte $3B,%01000000 + !byte $41,%00000010 + !byte $69,%11001011 + !byte $05,%00110010 + !byte $33,%11101111 + !byte $8F,%01001010 + !byte $91,%10110011 + !byte $63,%00001010 + !byte $19,%10110001 + !byte $85,%10101011 + !byte $9F,%11101001 + !byte $BF,%00001000 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $57,%10100111 + !byte $A9,%10101001 + !byte $B3,%10101011 + !byte $0F,%11110001 + !byte $99,%00001010 + !byte $BF,%00101000 + !byte $B9,%11101001 + !byte $5D,%01001000 + !byte $51,%11100101 + !byte $23,%01010000 + !byte $37,%11001111 + !byte $75,%00001100 + !byte $7F,%11001011 + !byte $A3,%11001001 + !byte $AD,%01001100 + !byte $95,%00110010 + !byte $6D,%00101100 + !byte $3F,%11000001 + !byte $2D,%00010000 + !byte $89,%01101010 + !byte $89,%10001011; + !byte $A7,%00001110 + !byte $45,%01100010 + !byte $45,%10000011; + !byte $4B,%00100100 + !byte $67,%01101010 + !byte $67,%10001011; + !byte $9B,%01110000 + !byte $9B,%10010001; + !byte $8F,%11110011 + !byte $5B,%00001000 + !byte $61,%11001001 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $27,%00110000 + !byte $A1,%11001111 + !byte $09,%00010010 + !byte $13,%11010001 + !byte $6F,%00101100 + !byte $93,%00101010 + !byte $9D,%11101001 + !byte $AD,%01101000 + !byte $AD,%10001001; + !byte $B3,%01001000 + !byte $A5,%01001110 + !byte $39,%10101111 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $39,%01001110 + !byte $39,%00101110 + !byte $39,%00001110 + !byte $39,%11101101 + !byte $39,%11001101 + !byte $39,%10101101 + !byte $39,%01001100 + !byte $39,%00101100 + !byte $39,%11101011 + !byte $39,%11001011 + !byte $39,%10101011 + !byte $39,%01001010 + !byte $39,%00101010 + !byte $39,%00001010 + !byte $39,%11101001 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $39,%01001000 + !byte $39,%00101000 + !byte $39,%00001000 + !byte $39,%11000111 + !byte $39,%10100111 + !byte $39,%00000110 + !byte $39,%11100101 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $55,%01000110 + !byte $31,%11101111 + !byte $A7,%10101001 + !byte $B7,%00101010 + !byte $39,%01000110 + !byte $39,%00100100 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $39,%00100010 + !byte $39,%11100001 + !byte $39,%10100001 + !byte $4F,%10100101 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $39,%00001100 + !byte $39,%11001001 + !byte $39,%11100111 + !byte $39,%11000101 + !byte $39,%01000010 + !byte $6B,%11101011 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $39,%00000100 + !byte $39,%11000011 + !byte $49,%11100011 + !byte $65,%00101010 + !byte $03,%00110010 + !byte $79,%11101011 + !byte $83,%10101011 + !byte $BD,%01101000 + !byte $BD,%10001001; + !byte $BB,%11001001 + !byte $B1,%11101011 + !byte $9F,%00010000 + !byte $93,%01110010 + !byte $93,%10010011; + !byte $39,%10101001 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $39,%00100110 + !byte $39,%10100101 + !byte $39,%11100011 + !byte $BD,%00001000 + !byte $39,%01000100 + !byte $39,%10100011 + !byte $39,%00000010 + !byte $39,%11000001 + !byte $39,%01100000 + !byte $39,%10000001; + !byte $39,%01000000 + !byte $0D,%11110001 + !byte $73,%00001100 + !byte $AB,%10101101 + !byte $99,%11010001 + !byte $43,%00100010 + !byte $59,%11000111 + !byte $53,%00000110 + !byte $17,%10110001 + !byte $21,%01010000 + !byte $A1,%11001001 + !byte $A9,%11101101 + !byte $39,%00100000 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $2B,%00010000 + !byte $7D,%11001011 + !byte $8D,%01001010 + !byte $97,%00001010 + !byte $B1,%01001000 + !byte $A3,%10101111 + !byte $39,%00000000 + !byte $5F,%01101000 + !byte $5F,%10001001; + !byte $4D,%01000100 + !byte $11,%11010001 + !byte $AF,%00101100 + !byte $3B,%00100000 + !byte $07,%00010010 + !byte $B7,%00101000 + !byte $97,%00010010 + !byte $47,%10100011 + !byte $35,%11001111 + !byte $AB,%01101000 + !byte $AB,%10001001; + !byte $B5,%01101010 + !byte $B5,%10001011; + !byte $9D,%01010000 + !byte $41,%11100001 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $87,%01101010 + !byte $87,%10001011; + !byte $91,%00101010 + !byte $91,%11010011 + !byte $69,%10101011 + !byte $63,%11101001 + !byte $AD,%01101100 + !byte $AD,%10001101; + !byte $77,%11101011 + !byte $B3,%11001011 + !byte $5D,%00101000 + !byte $25,%00110000 + !byte $2F,%11101111 + !byte $3F,%10100001 + !byte $51,%11000101 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $81,%10101011 + !byte $9B,%11101001 + !byte $A5,%10101001 + !byte $BB,%00001000 + !byte $6D,%00001100 + !byte $67,%01001010 + !byte $0B,%11110001 + !byte $B9,%00001010 + !byte $A7,%00101110 + !byte $A1,%11101111 + !byte $9B,%10110001 + !byte $1F,%01010000 + !byte $71,%00001100 + !byte $B5,%00101000 + !byte $45,%01000010 + !byte $4B,%00000100 + !byte $61,%10101001 + !byte $5B,%11100111 + !byte $01,%00110010 + !byte $15,%10110001 + !byte $95,%01010010 + !byte $8B,%01001010 + !byte $AF,%01001000 + !byte $BF,%11100111 + !byte $B1,%00001100 + !byte $A5,%01101110 + !byte $A5,%10001111; + !byte $6B,%11001011 + !byte $05,%00010010 + !byte $29,%00010000 + !byte $7B,%11001011 + !byte $A9,%01101000 + !byte $A9,%10001001; + !byte $BF,%01001000 + !byte $BD,%10101001 + !byte $55,%00100110 + !byte $95,%00001010 + !byte $9F,%11001001 + !byte $B7,%01001010 + !byte $AB,%11001101 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $33,%11001111 + !byte $85,%01101010 + !byte $85,%10001011; + !byte $49,%11000011 + !byte $8F,%00101010 + !byte $9F,%00110000 + !byte $99,%11110001 + !byte $93,%10110011 + !byte $43,%00000010 + !byte $65,%00001010 + !byte $75,%11101011 + !byte $99,%11101001 + !byte $B5,%10101011 + !byte $0F,%11010001 + !byte $B9,%00001000 + !byte $BB,%11101001 + !byte $AF,%01001100 + !byte $3D,%01000000 + !byte $19,%01110000 + !byte $19,%10010001; + !byte $23,%00110000 + !byte $A3,%10101001 + !byte $53,%11100101 + !byte $09,%11110001 + !byte $2D,%11101111 + !byte $AD,%01001000 + !byte $B3,%00101000 + !byte $59,%10100111 + !byte $5F,%01001000 + !byte $63,%11001001 + !byte $69,%01101010 + !byte $69,%10001011; + !byte $37,%10101111 + !byte $93,%00001010 + !byte $A9,%00001110 + !byte $4D,%00100100 + !byte $7F,%10101011 + !byte $89,%01001010 + !byte $9D,%01110000 + !byte $9D,%10010001; + !byte $97,%00110010 + !byte $91,%11110011 + !byte $41,%11000001 + !byte $A3,%11001111 + !byte $47,%01100010 + !byte $47,%10000011; + !byte $57,%01000110 + !byte $1D,%01010000 + !byte $6F,%00001100 + !byte $BD,%11100111 + !byte $5D,%00001000 + !byte $3B,%00000000 + !byte $45,%00100010 + !byte $13,%10110001 + !byte $79,%11001011 + !byte $B9,%00101010 + !byte $B3,%11101011 + !byte $27,%00010000 + !byte $4B,%11100011 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $31,%11001111 + !byte $BD,%11001001 + !byte $A1,%00010000 + !byte $83,%01101010 + !byte $83,%10001011; + !byte $8D,%00101010 + !byte $9D,%11001001 + !byte $B7,%00001000 + !byte $9B,%11010001 + !byte $51,%10100101 + !byte $6D,%11101011 + !byte $03,%00010010 + !byte $0D,%11010001 + !byte $BF,%01101000 + !byte $BF,%10001001; + !byte $AD,%10101101 + !byte $A7,%01001110 + !byte $55,%00000110 + !byte $67,%00101010 + !byte $A7,%01101000 + !byte $A7,%10001001; + !byte $B1,%00101000 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $4F,%01000100 + !byte $2B,%11101111 + !byte $73,%11101011 + !byte $7D,%10101011 + !byte $97,%11101001 + !byte $AB,%11101101 + !byte $95,%01110010 + !byte $95,%10010011; + !byte $61,%01101000 + !byte $61,%10001001; + !byte $37,%01101110 + !byte $37,%10001111; + !byte $37,%01001110 + !byte $37,%00101110 + !byte $37,%00001110 + !byte $37,%11101101 + !byte $37,%11001101 + !byte $37,%10101101 + !byte $37,%01101100 + !byte $37,%10001101; + !byte $37,%00101100 + !byte $37,%11101011 + !byte $37,%11001011 + !byte $37,%10101011 + !byte $37,%11101001 + !byte $37,%11001001 + !byte $37,%00101000 + !byte $37,%00001000 + !byte $37,%11100111 + !byte $37,%11100101 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $37,%00000100 + !byte $37,%00100000 + !byte $43,%11100001 + !byte $07,%11110001 + !byte $11,%10110001 + !byte $21,%00110000 + !byte $87,%01001010 + !byte $AB,%01001000 + !byte $B1,%00101100 + !byte $99,%00010010 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $37,%00101010 + !byte $37,%00001010 + !byte $37,%10101001 + !byte $37,%01000110 + !byte $37,%00100110 + !byte $37,%11000011 + !byte $5B,%11000111 + !byte $65,%11101001 + !byte $6B,%10101011 + !byte $35,%10101111 + !byte $A1,%10101001 + !byte $93,%11010011 + !byte $37,%01001010 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $37,%11000111 + !byte $37,%10100111 + !byte $37,%01000100 + !byte $37,%11100001 + !byte $37,%10100001 + !byte $49,%10100011 + !byte $37,%01001100 + !byte $37,%00001100 + !byte $37,%00000110 + !byte $37,%10100011 + !byte $37,%01000010 + !byte $37,%00000010 + !byte $37,%11000001 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $3D,%00100000 + !byte $91,%00001010 + !byte $B7,%01101010 + !byte $B7,%10001011; + !byte $9F,%01010000 + !byte $37,%01001000 + !byte $37,%01100110 + !byte $37,%10000111; + !byte $37,%10100101 + !byte $37,%00100100 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $37,%00000000 + !byte $25,%00010000 + !byte $9B,%11001001 + !byte $BB,%11100111 + !byte $B5,%11001011 + !byte $37,%11000101 + !byte $37,%11100011 + !byte $77,%11001011 + !byte $AF,%01101100 + !byte $AF,%10001101; + !byte $A5,%10101111 + !byte $37,%00100010 + !byte $37,%01000000 + !byte $01,%00010010 + !byte $1B,%01010000 + !byte $B5,%00001000 + !byte $59,%01100110 + !byte $59,%10000111; + !byte $5F,%00101000 + !byte $2F,%11001111 + !byte $81,%01101010 + !byte $81,%10001011; + !byte $97,%01010010 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $AF,%00101000 + !byte $53,%11000101 + !byte $8B,%00101010 + !byte $A5,%01101000 + !byte $A5,%10001001; + !byte $BB,%00001010 + !byte $A9,%00101110 + !byte $A3,%11101111 + !byte $69,%01001010 + !byte $95,%11101001 + !byte $BF,%11000111 + !byte $4D,%00000100 + !byte $5D,%11100111 + !byte $63,%10101001 + !byte $0B,%11010001 + !byte $71,%11101011 + !byte $7B,%10101011 + !byte $9D,%10110001 + !byte $29,%11101111 + !byte $B3,%00001100 + !byte $A7,%01101110 + !byte $A7,%10001111; + !byte $47,%01000010 + !byte $51,%01100100 + !byte $51,%10000101; + !byte $1F,%00110000 + !byte $9F,%10101001 + !byte $BF,%10101001 + !byte $41,%10100001 + !byte $33,%10101111 + !byte $B9,%11100111 + !byte $B9,%01001010 + !byte $AD,%11001101 + !byte $57,%00100110 + !byte $6D,%11001011 + !byte $05,%11110001 + !byte $19,%01010000 + !byte $8F,%00001010 + !byte $9B,%11110001 + !byte $4B,%11000011 + !byte $85,%01001010 + !byte $A1,%00110000 + !byte $67,%00001010 + !byte $23,%00010000 + !byte $75,%11001011 + !byte $B7,%10101011 + !byte $95,%10110011 + !byte $0F,%10110001 + !byte $A9,%01001000 + !byte $B3,%00001000 + !byte $BD,%11101001 + !byte $B1,%01001100 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $2D,%11001111 + !byte $3F,%01000000 + !byte $43,%11000001 + !byte $4F,%00100100 + !byte $5B,%10100111 + !byte $09,%11010001 + !byte $7F,%01101010 + !byte $7F,%10001011; + !byte $99,%11001001 + !byte $45,%00000010 + !byte $55,%11100101 + !byte $61,%01001000 + !byte $89,%00101010 + !byte $AD,%00101000 + !byte $AB,%00001110 + !byte $9F,%01110000 + !byte $9F,%10010001; + !byte $3D,%00000000 + !byte $BD,%11000111 + !byte $6B,%01101010 + !byte $6B,%10001011; + !byte $13,%01110000 + !byte $13,%10010001; + !byte $27,%11101111 + !byte $6F,%11101011 + !byte $79,%10101011 + !byte $A5,%11001111 + !byte $99,%00110010 + !byte $93,%11110011 + !byte $65,%11001001 + !byte $93,%11101001 + !byte $A3,%01101000 + !byte $A3,%10001001; + !byte $59,%01000110 + !byte $1D,%00110000 + !byte $BB,%00101010 + !byte $B5,%11101011 + !byte $9D,%11010001 + !byte $03,%11110001 + !byte $31,%10101111 + !byte $9D,%10101001 + !byte $A7,%01001000 + !byte $B7,%11100111 + !byte $5F,%00001000 + !byte $4D,%11100011 + !byte $53,%10100101 + !byte $69,%00101010 + !byte $0D,%10110001 + !byte $83,%01001010 + !byte $8D,%00001010 + !byte $A3,%00010000 + !byte $97,%01110010 + !byte $97,%10010011; + !byte $B1,%00001000 + !byte $47,%00100010 + !byte $17,%01010000 + !byte $21,%00010000 + !byte $BF,%11001001 + !byte $AF,%10101101 + !byte $73,%11001011 + !byte $63,%01101000 + !byte $63,%10001001; + !byte $5D,%11000111 + !byte $07,%11010001 + !byte $AD,%11101101 + !byte $A9,%01001110 + !byte $2B,%11001111 + !byte $35,%01101110 + !byte $35,%10001111; + !byte $7D,%01101010 + !byte $7D,%10001011; + !byte $A1,%01101000 + !byte $A1,%10001001; + !byte $A7,%10101111 + !byte $A1,%01010000 + !byte $57,%00000110 + !byte $6D,%10101011 + !byte $B3,%00101100 + !byte $97,%11001001 + !byte $BB,%11000111 + !byte $41,%01100000 + !byte $41,%10000001; + !byte $11,%01110000 + !byte $11,%10010001; + !byte $1B,%00110000 + !byte $77,%10101011 + !byte $9B,%10101001 + !byte $B9,%01101010 + !byte $B9,%10001011; + !byte $51,%01000100 + !byte $87,%00101010 + !byte $91,%11101001 + !byte $B5,%11100111 + !byte $4B,%10100011 + !byte $67,%11101001 + !byte $45,%11100001 + !byte $25,%11101111 + !byte $A5,%01001000 + !byte $B1,%01101100 + !byte $B1,%10001101; + !byte $9B,%00010010 + !byte $95,%11010011 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $61,%00101000 + !byte $2F,%10101111 + !byte $AB,%00101000 + !byte $3F,%00100000 + !byte $55,%11000101 + !byte $49,%01000010 + !byte $01,%11110001 + !byte $81,%01001010 + !byte $BF,%10100111 + !byte $9F,%10110001 + !byte $4F,%00000100 + !byte $35,%01001110 + !byte $35,%00101110 + !byte $35,%00001110 + !byte $35,%11101101 + !byte $35,%11001101 + !byte $35,%10101101 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $35,%01001100 + !byte $35,%11101011 + !byte $35,%11001011 + !byte $35,%01101010 + !byte $35,%10001011; + !byte $35,%00101010 + !byte $35,%10101001 + !byte $35,%11100101 + !byte $35,%01000100 + !byte $35,%11100011 + !byte $35,%01000000 + !byte $65,%10101001 + !byte $6B,%01001010 + !byte $1F,%00010000 + !byte $71,%11001011 + !byte $95,%11001001 + !byte $AF,%00001000 + !byte $AB,%00101110 + !byte $35,%00101100 + !byte $35,%11101001 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $35,%01001000 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $35,%10100101 + !byte $35,%00000100 + !byte $35,%01000010 + !byte $15,%01010000 + !byte $35,%10101011 + !byte $35,%11001001 + !byte $35,%00101000 + !byte $35,%11100111 + !byte $35,%00100100 + !byte $35,%00001100 + !byte $35,%00001010 + !byte $35,%00100110 + !byte $35,%00000110 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $35,%10100011 + !byte $35,%00100010 + !byte $35,%11100001 + !byte $35,%10100001 + !byte $35,%00000000 + !byte $0B,%10110001 + !byte $29,%11001111 + !byte $BD,%00001010 + !byte $A5,%11101111 + !byte $99,%01010010 + !byte $35,%01001010 + !byte $35,%00001000 + !byte $35,%11000111 + !byte $35,%10100111 + !byte $35,%01000110 + !byte $35,%00000010 + !byte $35,%00100000 + !byte $8B,%00001010 + !byte $B9,%11000111 + !byte $B5,%00001100 + !byte $35,%11000101 + !byte $35,%01100010 + !byte $35,%10000011; + !byte $43,%10100001 + !byte $33,%01101110 + !byte $33,%10001111; + !byte $B7,%11001011 + !byte $A3,%00110000 + !byte $35,%11000011 + !byte $35,%11000001 + !byte $35,%01100000 + !byte $35,%10000001; + !byte $7B,%01101010 + !byte $7B,%10001011; + !byte $85,%00101010 + !byte $A9,%00101000 + !byte $BB,%01001010 + !byte $AF,%11001101 + !byte $5F,%11100111 + !byte $19,%00110000 + !byte $97,%10110011 + !byte $4D,%11000011 + !byte $59,%00100110 + !byte $6F,%11001011 + !byte $9F,%01101000 + !byte $9F,%10001001; + !byte $B3,%11100111 + !byte $57,%11100101 + !byte $99,%10101001 + !byte $B9,%10101011 + !byte $9D,%11110001 + !byte $47,%00000010 + !byte $53,%01100100 + !byte $53,%10000101; + !byte $69,%00001010 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $23,%11101111 + !byte $75,%10101011 + !byte $8F,%11101001 + !byte $B3,%01001100 + !byte $41,%01000000 + !byte $5D,%10100111 + !byte $05,%11010001 + !byte $7F,%01001010 + !byte $A9,%01101110 + !byte $A9,%10001111; + !byte $2D,%10101111 + !byte $A3,%01001000 + !byte $BD,%10100111 + !byte $BF,%11101001 + !byte $63,%01001000 + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $1D,%00010000 + !byte $AD,%00001110 + !byte $67,%11001001 + !byte $09,%10110001 + !byte $89,%00001010 + !byte $9B,%00110010 + !byte $3F,%00000000 + !byte $13,%01010000 + !byte $93,%11001001 + !byte $A1,%01110000 + !byte $A1,%10010001; + !byte $95,%11110011 + !byte $61,%00001000 + !byte $6D,%01101010 + !byte $6D,%10001011; + !byte $B7,%11000111 + !byte $51,%00100100 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $31,%01101110 + !byte $31,%10001111; + !byte $9D,%01101000 + !byte $9D,%10001001; + !byte $BD,%00101010 + !byte $A7,%11001111 + !byte $45,%11000001 + !byte $03,%11010001 + !byte $27,%11001111 + !byte $79,%01101010 + !byte $79,%10001011; + !byte $AD,%00001000 + !byte $4F,%11100011 + !byte $A7,%00101000 + !byte $B7,%11101011 + !byte $6B,%00101010 + !byte $17,%00110000 + !byte $83,%00101010 + !byte $99,%01110010 + !byte $99,%10010011; + !byte $49,%00100010 + !byte $5B,%01000110 + !byte $2B,%10101111 + !byte $B1,%11100111 + !byte $B1,%10101101 + !byte $A5,%00010000 + !byte $9F,%11010001 + !byte $55,%10100101 + !byte $21,%11101111 + !byte $73,%10101011 + !byte $8D,%11101001 + !byte $97,%10101001 + !byte $65,%01101000 + !byte $65,%10001001; + !byte $7D,%01001010 + !byte $A1,%01001000 + !byte $AF,%11101101 + !byte $AB,%01001110 + !byte $53,%01000100 + !byte $BB,%10100111 + !byte $B5,%00101100 + !byte $43,%01100000 + !byte $43,%10000001; + !byte $59,%00000110 + !byte $87,%00001010 + !byte $91,%11001001 + !byte $A9,%10101111 + !byte $A3,%01010000 + !byte $5F,%11000111 + !byte $69,%11101001 + !byte $07,%10110001 + !byte $11,%01010000 + !byte $1B,%00010000 + !byte $97,%11010011 + !byte $63,%00101000 + !byte $AB,%00001000 + !byte $B5,%11000111 + !byte $9D,%00010010 + !byte $4D,%10100011 + !byte $6F,%10101011 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $01,%11010001 + !byte $25,%11001111 + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $BB,%01101010 + !byte $BB,%10001011; + !byte $B3,%01101100 + !byte $B3,%10001101; + !byte $41,%00100000 + !byte $77,%01101010 + !byte $77,%10001011; + !byte $81,%00101010 + !byte $9B,%01101000 + !byte $9B,%10001001; + !byte $BF,%01100110 + !byte $BF,%10000111; + !byte $B9,%11001011 + !byte $47,%11100001 + !byte $AF,%11100111 + !byte $57,%11000101 + !byte $8B,%11101001 + !byte $51,%00000100 + !byte $71,%10101011 + !byte $9B,%01010010 + !byte $4B,%01000010 + !byte $6D,%01001010 + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $15,%00110000 + !byte $1F,%11101111 + !byte $A5,%00101000 + !byte $A1,%10110001 + !byte $67,%10101001 + !byte $BF,%00001010 + !byte $AD,%00101110 + !byte $A7,%11101111 + !byte $61,%11100111 + !byte $05,%10110001 + !byte $29,%10101111 + !byte $7B,%01001010 + !byte $95,%10101001 + !byte $A9,%00001000 + !byte $B9,%10100111 + !byte $49,%00000010 + !byte $85,%00001010 + !byte $55,%01100100 + !byte $55,%10000101; + !byte $33,%01001110 + !byte $8F,%11001001 + !byte $9F,%01001000 + !byte $BD,%01001010 + !byte $B7,%00001100 + !byte $B1,%11001101 + !byte $AB,%01101110 + !byte $AB,%10001111; + !byte $45,%10100001 + !byte $5B,%00100110 + !byte $23,%11001111 + !byte $99,%01101000 + !byte $99,%10001001; + !byte $A5,%00110000 + !byte $4F,%11000011 + !byte $0F,%01010000 + !byte $19,%00010000 + !byte $9F,%11110001 + !byte $33,%00101110 + !byte $33,%00001110 + !byte $33,%11101101 + !byte $33,%11001101 + !byte $33,%10101101 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $33,%01001100 + !byte $33,%00101100 + !byte $33,%00001100 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $33,%01001010 + !byte $33,%00101010 + !byte $33,%00001010 + !byte $33,%10101001 + !byte $33,%11000101 + !byte $33,%00100100 + !byte $33,%11000011 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $33,%00000010 + !byte $6B,%00001010 + !byte $B3,%11000111 + !byte $33,%11001011 + !byte $33,%10101011 + !byte $33,%11101001 + !byte $33,%01101000 + !byte $33,%10001001; + !byte $33,%01001000 + !byte $33,%00101000 + !byte $33,%00001000 + !byte $33,%10100111 + !byte $33,%00100110 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $33,%10100011 + !byte $33,%11100001 + !byte $33,%00000000 + !byte $59,%11100101 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $75,%01101010 + !byte $75,%10001011; + !byte $A3,%00101000 + !byte $BD,%01100110 + !byte $BD,%10000111; + !byte $99,%10110011 + !byte $33,%11101011 + !byte $33,%11100111 + !byte $33,%00000110 + !byte $33,%11100101 + !byte $33,%01000100 + !byte $33,%11100011 + !byte $33,%11000001 + !byte $33,%01100000 + !byte $33,%10000001; + !byte $33,%00100000 + !byte $09,%01110000 + !byte $09,%10010001; + !byte $BB,%10101011 + !byte $33,%11001001 + !byte $33,%11000111 + !byte $33,%01100110 + !byte $33,%10000111; + !byte $33,%01000110 + !byte $33,%10100101 + !byte $33,%00000100 + !byte $33,%00100010 + !byte $33,%10100001 + !byte $33,%01000000 + !byte $7F,%00101010 + !byte $89,%11101001 + !byte $B5,%01001100 + !byte $A9,%11001111 + !byte $33,%01000010 + !byte $43,%01000000 + !byte $5F,%10100111 + !byte $65,%01001000 + !byte $13,%00110000 + !byte $AF,%00001110 + !byte $1D,%11101111 + !byte $B7,%10100111 + !byte $53,%00100100 + !byte $6F,%01101010 + !byte $6F,%10001011; + !byte $47,%11000001 + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $03,%10110001 + !byte $27,%10101111 + !byte $9D,%01001000 + !byte $9D,%00110010 + !byte $97,%11110011 + !byte $79,%01001010 + !byte $AD,%11100111 + !byte $69,%11001001 + !byte $5D,%01000110 + !byte $0D,%01010000 + !byte $A3,%01110000 + !byte $A3,%10010001; + !byte $57,%10100101 + !byte $63,%00001000 + !byte $31,%01001110 + !byte $83,%00001010 + !byte $8D,%11001001 + !byte $93,%10101001 + !byte $AD,%01001110 + !byte $41,%00000000 + !byte $51,%11100011 + !byte $B1,%11000111 + !byte $BF,%00101010 + !byte $B9,%11101011 + !byte $17,%00010000 + !byte $6D,%00101010 + !byte $73,%01101010 + !byte $73,%10001011; + !byte $97,%01101000 + !byte $97,%10001001; + !byte $9B,%01110010 + !byte $9B,%10010011; + !byte $BB,%01100110 + !byte $BB,%10000111; + !byte $67,%01101000 + !byte $67,%10001001; + !byte $45,%01100000 + !byte $45,%10000001; + !byte $21,%11001111 + !byte $7D,%00101010 + !byte $87,%11101001 + !byte $B3,%10101101 + !byte $A7,%00010000 + !byte $A1,%11010001 + !byte $61,%11000111 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $A7,%00001000 + !byte $4B,%00100010 + !byte $5B,%00000110 + !byte $91,%10101001 + !byte $B1,%11101101 + !byte $1B,%11101111 + !byte $A1,%00101000 + !byte $AB,%11100111 + !byte $AB,%10101111 + !byte $11,%00110000 + !byte $B7,%00101100 + !byte $9F,%00010010 + !byte $49,%11100001 + !byte $6B,%11101001 + !byte $9B,%01001000 + !byte $A5,%01010000 + !byte $55,%01000100 + !byte $07,%01110000 + !byte $07,%10010001; + !byte $77,%01001010 + !byte $81,%00001010 + !byte $B5,%10100111 + !byte $BD,%01101010 + !byte $BD,%10001011; + !byte $65,%00101000 + !byte $25,%10101111 + !byte $2F,%01001110 + !byte $BF,%01000110 + !byte $99,%11010011 + !byte $4F,%10100011 + !byte $43,%00100000 + !byte $8B,%11001001 + !byte $B5,%01101100 + !byte $B5,%10001101; + !byte $0B,%01010000 + !byte $A5,%00001000 + !byte $BB,%11001011 + !byte $A9,%11101111 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $53,%00000100 + !byte $71,%01101010 + !byte $71,%10001011; + !byte $A3,%10110001 + !byte $7B,%00101010 + !byte $95,%01101000 + !byte $95,%10001001; + !byte $9F,%00101000 + !byte $B9,%01100110 + !byte $B9,%10000111; + !byte $59,%11000101 + !byte $6F,%01001010 + !byte $01,%10110001 + !byte $15,%00010000 + !byte $29,%01101110 + !byte $29,%10001111; + !byte $47,%10100001 + !byte $4D,%01000010 + !byte $69,%10101001 + !byte $1F,%11001111 + !byte $AF,%11000111 + !byte $8F,%10101001 + !byte $A9,%11100111 + !byte $AF,%00101110 + !byte $9D,%01010010 + !byte $63,%11100111 + !byte $05,%01110000 + !byte $05,%10010001; + !byte $19,%11101111 + !byte $85,%11101001 + !byte $B9,%00001100 + !byte $B3,%10100111 + !byte $A1,%11110001 + !byte $51,%11000011 + !byte $5D,%00100110 + !byte $0F,%00110000 + !byte $BF,%01001010 + !byte $B3,%11001101 + !byte $AD,%01101110 + !byte $AD,%10001111; + !byte $57,%01100100 + !byte $57,%10000101; + !byte $4B,%00000010 + !byte $6D,%00001010 + !byte $23,%10101111 + !byte $75,%01001010 + !byte $A7,%00110000 + !byte $7F,%00001010 + !byte $99,%01001000 + !byte $BD,%01000110 + !byte $09,%01010000 + !byte $89,%11001001 + !byte $A3,%00001000 + !byte $9B,%10110011 + !byte $45,%01000000 + !byte $61,%10100111 + !byte $2D,%01001110 + !byte $B7,%01001100 + !byte $55,%00100100 + !byte $67,%01001000 + !byte $5B,%11100101 + !byte $13,%00010000 + !byte $BD,%10101011 + !byte $1D,%11001111 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $AD,%11000111 + !byte $AB,%11001111 + !byte $A5,%01110000 + !byte $A5,%10010001; + !byte $9F,%00110010 + !byte $31,%00101110 + !byte $B1,%00001110 + !byte $99,%11110011 + !byte $79,%00101010 + !byte $93,%01101000 + !byte $93,%10001001; + !byte $49,%11000001 + !byte $6B,%11001001 + !byte $31,%00001110 + !byte $31,%11101101 + !byte $31,%11001101 + !byte $31,%10101101 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $31,%01001100 + !byte $31,%00101100 + !byte $31,%00001100 + !byte $31,%11101011 + !byte $31,%10101011 + !byte $31,%01001010 + !byte $31,%00001010 + !byte $31,%11101001 + !byte $31,%01001000 + !byte $31,%11100101 + !byte $31,%11000101 + !byte $31,%00100100 + !byte $31,%01000010 + !byte $31,%10100001 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $0D,%00110000 + !byte $83,%11101001 + !byte $B1,%10100111 + !byte $B7,%01100110 + !byte $B7,%10000111; + !byte $31,%01101010 + !byte $31,%10001011; + !byte $31,%11001001 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $31,%00101000 + !byte $31,%00001000 + !byte $31,%11100111 + !byte $31,%01000110 + !byte $31,%01000100 + !byte $31,%11100011 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $31,%00100000 + !byte $9D,%00101000 + !byte $31,%11001011 + !byte $31,%00101010 + !byte $31,%10101001 + !byte $31,%11000111 + !byte $31,%10100111 + !byte $31,%10100101 + !byte $31,%00100010 + !byte $31,%11000011 + !byte $31,%01000000 + !byte $31,%00000000 + !byte $65,%00001000 + !byte $03,%01110000 + !byte $03,%10010001; + !byte $21,%10101111 + !byte $8D,%10101001 + !byte $97,%01001000 + !byte $31,%01100110 + !byte $31,%10000111; + !byte $31,%00100110 + !byte $31,%00000110 + !byte $31,%01100100 + !byte $31,%10000101; + !byte $31,%01100010 + !byte $31,%10000011; + !byte $31,%11000001 + !byte $43,%00000000 + !byte $17,%11101111 + !byte $73,%01001010 + !byte $A7,%11100111 + !byte $AF,%01001110 + !byte $A9,%00010000 + !byte $31,%00000100 + !byte $31,%10100011 + !byte $31,%11100001 + !byte $59,%10100101 + !byte $5F,%01000110 + !byte $31,%00000010 + !byte $6F,%00101010 + !byte $2B,%01001110 + !byte $BB,%11101011 + !byte $BB,%01000110 + !byte $A3,%11010001 + !byte $9D,%01110010 + !byte $9D,%10010011; + !byte $63,%11000111 + !byte $69,%01101000 + !byte $69,%10001001; + !byte $B5,%10101101 + !byte $53,%11100011 + !byte $07,%01010000 + !byte $7D,%00001010 + !byte $A1,%00001000 + !byte $47,%01100000 + !byte $47,%10000001; + !byte $57,%01000100 + !byte $11,%00010000 + !byte $B3,%11101101 + !byte $87,%11001001 + !byte $4D,%00100010 + !byte $25,%01101110 + !byte $25,%10001111; + !byte $2F,%00101110 + !byte $9B,%00101000 + !byte $AB,%11000111 + !byte $B5,%01100110 + !byte $B5,%10000111; + !byte $B9,%00101100 + !byte $A7,%01010000 + !byte $5D,%00000110 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $1B,%11001111 + !byte $77,%00101010 + !byte $91,%01101000 + !byte $91,%10001001; + !byte $AD,%10101111 + !byte $A1,%00010010 + !byte $9B,%11010011 + !byte $8B,%10101001 + !byte $6D,%11101001 + !byte $0B,%00110000 + !byte $A5,%11100111 + !byte $BF,%00100110 + !byte $51,%10100011 + !byte $55,%00000100 + !byte $5B,%11000101 + !byte $4B,%11100001 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $67,%00101000 + !byte $81,%11101001 + !byte $BD,%11001011 + !byte $B1,%00101110 + !byte $45,%00100000 + !byte $49,%10100001 + !byte $71,%01001010 + !byte $95,%01001000 + !byte $BF,%01101010 + !byte $BF,%10001011; + !byte $B7,%01101100 + !byte $B7,%10001101; + !byte $9F,%01010010 + !byte $AF,%10100111 + !byte $B9,%01000110 + !byte $AB,%11101111 + !byte $05,%01010000 + !byte $15,%11101111 + !byte $1F,%10101111 + !byte $29,%01001110 + !byte $7B,%00001010 + !byte $9F,%00001000 + !byte $A9,%11000111 + !byte $6B,%10101001 + !byte $65,%11100111 + !byte $B3,%01100110 + !byte $B3,%10000111; + !byte $A5,%10110001 + !byte $4F,%01000010 + !byte $0F,%00010000 + !byte $85,%11001001 + !byte $5F,%00100110 + !byte $59,%01100100 + !byte $59,%10000101; + !byte $53,%11000011 + !byte $19,%11001111 + !byte $75,%00101010 + !byte $8F,%01101000 + !byte $8F,%10001001; + !byte $99,%00101000 + !byte $BB,%00001100 + !byte $4D,%00000010 + !byte $2D,%00101110 + !byte $9D,%10110011 + !byte $6F,%00001010 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $BD,%00100110 + !byte $B5,%11001101 + !byte $AF,%01101110 + !byte $AF,%10001111; + !byte $47,%01000000 + !byte $63,%10100111 + !byte $7F,%11101001 + !byte $A9,%00110000 + !byte $A3,%11110001 + !byte $69,%01001000 + !byte $AD,%10100111 + !byte $57,%00100100 + !byte $09,%00110000 + !byte $13,%11101111 + !byte $AD,%11001111 + !byte $A7,%01110000 + !byte $A7,%10010001; + !byte $5D,%11100101 + !byte $79,%00001010 + !byte $89,%10101001 + !byte $93,%01001000 + !byte $A3,%11100111 + !byte $B9,%01001100 + !byte $51,%01100010 + !byte $51,%10000011; + !byte $6D,%11001001 + !byte $B7,%01000110 + !byte $BF,%10101011 + !byte $A1,%00110010 + !byte $1D,%10101111 + !byte $27,%01001110 + !byte $9D,%00001000 + !byte $5B,%10100101 + !byte $67,%00001000 + !byte $83,%11001001 + !byte $B3,%00001110 + !byte $03,%01010000 + !byte $B7,%10101101 + !byte $9B,%11110011 + !byte $45,%00000000 + !byte $0D,%00010000 + !byte $61,%01000110 + !byte $73,%00101010 + !byte $A7,%11000111 + !byte $BB,%00100110 + !byte $4B,%11000001 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $A5,%11010001 + !byte $4F,%00100010 + !byte $71,%00101010 + !byte $17,%11001111 + !byte $2B,%00101110 + !byte $8D,%01101000 + !byte $8D,%10001001; + !byte $A1,%11100111 + !byte $B1,%01001110 + !byte $AB,%00010000 + !byte $6B,%01101000 + !byte $6B,%10001001; + !byte $BD,%11101011 + !byte $49,%01100000 + !byte $49,%10000001; + !byte $55,%11100011 + !byte $07,%00110000 + !byte $7D,%11101001 + !byte $97,%00101000 + !byte $B1,%01100110 + !byte $B1,%10000111; + !byte $65,%11000111 + !byte $2F,%00001110 + !byte $2F,%11101101 + !byte $2F,%11001101 + !byte $2F,%10101101 + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $2F,%01001100 + !byte $2F,%00101100 + !byte $2F,%00001100 + !byte $2F,%11001011 + !byte $2F,%01001010 + !byte $2F,%00001010 + !byte $2F,%11101001 + !byte $2F,%10101001 + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $2F,%11000101 + !byte $2F,%10100101 + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $2F,%00100010 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $2F,%00100000 + !byte $59,%01000100 + !byte $11,%11101111 + !byte $9B,%00001000 + !byte $AB,%10100111 + !byte $B5,%01000110 + !byte $AF,%10101111 + !byte $9F,%01110010 + !byte $9F,%10010011; + !byte $2F,%11101011 + !byte $2F,%00101010 + !byte $2F,%00101000 + !byte $2F,%00001000 + !byte $2F,%11100111 + !byte $2F,%00000110 + !byte $2F,%11000011 + !byte $2F,%11100001 + !byte $87,%10101001 + !byte $91,%01001000 + !byte $2F,%10101011 + !byte $2F,%10100111 + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $2F,%01000110 + !byte $2F,%01000100 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $2F,%00000010 + !byte $2F,%11000001 + !byte $5F,%00000110 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $2F,%01001000 + !byte $2F,%00000100 + !byte $2F,%10100011 + !byte $4D,%11100001 + !byte $01,%01010000 + !byte $25,%01001110 + !byte $B5,%11101101 + !byte $A3,%00010010 + !byte $2F,%11001001 + !byte $2F,%11000111 + !byte $2F,%00100110 + !byte $2F,%11100101 + !byte $2F,%00100100 + !byte $2F,%01000010 + !byte $2F,%10100001 + !byte $2F,%01000000 + !byte $2F,%00000000 + !byte $1B,%10101111 + !byte $77,%00001010 + !byte $BF,%00000110 + !byte $2F,%11100011 + !byte $BB,%00101100 + !byte $81,%11001001 + !byte $53,%10100011 + !byte $6F,%11101001 + !byte $69,%00101000 + !byte $0B,%00010000 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $95,%00101000 + !byte $A5,%11000111 + !byte $A9,%01010000 + !byte $9D,%11010011 + !byte $47,%00100000 + !byte $B9,%00100110 + !byte $51,%01000010 + !byte $63,%01100110 + !byte $63,%10000111; + !byte $7B,%11101001 + !byte $AD,%11101111 + !byte $5D,%11000101 + !byte $8B,%01101000 + !byte $8B,%10001001; + !byte $AF,%01100110 + !byte $AF,%10000111; + !byte $BF,%11001011 + !byte $B3,%00101110 + !byte $A1,%01010010 + !byte $4B,%10100001 + !byte $15,%11001111 + !byte $B9,%01101100 + !byte $B9,%10001101; + !byte $57,%00000100 + !byte $6D,%10101001 + !byte $0F,%11101111 + !byte $29,%00101110 + !byte $A7,%10110001 + !byte $67,%11100111 + !byte $85,%10101001 + !byte $BD,%00001100 + !byte $B7,%11001101 + !byte $05,%00110000 + !byte $B1,%01101110 + !byte $B1,%10001111; + !byte $55,%11000011 + !byte $61,%00100110 + !byte $19,%10101111 + !byte $2D,%00001110 + !byte $75,%00001010 + !byte $8F,%01001000 + !byte $9F,%11100111 + !byte $A9,%10100111 + !byte $BD,%00000110 + !byte $23,%01001110 + !byte $7F,%11001001 + !byte $99,%00001000 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $6B,%01001000 + !byte $AB,%00110000 + !byte $A5,%11110001 + !byte $71,%00001010 + !byte $89,%01101000 + !byte $89,%10001001; + !byte $AD,%01100110 + !byte $AD,%10000111; + !byte $B5,%00001110 + !byte $9F,%10110011 + !byte $49,%01000000 + !byte $4F,%00000010 + !byte $13,%11001111 + !byte $93,%00101000 + !byte $09,%00010000 + !byte $9D,%11100111 + !byte $A3,%11000111 + !byte $B3,%01000110 + !byte $53,%01100010 + !byte $53,%10000011; + !byte $5F,%11100101 + !byte $65,%10100111 + !byte $6F,%11001001 + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $27,%00101110 + !byte $79,%11101001 + !byte $83,%10101001 + !byte $B7,%00100110 + !byte $AF,%11001111 + !byte $BB,%01001100 + !byte $A3,%00110010 + !byte $9D,%11110011 + !byte $69,%00001000 + !byte $A9,%01110000 + !byte $A9,%10010001; + !byte $4D,%11000001 + !byte $59,%00100100 + !byte $03,%00110000 + !byte $A7,%10100111 + !byte $63,%01000110 + !byte $B3,%01001110 + !byte $5D,%10100101 + !byte $21,%01001110 + !byte $73,%00001010 + !byte $8D,%01001000 + !byte $BB,%00000110 + !byte $B9,%10101101 + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $07,%00010000 + !byte $0D,%11101111 + !byte $AD,%00010000 + !byte $57,%11100011 + !byte $17,%10101111 + !byte $2B,%00001110 + !byte $97,%00001000 + !byte $B1,%01000110 + !byte $A7,%11010001 + !byte $47,%00000000 + !byte $11,%11001111 + !byte $7D,%11001001 + !byte $A1,%11000111 + !byte $AB,%01100110 + !byte $AB,%10000111; + !byte $A1,%01110010 + !byte $A1,%10010011; + !byte $51,%00100010 + !byte $87,%01101000 + !byte $87,%10001001; + !byte $6D,%01101000 + !byte $6D,%10001001; + !byte $B5,%00100110 + !byte $BF,%11101011 + !byte $25,%00101110 + !byte $61,%00000110 + !byte $91,%00101000 + !byte $5B,%01000100 + !byte $67,%11000111 + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $77,%11101001 + !byte $BF,%11100101 + !byte $AB,%01010000 + !byte $71,%11101001 + !byte $6B,%00101000 + !byte $0B,%11101111 + !byte $A5,%10100111 + !byte $B1,%10101111 + !byte $9F,%11010011 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $81,%10101001 + !byte $9B,%11100111 + !byte $55,%10100011 + !byte $49,%00100000 + !byte $4F,%11100001 + !byte $01,%00110000 + !byte $BD,%00101100 + !byte $B7,%11101101 + !byte $B5,%00101110 + !byte $8B,%01001000 + !byte $AF,%01000110 + !byte $2D,%11101101 + !byte $2D,%11001101 + !byte $2D,%10101101 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $2D,%01001100 + !byte $2D,%00001100 + !byte $2D,%11101011 + !byte $2D,%10101011 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $2D,%00101010 + !byte $2D,%11101001 + !byte $2D,%10101001 + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $2D,%01001000 + !byte $2D,%10100111 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $2D,%01000110 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $2D,%01000100 + !byte $2D,%00000010 + !byte $2D,%10100001 + !byte $2D,%01000000 + !byte $2D,%00000000 + !byte $1F,%01001110 + !byte $A5,%00010010 + !byte $2D,%11001011 + !byte $2D,%00101000 + !byte $2D,%11000101 + !byte $2D,%10100011 + !byte $2D,%00100010 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $59,%00000100 + !byte $15,%10101111 + !byte $2D,%01001010 + !byte $2D,%11001001 + !byte $2D,%11100111 + !byte $2D,%11000111 + !byte $2D,%00100110 + !byte $2D,%00000110 + !byte $2D,%00100100 + !byte $5F,%11000101 + !byte $2D,%00101100 + !byte $2D,%00001010 + !byte $2D,%10100101 + !byte $2D,%11100011 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $53,%01000010 + !byte $29,%00001110 + !byte $85,%01101000 + !byte $85,%10001001; + !byte $B9,%00000110 + !byte $AF,%11101111 + !byte $A9,%10110001 + !byte $2D,%00001000 + !byte $2D,%11100101 + !byte $2D,%00000100 + !byte $2D,%11000001 + !byte $2D,%00100000 + !byte $6F,%10101001 + !byte $05,%00010000 + !byte $0F,%11001111 + !byte $7B,%11001001 + !byte $95,%00001000 + !byte $2D,%11000011 + !byte $2D,%01000010 + !byte $2D,%11100001 + !byte $BB,%01101100 + !byte $BB,%10001101; + !byte $A3,%01010010 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $8F,%00101000 + !byte $9F,%11000111 + !byte $23,%00101110 + !byte $99,%11100111 + !byte $BF,%00001100 + !byte $69,%11100111 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $75,%11101001 + !byte $A9,%01100110 + !byte $A9,%10000111; + !byte $BD,%11100101 + !byte $4D,%10100001 + !byte $63,%00100110 + !byte $7F,%10101001 + !byte $B9,%11001101 + !byte $B3,%01101110 + !byte $B3,%10001111; + !byte $AD,%00110000 + !byte $09,%11101111 + !byte $A1,%10110011 + !byte $61,%11100101 + !byte $93,%00001000 + !byte $A7,%11110001 + !byte $4B,%01000000 + !byte $6D,%01001000 + !byte $89,%01001000 + !byte $A3,%10100111 + !byte $B3,%00100110 + !byte $57,%11000011 + !byte $4F,%11000001 + !byte $13,%10101111 + !byte $1D,%01001110 + !byte $27,%00001110 + !byte $AD,%01000110 + !byte $B7,%00000110 + !byte $BD,%01001100 + !byte $5B,%00100100 + !byte $67,%10100111 + !byte $51,%00000010 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $71,%11001001 + !byte $03,%00010000 + !byte $79,%11001001 + !byte $9D,%11000111 + !byte $A7,%01100110 + !byte $A7,%10000111; + !byte $B7,%00001110 + !byte $AB,%01110000 + !byte $AB,%10010001; + !byte $9F,%11110011 + !byte $BB,%10101101 + !byte $B1,%11001111 + !byte $A5,%00110010 + !byte $83,%01101000 + !byte $83,%10001001; + !byte $8D,%00101000 + !byte $59,%11100011 + !byte $65,%01000110 + !byte $0D,%11001111 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $21,%00101110 + !byte $73,%11101001 + !byte $97,%11100111 + !byte $BB,%11100101 + !byte $5F,%10100101 + !byte $6B,%00001000 + !byte $A9,%11010001 + !byte $49,%00000000 + !byte $7D,%10101001 + !byte $B1,%00100110 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $11,%10101111 + !byte $2B,%11101101 + !byte $87,%01001000 + !byte $A1,%10100111 + !byte $AB,%01000110 + !byte $B5,%01001110 + !byte $AF,%00010000 + !byte $A3,%01110010 + !byte $A3,%10010011; + !byte $6F,%01101000 + !byte $6F,%10001001; + !byte $07,%11101111 + !byte $91,%00001000 + !byte $B5,%00000110 + !byte $53,%00100010 + !byte $69,%11000111 + !byte $B9,%11101101 + !byte $1B,%01001110 + !byte $77,%11001001 + !byte $A5,%01100110 + !byte $A5,%10000111; + !byte $AD,%01010000 + !byte $01,%00010000 + !byte $25,%00001110 + !byte $9B,%11000111 + !byte $BF,%11000101 + !byte $BF,%00101100 + !byte $63,%00000110 + !byte $0B,%11001111 + !byte $81,%01101000 + !byte $81,%10001001; + !byte $A7,%00010010 + !byte $A1,%11010011 + !byte $8B,%00101000 + !byte $51,%11100001 + !byte $57,%10100011 + !byte $5D,%01000100 + !byte $61,%11000101 + !byte $67,%01100110 + !byte $67,%10000111; + !byte $6D,%00101000 + !byte $B3,%10101111 + !byte $AF,%00100110 + !byte $BD,%01101100 + !byte $BD,%10001101; + !byte $1F,%00101110 + !byte $29,%11101101 + !byte $5B,%00000100 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $95,%11100111 + !byte $AB,%10110001 + !byte $4B,%00100000 + !byte $55,%01000010 + !byte $85,%01001000 + !byte $B9,%11100101 + !byte $B7,%00101110 + !byte $4F,%10100001 + !byte $71,%10101001 + !byte $05,%11101111 + !byte $7B,%10101001 + !byte $9F,%10100111 + !byte $0F,%10101111 + !byte $23,%00001110 + !byte $A9,%01000110 + !byte $A5,%01010010 + !byte $8F,%00001000 + !byte $B1,%11101111 + !byte $6B,%11100111 + !byte $19,%01001110 + !byte $75,%11001001 + !byte $BD,%11000101 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $2B,%11001101 + !byte $2B,%10101101 + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $2B,%01001100 + !byte $2B,%00101100 + !byte $2B,%00001100 + !byte $2B,%11001011 + !byte $2B,%10101011 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $2B,%01001010 + !byte $2B,%00001010 + !byte $2B,%11101001 + !byte $2B,%10101001 + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $2B,%00001000 + !byte $2B,%10100111 + !byte $2B,%01000110 + !byte $2B,%00100110 + !byte $2B,%00000110 + !byte $2B,%00100100 + !byte $2B,%00100010 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $2B,%00100000 + !byte $4D,%01000000 + !byte $7F,%01101000 + !byte $7F,%10001001; + !byte $2B,%11101011 + !byte $2B,%11001001 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $2B,%11100011 + !byte $2B,%01000010 + !byte $53,%00000010 + !byte $65,%00100110 + !byte $89,%00101000 + !byte $A3,%01100110 + !byte $A3,%10000111; + !byte $2B,%00101010 + !byte $2B,%11100111 + !byte $2B,%11100101 + !byte $2B,%11000101 + !byte $2B,%11000001 + !byte $2B,%01001000 + !byte $2B,%11000111 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $2B,%01000100 + !byte $2B,%11000011 + !byte $2B,%10100011 + !byte $2B,%11100001 + !byte $09,%11001111 + !byte $1D,%00101110 + !byte $AD,%00100110 + !byte $BB,%11001101 + !byte $2B,%00101000 + !byte $2B,%10100101 + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $2B,%00000010 + !byte $2B,%10100001 + !byte $2B,%01000000 + !byte $99,%11000111 + !byte $B3,%00000110 + !byte $A9,%11110001 + !byte $2B,%00000100 + !byte $59,%11000011 + !byte $69,%10100111 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $B7,%11100101 + !byte $B9,%00001110 + !byte $B5,%01101110 + !byte $B5,%10001111; + !byte $AF,%00110000 + !byte $A3,%10110011 + !byte $2B,%00000000 + !byte $6F,%01001000 + !byte $73,%11001001 + !byte $27,%11101101 + !byte $79,%10101001 + !byte $9D,%10100111 + !byte $AD,%01110000 + !byte $AD,%10010001; + !byte $63,%11100101 + !byte $0D,%10101111 + !byte $93,%11100111 + !byte $B3,%11001111 + !byte $4B,%00000000 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $51,%11000001 + !byte $A7,%01000110 + !byte $BF,%01001100 + !byte $6D,%00001000 + !byte $83,%01001000 + !byte $A7,%00110010 + !byte $5D,%00100100 + !byte $61,%10100101 + !byte $03,%11101111 + !byte $8D,%00001000 + !byte $17,%01001110 + !byte $B1,%00000110 + !byte $BB,%11000101 + !byte $67,%01000110 + !byte $97,%11000111 + !byte $A1,%01100110 + !byte $A1,%10000111; + !byte $AB,%00100110 + !byte $BD,%10101101 + !byte $A1,%11110011 + !byte $21,%00001110 + !byte $7D,%01101000 + !byte $7D,%10001001; + !byte $B1,%00010000 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $87,%00101000 + !byte $B5,%11100101 + !byte $07,%11001111 + !byte $71,%01101000 + !byte $71,%10001001; + !byte $65,%00000110 + !byte $6B,%11000111 + !byte $91,%11100111 + !byte $B7,%01001110 + !byte $AB,%11010001 + !byte $5B,%11100011 + !byte $1B,%00101110 + !byte $A5,%01110010 + !byte $A5,%10010011; + !byte $55,%00100010 + !byte $25,%11101101 + !byte $77,%10101001 + !byte $81,%01001000 + !byte $9B,%10100111 + !byte $BF,%10100101 + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $5F,%01000100 + !byte $01,%11101111 + !byte $AF,%00000110 + !byte $B9,%11000101 + !byte $BB,%11101101 + !byte $B5,%10101111 + !byte $A9,%00010010 + !byte $59,%10100011 + !byte $8B,%00001000 + !byte $4D,%00100000 + !byte $63,%11000101 + !byte $15,%01001110 + !byte $1F,%00001110 + !byte $A3,%11010011 + !byte $53,%11100001 + !byte $6F,%00101000 + !byte $05,%11001111 + !byte $0B,%10101111 + !byte $29,%11001101 + !byte $AF,%01010000 + !byte $95,%11000111 + !byte $A5,%01000110 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $AD,%10110001 + !byte $7B,%01101000 + !byte $7B,%10001001; + !byte $9F,%01100110 + !byte $9F,%10000111; + !byte $BF,%01101100 + !byte $BF,%10001101; + !byte $5D,%00000100 + !byte $57,%01000010 + !byte $6D,%11100111 + !byte $8F,%11100111 + !byte $B9,%00101110 + !byte $73,%10101001 + !byte $85,%00101000 + !byte $A9,%00100110 + !byte $B3,%11101111 + !byte $61,%01100100 + !byte $61,%10000101; + !byte $23,%11101101 + !byte $7F,%01001000 + !byte $A7,%01010010 + !byte $19,%00101110 + !byte $75,%10101001 + !byte $BD,%10100101 + !byte $BD,%11001101 + !byte $67,%00100110 + !byte $09,%10101111 + !byte $51,%10100001 + !byte $99,%10100111 + !byte $A3,%01000110 + !byte $B3,%11100101 + !byte $B7,%01101110 + !byte $B7,%10001111; + !byte $B1,%00110000 + !byte $4F,%01000000 + !byte $71,%01001000 + !byte $1D,%00001110 + !byte $89,%00001000 + !byte $AD,%00000110 + !byte $A5,%10110011 + !byte $55,%00000010 + !byte $5B,%11000011 + !byte $9D,%01100110 + !byte $9D,%10000111; + !byte $B7,%11000101 + !byte $AB,%11110001 + !byte $03,%11001111 + !byte $13,%01001110 + !byte $27,%11001101 + !byte $79,%01101000 + !byte $79,%10001001; + !byte $65,%11100101 + !byte $B5,%11001111 + !byte $93,%11000111 + !byte $59,%01100010 + !byte $59,%10000011; + !byte $5F,%00100100 + !byte $6B,%10100111 + !byte $29,%10101101 + !byte $29,%01101100 + !byte $29,%10001101; + !byte $29,%01001100 + !byte $29,%00101100 + !byte $29,%00001100 + !byte $29,%11001011 + !byte $29,%01001010 + !byte $29,%11001001 + !byte $29,%01101000 + !byte $29,%10001001; + !byte $29,%00101000 + !byte $29,%00001000 + !byte $29,%11100111 + !byte $29,%11000111 + !byte $29,%01000110 + !byte $29,%00000110 + !byte $29,%11100101 + !byte $29,%11000101 + !byte $29,%00000100 + !byte $29,%11100011 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $29,%01000000 + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $8D,%11100111 + !byte $A7,%00100110 + !byte $BB,%00001110 + !byte $29,%11101011 + !byte $29,%01100110 + !byte $29,%10000111; + !byte $29,%00100110 + !byte $29,%00100100 + !byte $29,%10100011 + !byte $29,%11000001 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $83,%00101000 + !byte $29,%10101011 + !byte $29,%00101010 + !byte $29,%00001010 + !byte $29,%01001000 + !byte $29,%10100101 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $29,%01000010 + !byte $53,%11000001 + !byte $29,%01101010 + !byte $29,%10001011; + !byte $29,%11101001 + !byte $29,%10101001 + !byte $29,%10100111 + !byte $29,%00000010 + !byte $29,%00000000 + !byte $6F,%00001000 + !byte $97,%10100111 + !byte $AF,%01110000 + !byte $AF,%10010001; + !byte $A9,%00110010 + !byte $A3,%11110011 + !byte $29,%01000100 + !byte $29,%11000011 + !byte $29,%00100010 + !byte $69,%01000110 + !byte $17,%00101110 + !byte $B1,%11100101 + !byte $BB,%10100101 + !byte $29,%11100001 + !byte $29,%10100001 + !byte $57,%00100010 + !byte $A1,%01000110 + !byte $B3,%00010000 + !byte $AD,%11010001 + !byte $29,%00100000 + !byte $63,%10100101 + !byte $07,%10101111 + !byte $21,%11101101 + !byte $7D,%01001000 + !byte $B9,%01001110 + !byte $4D,%00000000 + !byte $87,%00001000 + !byte $91,%11000111 + !byte $B5,%11000101 + !byte $5D,%11100011 + !byte $BF,%10101101 + !byte $A7,%01110010 + !byte $A7,%10010011; + !byte $51,%01100000 + !byte $51,%10000001; + !byte $67,%00000110 + !byte $9B,%01100110 + !byte $9B,%10000111; + !byte $73,%01101000 + !byte $73,%10001001; + !byte $61,%01000100 + !byte $11,%01001110 + !byte $1B,%00001110 + !byte $BD,%11101101 + !byte $B7,%10101111 + !byte $25,%11001101 + !byte $77,%01101000 + !byte $77,%10001001; + !byte $81,%00101000 + !byte $AB,%00000110 + !byte $BF,%01100100 + !byte $BF,%10000101; + !byte $6D,%11000111 + !byte $01,%11001111 + !byte $55,%11100001 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $AF,%11100101 + !byte $B9,%10100101 + !byte $5B,%10100011 + !byte $4F,%00100000 + !byte $8B,%11100111 + !byte $AB,%00010010 + !byte $71,%00101000 + !byte $15,%00101110 + !byte $1F,%11101101 + !byte $95,%10100111 + !byte $A5,%00100110 + !byte $B1,%01010000 + !byte $A5,%11010011 + !byte $7B,%01001000 + !byte $85,%00001000 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $9F,%01000110 + !byte $BB,%00101110 + !byte $5F,%00000100 + !byte $65,%11000101 + !byte $53,%10100001 + !byte $59,%01000010 + !byte $0F,%01001110 + !byte $8F,%11000111 + !byte $B5,%11101111 + !byte $A9,%01010010 + !byte $05,%10101111 + !byte $19,%00001110 + !byte $A9,%00000110 + !byte $23,%11001101 + !byte $7F,%00101000 + !byte $AF,%10110001 + !byte $A3,%00100110 + !byte $BD,%01100100 + !byte $BD,%10000101; + !byte $6F,%11100111 + !byte $69,%00100110 + !byte $75,%01101000 + !byte $75,%10001001; + !byte $B9,%01101110 + !byte $B9,%10001111; + !byte $63,%01100100 + !byte $63,%10000101; + !byte $99,%01100110 + !byte $99,%10000111; + !byte $B3,%11000101 + !byte $5D,%11000011 + !byte $1D,%11101101 + !byte $89,%11100111 + !byte $AD,%11100101 + !byte $B3,%00110000 + !byte $13,%00101110 + !byte $BF,%11001101 + !byte $AD,%11110001 + !byte $73,%01001000 + !byte $03,%10101111 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $9D,%01000110 + !byte $B7,%10100101 + !byte $57,%00000010 + !byte $27,%10101101 + !byte $79,%01001000 + !byte $93,%10100111 + !byte $A7,%10110011 + !byte $61,%00100100 + !byte $6D,%10100111 + !byte $0D,%01001110 + !byte $B1,%01110000 + !byte $B1,%10010001; + !byte $67,%11100101 + !byte $51,%01000000 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $8D,%11000111 + !byte $A7,%00000110 + !byte $AB,%00110010 + !byte $17,%00001110 + !byte $83,%00001000 + !byte $71,%00001000 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $97,%01100110 + !byte $97,%10000111; + !byte $A1,%00100110 + !byte $B7,%11001111 + !byte $A5,%11110011 + !byte $21,%11001101 + !byte $B1,%11000101 + !byte $BB,%01100100 + !byte $BB,%10000101; + !byte $55,%11000001 + !byte $6B,%01000110 + !byte $87,%11100111 + !byte $BD,%00001110 + !byte $BB,%01001110 + !byte $4F,%00000000 + !byte $7D,%00101000 + !byte $5F,%11100011 + !byte $65,%10100101 + !byte $53,%01100000 + !byte $53,%10000001; + !byte $59,%00100010 + !byte $B5,%10100101 + !byte $A9,%01110010 + !byte $A9,%10010011; + !byte $11,%00101110 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $27,%01001100 + !byte $27,%00101100 + !byte $27,%00001100 + !byte $27,%11101011 + !byte $27,%11001011 + !byte $27,%10101011 + !byte $27,%01101010 + !byte $27,%10001011; + !byte $27,%01001010 + !byte $27,%00101010 + !byte $27,%00001010 + !byte $27,%10101001 + !byte $27,%01001000 + !byte $27,%00101000 + !byte $27,%00001000 + !byte $27,%11100111 + !byte $27,%10100101 + !byte $27,%01100100 + !byte $27,%10000101; + !byte $27,%11000011 + !byte $27,%00100010 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $27,%11101001 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $27,%10100111 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $27,%00100110 + !byte $27,%00000110 + !byte $27,%11100101 + !byte $27,%11000101 + !byte $27,%11100011 + !byte $27,%10100001 + !byte $01,%10101111 + !byte $1B,%11101101 + !byte $9B,%01000110 + !byte $27,%11001001 + !byte $27,%01000100 + !byte $27,%00100100 + !byte $27,%00000000 + !byte $27,%01000010 + !byte $27,%11100001 + !byte $27,%00100000 + !byte $69,%00000110 + !byte $B5,%00010000 + !byte $AF,%11010001 + !byte $27,%11000111 + !byte $27,%01000110 + !byte $27,%00000100 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $27,%00000010 + !byte $6F,%11000111 + !byte $25,%10101101 + !byte $77,%01001000 + !byte $81,%00001000 + !byte $91,%10100111 + !byte $AB,%11100101 + !byte $BF,%01000100 + !byte $27,%10100011 + !byte $27,%11000001 + !byte $0B,%01001110 + !byte $8B,%11000111 + !byte $27,%01000000 + !byte $15,%00001110 + !byte $AF,%11000101 + !byte $A7,%11010011 + !byte $5D,%10100011 + !byte $1F,%11001101 + !byte $BF,%11101101 + !byte $B3,%01010000 + !byte $57,%11100001 + !byte $63,%01000100 + !byte $95,%01100110 + !byte $95,%10000111; + !byte $A5,%00000110 + !byte $B9,%01100100 + !byte $B9,%10000101; + !byte $AD,%00010010 + !byte $51,%00100000 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $67,%11000101 + !byte $73,%00101000 + !byte $7B,%00101000 + !byte $BD,%00101110 + !byte $B9,%10101111 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $9F,%00100110 + !byte $B7,%11101111 + !byte $5B,%01000010 + !byte $61,%00000100 + !byte $8F,%10100111 + !byte $B1,%10110001 + !byte $A9,%11100101 + !byte $23,%10101101 + !byte $0F,%00101110 + !byte $19,%11101101 + !byte $85,%11100111 + !byte $AB,%01010010 + !byte $55,%10100001 + !byte $75,%01001000 + !byte $7F,%00001000 + !byte $71,%11100111 + !byte $A3,%00000110 + !byte $BD,%01000100 + !byte $59,%00000010 + !byte $89,%11000111 + !byte $09,%01001110 + !byte $13,%00001110 + !byte $99,%01000110 + !byte $B3,%10100101 + !byte $B5,%00110000 + !byte $5F,%11000011 + !byte $6B,%00100110 + !byte $9D,%00100110 + !byte $AD,%11000101 + !byte $A9,%10110011 + !byte $65,%01100100 + !byte $65,%10000101; + !byte $63,%00100100 + !byte $1D,%11001101 + !byte $B7,%01100100 + !byte $B7,%10000101; + !byte $BB,%01101110 + !byte $BB,%10001111; + !byte $53,%01000000 + !byte $79,%00101000 + !byte $93,%01100110 + !byte $93,%10000111; + !byte $6F,%10100111 + !byte $AF,%11110001 + !byte $B9,%11001111 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $69,%11100101 + !byte $0D,%00101110 + !byte $8D,%10100111 + !byte $A7,%11100101 + !byte $57,%11000001 + !byte $17,%11101101 + !byte $83,%11100111 + !byte $BF,%00001110 + !byte $AD,%00110010 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $97,%01000110 + !byte $A1,%00000110 + !byte $A7,%11110011 + !byte $6D,%01000110 + !byte $21,%10101101 + !byte $B1,%10100101 + !byte $BB,%01000100 + !byte $51,%00000000 + !byte $67,%10100101 + !byte $87,%11000111 + !byte $B3,%01110000 + !byte $B3,%10010001; + !byte $73,%00001000 + !byte $11,%00001110 + !byte $7D,%00001000 + !byte $B5,%01100100 + !byte $B5,%10000101; + !byte $B1,%11010001 + !byte $AB,%01110010 + !byte $AB,%10010011; + !byte $5B,%00100010 + !byte $61,%11100011 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $07,%01001110 + !byte $77,%00101000 + !byte $BD,%01001110 + !byte $1B,%11001101 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $9B,%00100110 + !byte $B7,%00010000 + !byte $71,%11000111 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $0B,%00101110 + !byte $65,%01000100 + !byte $6B,%00000110 + !byte $81,%11100111 + !byte $91,%01100110 + !byte $91,%10000111; + !byte $AB,%11000101 + !byte $8B,%10100111 + !byte $AF,%10100101 + !byte $BF,%00100100 + !byte $BB,%10101111 + !byte $5F,%10100011 + !byte $05,%01001110 + !byte $15,%11101101 + !byte $1F,%10101101 + !byte $53,%00100000 + !byte $95,%01000110 + !byte $A5,%11100101 + !byte $B9,%01000100 + !byte $B5,%01010000 + !byte $25,%00001100 + !byte $25,%11101011 + !byte $25,%11001011 + !byte $25,%10101011 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $25,%00101010 + !byte $25,%11101001 + !byte $25,%11001001 + !byte $25,%01101000 + !byte $25,%10001001; + !byte $25,%01001000 + !byte $25,%10100111 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $25,%01000110 + !byte $25,%00100100 + !byte $25,%00000010 + !byte $75,%00101000 + !byte $7B,%00001000 + !byte $85,%11000111 + !byte $AF,%00010010 + !byte $A9,%11010011 + !byte $25,%00101100 + !byte $25,%01001010 + !byte $25,%00001010 + !byte $25,%00101000 + !byte $25,%10100101 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $25,%01000100 + !byte $25,%10100011 + !byte $25,%00000000 + !byte $59,%11100001 + !byte $69,%11000101 + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $9F,%00000110 + !byte $25,%01001100 + !byte $25,%10101001 + !byte $25,%11100111 + !byte $25,%11000111 + !byte $25,%00100110 + !byte $25,%11100101 + !byte $25,%11000101 + !byte $25,%11100011 + !byte $25,%11100001 + !byte $25,%00000100 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $25,%10100001 + !byte $25,%01000000 + !byte $63,%00000100 + !byte $8F,%01100110 + !byte $8F,%10000111; + !byte $B9,%11101111 + !byte $25,%00001000 + !byte $25,%11000011 + !byte $25,%00100010 + !byte $25,%11000001 + !byte $0F,%00001110 + !byte $19,%11001101 + !byte $A9,%11000101 + !byte $AD,%01010010 + !byte $25,%00000110 + !byte $25,%01000010 + !byte $25,%00100000 + !byte $5D,%01000010 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $BF,%00101110 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $6D,%00100110 + !byte $73,%11100111 + !byte $7F,%11100111 + !byte $A3,%11100101 + !byte $61,%11000011 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $09,%00101110 + !byte $89,%10100111 + !byte $B7,%00110000 + !byte $B3,%10110001 + !byte $99,%00100110 + !byte $B7,%01000100 + !byte $BD,%00100100 + !byte $57,%10100001 + !byte $55,%01000000 + !byte $5B,%00000010 + !byte $13,%11101101 + !byte $9D,%00000110 + !byte $AD,%10100101 + !byte $B1,%11110001 + !byte $B3,%01100100 + !byte $B3,%10000101; + !byte $BD,%01101110 + !byte $BD,%10001111; + !byte $6B,%11100101 + !byte $1D,%10101101 + !byte $71,%10100111 + !byte $03,%01001110 + !byte $93,%01000110 + !byte $A7,%11000101 + !byte $B5,%01110000 + !byte $B5,%10010001; + !byte $AB,%10110011 + !byte $0D,%00001110 + !byte $79,%00001000 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $17,%11001101 + !byte $8D,%01100110 + !byte $8D,%10000111; + !byte $BB,%11001111 + !byte $65,%00100100 + !byte $21,%01101100 + !byte $21,%10001101; + !byte $83,%11000111 + !byte $97,%00100110 + !byte $A1,%11100101 + !byte $A9,%11110011 + !byte $59,%11000001 + !byte $07,%00101110 + !byte $B1,%01100100 + !byte $B1,%10000101; + !byte $BB,%00100100 + !byte $6F,%01000110 + !byte $75,%00001000 + !byte $87,%10100111 + !byte $AF,%00110010 + !byte $7D,%11100111 + !byte $53,%00000000 + !byte $63,%11100011 + !byte $11,%11101101 + !byte $69,%10100101 + !byte $1B,%10101101 + !byte $BF,%01001110 + !byte $B3,%11010001 + !byte $5D,%00100010 + !byte $77,%00001000 + !byte $B5,%01000100 + !byte $B9,%00010000 + !byte $73,%11000111 + !byte $9B,%00000110 + !byte $57,%01100000 + !byte $57,%10000001; + !byte $15,%11001101 + !byte $AD,%01110010 + !byte $AD,%10010011; + !byte $81,%11000111 + !byte $91,%01000110 + !byte $AB,%10100101 + !byte $61,%10100011 + !byte $6D,%00000110 + !byte $5B,%11100001 + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $8B,%01100110 + !byte $8B,%10000111; + !byte $01,%01001110 + !byte $AF,%01100100 + !byte $AF,%10000101; + !byte $67,%01000100 + !byte $BD,%10101111 + !byte $B7,%01010000 + !byte $B1,%00010010 + !byte $0B,%00001110 + !byte $7B,%11100111 + !byte $95,%00100110 + !byte $A5,%11000101 + !byte $B9,%00100100 + !byte $BF,%00000100 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $85,%10100111 + !byte $AB,%11010011 + !byte $9F,%11100101 + !byte $6B,%11000101 + !byte $0F,%11101101 + !byte $8F,%01000110 + !byte $B3,%01000100 + !byte $55,%00100000 + !byte $A9,%10100101 + !byte $5F,%01000010 + !byte $19,%10101101 + !byte $B5,%10110001 + !byte $59,%10100001 + !byte $65,%00000100 + !byte $05,%00101110 + !byte $23,%01001100 + !byte $BB,%11101111 + !byte $AF,%01010010 + !byte $6F,%00100110 + !byte $99,%00000110 + !byte $A3,%11000101 + !byte $23,%00001100 + !byte $23,%11101011 + !byte $23,%11001011 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $23,%01001010 + !byte $23,%00101010 + !byte $23,%11101001 + !byte $23,%10101001 + !byte $23,%11100111 + !byte $23,%11000111 + !byte $23,%10100111 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $23,%01000110 + !byte $23,%00100110 + !byte $23,%00000110 + !byte $23,%10100101 + !byte $23,%11000001 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $09,%00001110 + !byte $13,%11001101 + !byte $7F,%11000111 + !byte $89,%01100110 + !byte $89,%10000111; + !byte $23,%10101011 + !byte $23,%00101000 + !byte $23,%00000100 + !byte $23,%11100011 + !byte $23,%01000010 + !byte $75,%11100111 + !byte $BD,%00000100 + !byte $23,%00101100 + !byte $23,%00001010 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $23,%01100100 + !byte $23,%10000101; + !byte $23,%10100011 + !byte $23,%10100001 + !byte $23,%01000000 + !byte $23,%11001001 + !byte $23,%01001000 + !byte $23,%11100101 + !byte $23,%11000101 + !byte $23,%11000011 + !byte $23,%00100010 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $23,%00000000 + !byte $63,%11000011 + !byte $79,%11100111 + !byte $9D,%11100101 + !byte $AD,%01100100 + !byte $AD,%10000101; + !byte $BF,%01101110 + !byte $BF,%10001111; + !byte $23,%00001000 + !byte $23,%00100100 + !byte $23,%01100010 + !byte $23,%10000011; + !byte $23,%00000010 + !byte $23,%11100001 + !byte $23,%00100000 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $B7,%00100100 + !byte $B3,%11110001 + !byte $23,%01000100 + !byte $57,%01000000 + !byte $5D,%00000010 + !byte $03,%00101110 + !byte $93,%00100110 + !byte $73,%10100111 + !byte $5B,%11000001 + !byte $17,%10101101 + !byte $A7,%10100101 + !byte $B9,%00110000 + !byte $AD,%10110011 + !byte $67,%00100100 + !byte $6D,%11100101 + !byte $0D,%11101101 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $8D,%01000110 + !byte $B1,%00110010 + !byte $21,%01001100 + !byte $83,%10100111 + !byte $07,%00001110 + !byte $7D,%11000111 + !byte $97,%00000110 + !byte $A1,%11000101 + !byte $AB,%11110011 + !byte $B1,%01000100 + !byte $65,%11100011 + !byte $87,%01100110 + !byte $87,%10000111; + !byte $91,%00100110 + !byte $AB,%01100100 + !byte $AB,%10000101; + !byte $B7,%01110000 + !byte $B7,%10010001; + !byte $55,%00000000 + !byte $71,%01000110 + !byte $BB,%00000100 + !byte $11,%11001101 + !byte $BD,%11001111 + !byte $59,%01100000 + !byte $59,%10000001; + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $BB,%00010000 + !byte $5F,%00100010 + !byte $B5,%00100100 + !byte $B5,%11010001 + !byte $6B,%10100101 + !byte $0B,%11101101 + !byte $77,%11100111 + !byte $9B,%11100101 + !byte $6F,%00000110 + !byte $75,%11000111 + !byte $AF,%01110010 + !byte $AF,%10010011; + !byte $01,%00101110 + !byte $81,%10100111 + !byte $BF,%10101111 + !byte $69,%01000100 + !byte $8B,%01000110 + !byte $AF,%01000100 + !byte $63,%10100011 + !byte $5D,%11100001 + !byte $15,%10101101 + !byte $1F,%01001100 + !byte $95,%00000110 + !byte $A5,%10100101 + !byte $B9,%00000100 + !byte $B9,%01010000 + !byte $B3,%00010010 + !byte $6D,%11000101 + !byte $85,%01100110 + !byte $85,%10000111; + !byte $AD,%11010011 + !byte $05,%00001110 + !byte $7B,%11000111 + !byte $9F,%11000101 + !byte $BF,%11100011 + !byte $57,%00100000 + !byte $0F,%11001101 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $8F,%00100110 + !byte $B3,%00100100 + !byte $67,%00000100 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $A9,%01100100 + !byte $A9,%10000101; + !byte $B7,%10110001 + !byte $61,%01000010 + !byte $B1,%01010010 + !byte $09,%11101101 + !byte $7F,%10100111 + !byte $89,%01000110 + !byte $99,%11100101 + !byte $A3,%10100101 + !byte $AD,%01000100 + !byte $BD,%11101111 + !byte $71,%00100110 + !byte $5B,%10100001 + !byte $1D,%01001100 + !byte $65,%11000011 + !byte $9D,%11000101 + !byte $BB,%00110000 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $13,%10101101 + !byte $B7,%00000100 + !byte $5F,%00000010 + !byte $0D,%11001101 + !byte $79,%11000111 + !byte $83,%01100110 + !byte $83,%10000111; + !byte $B5,%11110001 + !byte $AF,%10110011 + !byte $93,%00000110 + !byte $A7,%01100100 + !byte $A7,%10000101; + !byte $BD,%11100011 + !byte $BF,%11001111 + !byte $75,%10100111 + !byte $03,%00001110 + !byte $6F,%11100101 + !byte $21,%00101100 + !byte $21,%00001100 + !byte $21,%11101011 + !byte $21,%11001011 + !byte $21,%10101011 + !byte $21,%01001010 + !byte $21,%00001010 + !byte $21,%10101001 + !byte $21,%00001000 + !byte $21,%11100111 + !byte $21,%01000100 + !byte $21,%00000100 + !byte $21,%00100000 + !byte $8D,%00100110 + !byte $B9,%01110000 + !byte $B9,%10010001; + !byte $21,%01101010 + !byte $21,%10001011; + !byte $21,%00101010 + !byte $21,%01001000 + !byte $21,%11000111 + !byte $21,%01000110 + !byte $21,%11100101 + !byte $21,%11000101 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $21,%11000011 + !byte $21,%10100011 + !byte $21,%01000000 + !byte $21,%11101001 + !byte $21,%00101000 + !byte $21,%01100110 + !byte $21,%10000111; + !byte $21,%01000010 + !byte $21,%11100001 + !byte $21,%00000000 + !byte $59,%01000000 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $69,%00100100 + !byte $21,%11001001 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $21,%00100100 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $21,%00000010 + !byte $21,%10100001 + !byte $57,%00000000 + !byte $5D,%11000001 + !byte $17,%01101100 + !byte $17,%10001101; + !byte $7D,%10100111 + !byte $97,%11100101 + !byte $A1,%10100101 + !byte $AD,%11110011 + !byte $21,%10100111 + !byte $21,%00100110 + !byte $21,%00000110 + !byte $21,%10100101 + !byte $21,%00100010 + !byte $21,%11000001 + !byte $B3,%00110010 + !byte $21,%11100011 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $1B,%01001100 + !byte $91,%00000110 + !byte $AB,%01000100 + !byte $B1,%00100100 + !byte $B5,%00000100 + !byte $BB,%11100011 + !byte $6D,%10100101 + !byte $73,%01000110 + !byte $87,%01000110 + !byte $07,%11101101 + !byte $11,%10101101 + !byte $61,%00100010 + !byte $0B,%11001101 + !byte $A5,%01100100 + !byte $A5,%10000101; + !byte $BF,%11000011 + !byte $BD,%00010000 + !byte $B1,%01110010 + !byte $B1,%10010011; + !byte $67,%11100011 + !byte $77,%11000111 + !byte $9B,%11000101 + !byte $B7,%11010001 + !byte $01,%00001110 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $71,%00000110 + !byte $8B,%00100110 + !byte $6B,%01000100 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $81,%01100110 + !byte $81,%10000111; + !byte $5F,%11100001 + !byte $65,%10100011 + !byte $AF,%11010011 + !byte $1F,%00101100 + !byte $95,%11100101 + !byte $AF,%00100100 + !byte $05,%11101101 + !byte $BB,%01010000 + !byte $7B,%10100111 + !byte $9F,%10100101 + !byte $B9,%11100011 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $85,%01000110 + !byte $8F,%00000110 + !byte $BD,%11000011 + !byte $B5,%00010010 + !byte $69,%00000100 + !byte $6F,%11000101 + !byte $0F,%10101101 + !byte $59,%00100000 + !byte $5D,%10100001 + !byte $B3,%00000100 + !byte $19,%01001100 + !byte $A9,%01000100 + !byte $63,%01000010 + !byte $09,%11001101 + !byte $BF,%11101111 + !byte $B9,%10110001 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $A3,%01100100 + !byte $A3,%10000101; + !byte $B3,%01010010 + !byte $67,%11000011 + !byte $73,%00100110 + !byte $89,%00100110 + !byte $99,%11000101 + !byte $AD,%00100100 + !byte $1D,%00101100 + !byte $9D,%10100101 + !byte $B7,%11110001 + !byte $B1,%10110011 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $B7,%11100011 + !byte $61,%00000010 + !byte $03,%11101101 + !byte $79,%10100111 + !byte $93,%11100101 + !byte $A7,%01000100 + !byte $77,%10100111 + !byte $71,%11100101 + !byte $83,%01000110 + !byte $B1,%00000100 + !byte $BB,%11000011 + !byte $5B,%01000000 + !byte $0D,%10101101 + !byte $17,%01001100 + !byte $8D,%00000110 + !byte $6B,%00100100 + !byte $BD,%00110000 + !byte $5F,%11000001 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $97,%11000101 + !byte $A1,%01100100 + !byte $A1,%10000101; + !byte $AF,%11110011 + !byte $07,%11001101 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $6F,%10100101 + !byte $AB,%00100100 + !byte $11,%01101100 + !byte $11,%10001101; + !byte $87,%00100110 + !byte $59,%00000000 + !byte $75,%01000110 + !byte $91,%11100101 + !byte $BB,%01110000 + !byte $BB,%10010001; + !byte $B5,%00110010 + !byte $01,%11101101 + !byte $B5,%11100011 + !byte $1F,%11101011 + !byte $1F,%11001011 + !byte $1F,%10101011 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $1F,%11101001 + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $1F,%01001000 + !byte $1F,%00101000 + !byte $1F,%11000111 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $1F,%01000110 + !byte $1F,%00100110 + !byte $1F,%00000110 + !byte $1F,%11100101 + !byte $1F,%11000101 + !byte $1F,%10100101 + !byte $1F,%11000011 + !byte $1F,%10100011 + !byte $1F,%01000000 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $1B,%00101100 + !byte $81,%01000110 + !byte $A5,%01000100 + !byte $BF,%10100011 + !byte $1F,%01001010 + !byte $1F,%00001010 + !byte $1F,%00000100 + !byte $1F,%11100011 + !byte $1F,%01000010 + !byte $1F,%00000000 + !byte $69,%11100011 + !byte $9B,%10100101 + !byte $BF,%00010000 + !byte $1F,%00101010 + !byte $1F,%00001000 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $1F,%00100100 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $1F,%00000010 + !byte $1F,%10100001 + !byte $63,%00100010 + !byte $1F,%00001100 + !byte $1F,%11001001 + !byte $1F,%10100111 + !byte $1F,%00100010 + !byte $1F,%11000001 + !byte $1F,%10101001 + !byte $1F,%11100111 + !byte $1F,%11100001 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $8B,%00000110 + !byte $B3,%01110010 + !byte $B3,%10010011; + !byte $1F,%01000100 + !byte $1F,%00100000 + !byte $73,%00000110 + !byte $15,%01001100 + !byte $B9,%11010001 + !byte $0B,%10101101 + !byte $67,%10100011 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $B7,%00010010 + !byte $B1,%11010011 + !byte $6D,%01000100 + !byte $95,%11000101 + !byte $AF,%00000100 + !byte $61,%11100001 + !byte $5B,%00100000 + !byte $05,%11001101 + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $85,%00100110 + !byte $8F,%11100101 + !byte $9F,%01100100 + !byte $9F,%10000101; + !byte $BD,%01010000 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $99,%10100101 + !byte $19,%00101100 + !byte $B9,%11000011 + !byte $71,%11000101 + !byte $B3,%11100011 + !byte $BD,%10100011 + !byte $A9,%00100100 + !byte $5F,%10100001 + !byte $65,%01000010 + !byte $13,%01001100 + !byte $BB,%10110001 + !byte $6B,%00000100 + !byte $69,%11000011 + !byte $7F,%01000110 + !byte $89,%00000110 + !byte $A3,%01000100 + !byte $AD,%00000100 + !byte $75,%00100110 + !byte $5D,%01000000 + !byte $09,%10101101 + !byte $1D,%00001100 + !byte $BF,%00110000 + !byte $B5,%01010010 + !byte $B9,%11110001 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $9D,%01100100 + !byte $9D,%10000101; + !byte $79,%01100110 + !byte $79,%10000111; + !byte $83,%00100110 + !byte $93,%11000101 + !byte $A7,%00100100 + !byte $B7,%11000011 + !byte $63,%00000010 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $17,%00101100 + !byte $B1,%11100011 + !byte $73,%11100101 + !byte $03,%11001101 + !byte $8D,%11100101 + !byte $B3,%10110011 + !byte $6D,%00100100 + !byte $BB,%10100011 + !byte $97,%10100101 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $11,%01001100 + !byte $A1,%01000100 + !byte $BD,%01110000 + !byte $BD,%10010001; + !byte $5B,%00000000 + !byte $7D,%01000110 + !byte $61,%11000001 + !byte $07,%10101101 + !byte $B7,%00110010 + !byte $1B,%00001100 + !byte $87,%00000110 + !byte $B1,%11110011 + !byte $91,%11000101 + !byte $AB,%00000100 + !byte $6B,%11100011 + !byte $71,%10100101 + !byte $77,%01000110 + !byte $B5,%11000011 + !byte $BF,%01100010 + !byte $BF,%10000011; + !byte $01,%11001101 + !byte $BB,%11010001 + !byte $9B,%01100100 + !byte $9B,%10000101; + !byte $B5,%01110010 + !byte $B5,%10010011; + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $15,%00101100 + !byte $81,%00100110 + !byte $A5,%00100100 + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $65,%00100010 + !byte $75,%00000110 + !byte $B9,%10100011 + !byte $6F,%01000100 + !byte $8B,%11100101 + !byte $5D,%00100000 + !byte $69,%10100011 + !byte $05,%10101101 + !byte $A9,%00000100 + !byte $7B,%01000110 + !byte $95,%10100101 + !byte $1D,%11101011 + !byte $1D,%11001011 + !byte $1D,%10101011 + !byte $1D,%01001010 + !byte $1D,%10101001 + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $1D,%00101000 + !byte $1D,%00001000 + !byte $1D,%11100011 + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $1D,%01000010 + !byte $1D,%00000000 + !byte $0F,%01001100 + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $1D,%00101010 + !byte $1D,%11101001 + !byte $1D,%11001001 + !byte $1D,%01001000 + !byte $1D,%10100111 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $1D,%01000110 + !byte $1D,%00100110 + !byte $1D,%11100101 + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $1D,%01000100 + !byte $1D,%10100011 + !byte $1D,%00000010 + !byte $85,%00000110 + !byte $9F,%01000100 + !byte $AF,%11100011 + !byte $B9,%00010010 + !byte $B3,%11010011 + !byte $1D,%00001010 + !byte $1D,%00000110 + !byte $1D,%11000011 + !byte $1D,%00100010 + !byte $1D,%11000001 + !byte $1D,%01000000 + !byte $1D,%11100111 + !byte $1D,%11000111 + !byte $1D,%00100100 + !byte $1D,%00000100 + !byte $1D,%11100001 + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $19,%00001100 + !byte $BF,%01010000 + !byte $1D,%11000101 + !byte $1D,%10100101 + !byte $1D,%10100001 + !byte $1D,%00100000 + !byte $8F,%11000101 + !byte $B3,%11000011 + !byte $63,%11100001 + !byte $73,%11000101 + !byte $99,%01100100 + !byte $99,%10000101; + !byte $09,%01101100 + !byte $09,%10001101; + !byte $6D,%00000100 + !byte $7F,%00100110 + !byte $BD,%01100010 + !byte $BD,%10000011; + !byte $67,%01000010 + !byte $77,%00100110 + !byte $93,%10100101 + !byte $BD,%10110001 + !byte $B7,%01010010 + !byte $89,%11100101 + !byte $9D,%01000100 + !byte $A3,%00100100 + !byte $AD,%11100011 + !byte $61,%10100001 + !byte $71,%01100100 + !byte $71,%10000101; + !byte $13,%00101100 + !byte $79,%01000110 + !byte $5F,%01000000 + !byte $03,%10101101 + !byte $83,%00000110 + !byte $B5,%10110011 + !byte $6B,%11000011 + !byte $6F,%00100100 + !byte $0D,%01001100 + !byte $BB,%11110001 + !byte $A7,%00000100 + !byte $B7,%10100011 + !byte $65,%00000010 + !byte $17,%00001100 + !byte $7D,%00100110 + !byte $B1,%11000011 + !byte $B9,%00110010 + !byte $8D,%11000101 + !byte $97,%01100100 + !byte $97,%10000101; + !byte $A1,%00100100 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $75,%11100101 + !byte $BB,%01100010 + !byte $BB,%10000011; + !byte $07,%01101100 + !byte $07,%10001101; + !byte $AB,%11100011 + !byte $BF,%01110000 + !byte $BF,%10010001; + !byte $1B,%11101011 + !byte $11,%00101100 + !byte $91,%10100101 + !byte $B3,%11110011 + !byte $6D,%11100011 + !byte $73,%10100101 + !byte $87,%11100101 + !byte $A5,%00000100 + !byte $63,%11000001 + !byte $5D,%00000000 + !byte $01,%10101101 + !byte $81,%00000110 + !byte $B5,%10100011 + !byte $BF,%01000010 + !byte $BD,%11010001 + !byte $0B,%01001100 + !byte $AF,%11000011 + !byte $9B,%01000100 + !byte $B9,%01100010 + !byte $B9,%10000011; + !byte $B7,%01110010 + !byte $B7,%10010011; + !byte $77,%00000110 + !byte $15,%00001100 + !byte $8B,%11000101 + !byte $61,%01100000 + !byte $61,%10000001; + !byte $67,%00100010 + !byte $6B,%10100011 + !byte $65,%11100001 + !byte $95,%01100100 + !byte $95,%10000101; + !byte $5F,%00100000 + !byte $A9,%11100011 + !byte $71,%01000100 + !byte $05,%01101100 + !byte $05,%10001101; + !byte $0F,%00101100 + !byte $7B,%00100110 + !byte $B5,%11010011 + !byte $85,%11100101 + !byte $8F,%10100101 + !byte $9F,%00100100 + !byte $B3,%10100011 + !byte $6F,%00000100 + !byte $75,%11000101 + !byte $19,%11101011 + !byte $99,%01000100 + !byte $BB,%00010010 + !byte $63,%10100001 + !byte $7F,%00000110 + !byte $BD,%01000010 + !byte $09,%01001100 + !byte $BF,%10110001 + !byte $B9,%01010010 + !byte $13,%00001100 + !byte $69,%01000010 + !byte $1B,%11001011 + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $1B,%00101010 + !byte $1B,%00001010 + !byte $1B,%11001001 + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $1B,%01001000 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $1B,%01000110 + !byte $1B,%00000110 + !byte $1B,%11100101 + !byte $1B,%11000101 + !byte $1B,%10100101 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $1B,%01000100 + !byte $1B,%10100011 + !byte $1B,%00000010 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $B7,%01100010 + !byte $B7,%10000011; + !byte $1B,%10101011 + !byte $1B,%01001010 + !byte $1B,%10101001 + !byte $1B,%00101000 + !byte $1B,%00000100 + !byte $1B,%11000011 + !byte $1B,%01000010 + !byte $1B,%00100010 + !byte $1B,%11000001 + !byte $A3,%00000100 + !byte $1B,%11101001 + !byte $1B,%11000111 + !byte $1B,%10100111 + !byte $1B,%00100100 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $1B,%11100001 + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $1B,%00000000 + !byte $1B,%00100110 + !byte $1B,%10100001 + !byte $1B,%00100000 + !byte $93,%01100100 + !byte $93,%10000101; + !byte $BD,%11110001 + !byte $1B,%00001000 + !byte $1B,%11100111 + !byte $1B,%11100011 + !byte $1B,%01000000 + !byte $67,%00000010 + !byte $79,%00100110 + !byte $89,%11000101 + !byte $9D,%00100100 + !byte $AD,%11000011 + !byte $0D,%00101100 + !byte $B1,%10100011 + !byte $03,%01101100 + !byte $03,%10001101; + !byte $6D,%11000011 + !byte $17,%11101011 + !byte $83,%11100101 + !byte $A7,%11100011 + !byte $BB,%01000010 + !byte $07,%01001100 + !byte $7D,%00000110 + !byte $8D,%10100101 + !byte $97,%01000100 + !byte $61,%01000000 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $77,%11100101 + !byte $87,%11000101 + !byte $B7,%10110011 + !byte $65,%11000001 + !byte $71,%00100100 + !byte $A1,%00000100 + !byte $BB,%00110010 + !byte $11,%00001100 + !byte $9B,%00100100 + !byte $91,%01100100 + !byte $91,%10000101; + !byte $AB,%11000011 + !byte $B5,%11110011 + !byte $5F,%00000000 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $69,%00100010 + !byte $75,%10100101 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $6F,%11100011 + !byte $0B,%00101100 + !byte $A5,%11100011 + !byte $15,%11101011 + !byte $8B,%10100101 + !byte $AF,%10100011 + !byte $81,%11100101 + !byte $B9,%01000010 + !byte $BF,%00100010 + !byte $95,%01000100 + !byte $BF,%11010001 + !byte $B9,%01110010 + !byte $B9,%10010011; + !byte $B5,%01100010 + !byte $B5,%10000011; + !byte $79,%00000110 + !byte $6D,%10100011 + !byte $05,%01001100 + !byte $7B,%00000110 + !byte $9F,%00000100 + !byte $73,%01000100 + !byte $0F,%00001100 + !byte $85,%11000101 + !byte $A9,%11000011 + !byte $67,%11100001 + !byte $19,%11001011 + !byte $B7,%11010011 + !byte $BD,%00010010 + !byte $99,%00100100 + !byte $A3,%11100011 + !byte $AD,%10100011 + !byte $77,%11000101 + !byte $09,%00101100 + !byte $8F,%01100100 + !byte $8F,%10000101; + !byte $B3,%01100010 + !byte $B3,%10000011; + !byte $61,%00100000 + !byte $71,%00000100 + !byte $13,%11101011 + !byte $89,%10100101 + !byte $7F,%11100101 + !byte $BD,%00100010 + !byte $65,%10100001 + !byte $93,%01000100 + !byte $BB,%01010010 + !byte $6B,%01000010 + !byte $0D,%00001100 + !byte $A7,%11000011 + !byte $B7,%01000010 + !byte $9D,%00000100 + !byte $03,%01001100 + !byte $17,%11001011 + !byte $83,%11000101 + !byte $8D,%01100100 + !byte $8D,%10000101; + !byte $63,%01000000 + !byte $69,%00000010 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $BF,%11110001 + !byte $79,%11100101 + !byte $6F,%11000011 + !byte $B1,%01100010 + !byte $B1,%10000011; + !byte $19,%10101011 + !byte $19,%01001010 + !byte $19,%00001010 + !byte $19,%11101001 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $19,%00101000 + !byte $19,%00001000 + !byte $19,%11100111 + !byte $19,%00000100 + !byte $19,%11100011 + !byte $19,%11000001 + !byte $B9,%10110011 + !byte $19,%01101010 + !byte $19,%10001011; + !byte $19,%00101010 + !byte $19,%11001001 + !byte $19,%01001000 + !byte $19,%10100111 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $19,%01100010 + !byte $19,%10000011; + !byte $19,%01000010 + !byte $19,%11100001 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $BB,%00100010 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $19,%11100101 + !byte $19,%10100101 + !byte $19,%11000011 + !byte $19,%10100001 + !byte $19,%00100000 + !byte $19,%10101001 + !byte $19,%11000111 + !byte $19,%00100100 + !byte $19,%00100010 + !byte $19,%01000000 + !byte $19,%01000110 + !byte $19,%00100110 + !byte $19,%00000110 + !byte $19,%11000101 + !byte $19,%01000100 + !byte $19,%00000000 + !byte $73,%00100100 + !byte $07,%00101100 + !byte $7D,%11100101 + !byte $97,%00100100 + !byte $A1,%11100011 + !byte $19,%10100011 + !byte $19,%00000010 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $87,%10100101 + !byte $B5,%01000010 + !byte $AB,%10100011 + !byte $B7,%11110011 + !byte $11,%11101011 + !byte $9B,%00000100 + !byte $67,%11000001 + !byte $01,%01001100 + !byte $91,%01000100 + !byte $77,%10100101 + !byte $0B,%00001100 + !byte $81,%11000101 + !byte $BD,%00110010 + !byte $6B,%00100010 + !byte $AF,%01100010 + !byte $AF,%10000011; + !byte $61,%00000000 + !byte $8B,%01100100 + !byte $8B,%10000101; + !byte $BB,%01110010 + !byte $BB,%10010011; + !byte $A5,%11000011 + !byte $71,%11100011 + !byte $95,%00100100 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $15,%11001011 + !byte $B9,%00100010 + !byte $75,%01000100 + !byte $9F,%11100011 + !byte $B3,%01000010 + !byte $BF,%00010010 + !byte $7B,%11100101 + !byte $85,%10100101 + !byte $A9,%10100011 + !byte $BF,%00000010 + !byte $6F,%10100011 + !byte $8F,%01000100 + !byte $05,%00101100 + !byte $0F,%11101011 + !byte $63,%00100000 + !byte $69,%11100001 + !byte $67,%10100001 + !byte $09,%00001100 + !byte $7F,%11000101 + !byte $79,%11000101 + !byte $99,%00000100 + !byte $73,%00000100 + !byte $A3,%11000011 + !byte $AD,%01100010 + !byte $AD,%10000011; + !byte $B9,%11010011 + !byte $13,%11001011 + !byte $89,%01100100 + !byte $89,%10000101; + !byte $BD,%01010010 + !byte $6D,%01000010 + !byte $93,%00100100 + !byte $B7,%00100010 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $83,%10100101 + !byte $BD,%00000010 + !byte $A7,%10100011 + !byte $0D,%11101011 + !byte $9D,%11100011 + !byte $03,%00101100 + !byte $8D,%01000100 + !byte $97,%00000100 + !byte $6B,%00000010 + !byte $71,%11000011 + !byte $17,%10101011 + !byte $07,%00001100 + !byte $7D,%11000101 + !byte $BB,%10110011 + !byte $75,%00100100 + !byte $B1,%01000010 + !byte $65,%01000000 + !byte $69,%11000001 + !byte $91,%00100100 + !byte $11,%11001011 + !byte $87,%01100100 + !byte $87,%10000101; + !byte $BB,%00000010 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $9B,%11100011 + !byte $A1,%11000011 + !byte $B9,%11110011 + !byte $79,%10100101 + !byte $B5,%00100010 + !byte $BF,%11100001 + !byte $BF,%00110010 + !byte $63,%00000000 + !byte $AB,%01100010 + !byte $AB,%10000011; + !byte $17,%01101010 + !byte $17,%10001011; + !byte $17,%01001010 + !byte $17,%00101010 + !byte $17,%11101001 + !byte $17,%11001001 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $17,%01001000 + !byte $17,%11100111 + !byte $17,%11000111 + !byte $17,%10100111 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $17,%00000110 + !byte $17,%11100101 + !byte $17,%10100101 + !byte $17,%01100100 + !byte $17,%10000101; + !byte $17,%01000100 + !byte $17,%00100100 + !byte $17,%00000100 + !byte $17,%01000000 + !byte $01,%00101100 + !byte $BD,%01110010 + !byte $BD,%10010011; + !byte $17,%00001010 + !byte $17,%10101001 + !byte $17,%00101000 + !byte $17,%11000101 + !byte $17,%11000011 + !byte $17,%10100011 + !byte $17,%00000010 + !byte $17,%10100001 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $0B,%11101011 + !byte $81,%10100101 + !byte $17,%00001000 + !byte $17,%00100010 + !byte $17,%01000110 + !byte $17,%00100110 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $17,%11100001 + !byte $17,%00000000 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $15,%10101011 + !byte $17,%11100011 + !byte $17,%00100000 + !byte $6D,%00100010 + !byte $8B,%01000100 + !byte $95,%00000100 + !byte $A5,%10100011 + !byte $AF,%01000010 + !byte $17,%01000010 + !byte $17,%11000001 + !byte $73,%11100011 + !byte $9F,%11000011 + !byte $05,%00001100 + !byte $B9,%00000010 + !byte $65,%00100000 + !byte $6B,%11100001 + !byte $71,%10100011 + !byte $77,%01000100 + !byte $0F,%11001011 + !byte $B3,%00100010 + !byte $7B,%11000101 + !byte $85,%01100100 + !byte $85,%10000101; + !byte $A9,%01100010 + !byte $A9,%10000011; + !byte $8F,%00100100 + !byte $BD,%11100001 + !byte $75,%00000100 + !byte $13,%10101011 + !byte $6F,%01000010 + !byte $09,%11101011 + !byte $7F,%10100101 + !byte $99,%11100011 + !byte $A3,%10100011 + !byte $AD,%01000010 + !byte $BB,%11010011 + !byte $69,%10100001 + !byte $9D,%11000011 + !byte $89,%01000100 + !byte $6D,%00000010 + !byte $0D,%11001011 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $93,%00000100 + !byte $B7,%00000010 + !byte $03,%00001100 + !byte $A7,%01100010 + !byte $A7,%10000011; + !byte $BF,%01010010 + !byte $83,%01100100 + !byte $83,%10000101; + !byte $BB,%11100001 + !byte $BD,%10110011 + !byte $73,%11000011 + !byte $8D,%00100100 + !byte $67,%01000000 + !byte $97,%11100011 + !byte $A1,%10100011 + !byte $77,%00100100 + !byte $07,%11101011 + !byte $7D,%10100101 + !byte $AB,%01000010 + !byte $65,%00000000 + !byte $11,%10101011 + !byte $91,%00000100 + !byte $87,%01000100 + !byte $B1,%00100010 + !byte $B5,%00000010 + !byte $BF,%11000001 + !byte $BB,%11110011 + !byte $71,%01100010 + !byte $71,%10000011; + !byte $6B,%11000001 + !byte $7B,%10100101 + !byte $0B,%11001011 + !byte $A5,%01100010 + !byte $A5,%10000011; + !byte $01,%00001100 + !byte $9B,%11000011 + !byte $81,%01100100 + !byte $81,%10000101; + !byte $69,%01100000 + !byte $69,%10000001; + !byte $75,%11100011 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $6F,%00100010 + !byte $8B,%00100100 + !byte $95,%11100011 + !byte $AF,%00100010 + !byte $BF,%01110010 + !byte $BF,%10010011; + !byte $79,%01000100 + !byte $85,%01000100 + !byte $05,%11101011 + !byte $9F,%10100011 + !byte $B3,%00000010 + !byte $15,%01001010 + !byte $15,%00101010 + !byte $15,%00001010 + !byte $15,%11001001 + !byte $15,%10101001 + !byte $15,%00101000 + !byte $15,%00001000 + !byte $15,%01000110 + !byte $15,%11100101 + !byte $15,%11000101 + !byte $15,%11000011 + !byte $15,%10100011 + !byte $15,%11100001 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $15,%00000000 + !byte $73,%10100011 + !byte $99,%11000011 + !byte $15,%11101001 + !byte $15,%01101000 + !byte $15,%10001001; + !byte $15,%10100111 + !byte $15,%00000100 + !byte $15,%10100001 + !byte $15,%00100000 + !byte $0F,%10101011 + !byte $8F,%00000100 + !byte $BD,%11000001 + !byte $15,%00100110 + !byte $15,%00000110 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $15,%00100100 + !byte $15,%01100010 + !byte $15,%10000011; + !byte $15,%01000010 + !byte $67,%00100000 + !byte $15,%11100111 + !byte $15,%00000010 + !byte $6D,%11100001 + !byte $15,%11000111 + !byte $15,%11100011 + !byte $15,%00100010 + !byte $15,%11000001 + !byte $A9,%01000010 + !byte $15,%01001000 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $15,%10100101 + !byte $15,%01000100 + !byte $15,%01000000 + !byte $77,%00000100 + !byte $09,%11001011 + !byte $89,%00100100 + !byte $BD,%11010011 + !byte $B9,%11100001 + !byte $93,%11100011 + !byte $71,%01000010 + !byte $13,%01101010 + !byte $13,%10001011; + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $A3,%01100010 + !byte $A3,%10000011; + !byte $AD,%00100010 + !byte $6B,%10100001 + !byte $83,%01000100 + !byte $9D,%10100011 + !byte $03,%11101011 + !byte $0D,%10101011 + !byte $A7,%01000010 + !byte $B7,%11100001 + !byte $6F,%00000010 + !byte $B1,%00000010 + !byte $BF,%10110011 + !byte $75,%11000011 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $8D,%00000100 + !byte $97,%11000011 + !byte $07,%11001011 + !byte $BB,%11000001 + !byte $AB,%00100010 + !byte $69,%01000000 + !byte $87,%00100100 + !byte $A1,%01100010 + !byte $A1,%10000011; + !byte $79,%00100100 + !byte $11,%01101010 + !byte $11,%10001011; + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $91,%11100011 + !byte $BD,%11110011 + !byte $6D,%11000001 + !byte $0B,%10101011 + !byte $B5,%11100001 + !byte $BF,%10100001 + !byte $67,%00000000 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $71,%00100010 + !byte $81,%01000100 + !byte $8B,%00000100 + !byte $A5,%01000010 + !byte $AF,%00000010 + !byte $9B,%10100011 + !byte $01,%11101011 + !byte $77,%11100011 + !byte $05,%11001011 + !byte $B9,%11000001 + !byte $7B,%01000100 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $A9,%00100010 + !byte $95,%11000011 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $85,%00100100 + !byte $9F,%01100010 + !byte $9F,%10000011; + !byte $B3,%11100001 + !byte $6F,%11100001 + !byte $75,%10100011 + !byte $99,%10100011 + !byte $09,%10101011 + !byte $8F,%11100011 + !byte $BD,%10100001 + !byte $79,%00000100 + !byte $13,%01001010 + !byte $7F,%01000100 + !byte $BF,%11010011 + !byte $89,%00000100 + !byte $B7,%11000001 + !byte $93,%11000011 + !byte $A3,%01000010 + !byte $69,%00100000 + !byte $13,%00001010 + !byte $13,%11101001 + !byte $13,%10101001 + !byte $13,%01101000 + !byte $13,%10001001; + !byte $13,%00001000 + !byte $13,%11100111 + !byte $13,%00000100 + !byte $13,%11100011 + !byte $13,%11000011 + !byte $13,%00100010 + !byte $13,%10100001 + !byte $13,%00100000 + !byte $03,%11001011 + !byte $13,%11001001 + !byte $13,%01001000 + !byte $13,%00101000 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $13,%00000110 + !byte $13,%10100101 + !byte $13,%01100100 + !byte $13,%10000101; + !byte $13,%01000100 + !byte $13,%01000010 + !byte $13,%11000001 + !byte $13,%01000000 + !byte $73,%01000010 + !byte $9D,%01100010 + !byte $9D,%10000011; + !byte $AD,%00000010 + !byte $13,%00101010 + !byte $13,%11100101 + !byte $13,%00000010 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $13,%11000111 + !byte $13,%10100111 + !byte $13,%00100100 + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $13,%01000110 + !byte $13,%00100110 + !byte $13,%11000101 + !byte $13,%01100010 + !byte $13,%10000011; + !byte $13,%11100001 + !byte $83,%00100100 + !byte $13,%10100011 + !byte $13,%00000000 + !byte $8D,%11100011 + !byte $6D,%10100001 + !byte $B1,%11100001 + !byte $71,%00000010 + !byte $6B,%01000000 + !byte $77,%11000011 + !byte $07,%10101011 + !byte $A7,%00100010 + !byte $BB,%10100001 + !byte $7D,%01000100 + !byte $97,%10100011 + !byte $A1,%01000010 + !byte $B5,%11000001 + !byte $87,%00000100 + !byte $AB,%00000010 + !byte $9B,%01100010 + !byte $9B,%10000011; + !byte $69,%00000000 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $7B,%00100100 + !byte $11,%01001010 + !byte $91,%11000011 + !byte $01,%11001011 + !byte $A5,%00100010 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $6F,%11000001 + !byte $81,%00100100 + !byte $8B,%11100011 + !byte $73,%00100010 + !byte $95,%10100011 + !byte $AF,%11100001 + !byte $BF,%11110011 + !byte $B9,%10100001 + !byte $9F,%01000010 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $05,%10101011 + !byte $BF,%01100000 + !byte $BF,%10000001; + !byte $79,%11100011 + !byte $0F,%01001010 + !byte $77,%10100011 + !byte $8F,%11000011 + !byte $A9,%00000010 + !byte $85,%00000100 + !byte $99,%01100010 + !byte $99,%10000011; + !byte $A3,%00100010 + !byte $AD,%11100001 + !byte $6B,%00100000 + !byte $7F,%00100100 + !byte $B3,%11000001 + !byte $71,%11100001 + !byte $7B,%00000100 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $89,%11100011 + !byte $BD,%01100000 + !byte $BD,%10000001; + !byte $6F,%10100001 + !byte $03,%10101011 + !byte $93,%10100011 + !byte $75,%01000010 + !byte $A7,%00000010 + !byte $B7,%10100001 + !byte $0D,%01001010 + !byte $9D,%01000010 + !byte $97,%01100010 + !byte $97,%10000011; + !byte $83,%00000100 + !byte $8D,%11000011 + !byte $79,%11000011 + !byte $B1,%11000001 + !byte $73,%00000010 + !byte $11,%00101010 + !byte $11,%11101001 + !byte $11,%11001001 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $11,%01001000 + !byte $11,%11000111 + !byte $11,%01100110 + !byte $11,%10000111; + !byte $11,%01000110 + !byte $11,%00100110 + !byte $11,%00000110 + !byte $11,%11100101 + !byte $11,%01100100 + !byte $11,%10000101; + !byte $11,%01000100 + !byte $11,%00000100 + !byte $11,%01000010 + !byte $11,%00100010 + !byte $11,%10101001 + !byte $11,%00101000 + !byte $11,%00001000 + !byte $11,%10100011 + !byte $11,%11100001 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $11,%00000000 + !byte $7D,%00100100 + !byte $BB,%01100000 + !byte $BB,%10000001; + !byte $11,%00001010 + !byte $11,%10100111 + !byte $11,%11000011 + !byte $11,%00000010 + !byte $11,%00100000 + !byte $11,%11000101 + !byte $11,%10100101 + !byte $11,%00100100 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $11,%11000001 + !byte $11,%01000000 + !byte $91,%10100011 + !byte $11,%11100111 + !byte $6D,%01000000 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $A1,%00100010 + !byte $11,%11100011 + !byte $11,%10100001 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $B5,%10100001 + !byte $BF,%01000000 + !byte $87,%11100011 + !byte $AB,%11100001 + !byte $6B,%00000000 + !byte $9B,%01000010 + !byte $71,%11000001 + !byte $01,%10101011 + !byte $0B,%01001010 + !byte $A5,%00000010 + !byte $AF,%11000001 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $81,%00000100 + !byte $8B,%11000011 + !byte $95,%01100010 + !byte $95,%10000011; + !byte $9F,%00100010 + !byte $75,%00100010 + !byte $0F,%00101010 + !byte $7B,%11100011 + !byte $B9,%01100000 + !byte $B9,%10000001; + !byte $85,%11100011 + !byte $B3,%10100001 + !byte $8F,%10100011 + !byte $A9,%11100001 + !byte $05,%01101010 + !byte $05,%10001011; + !byte $BD,%01000000 + !byte $73,%11100001 + !byte $79,%10100011 + !byte $6D,%00100000 + !byte $7F,%00000100 + !byte $A3,%00000010 + !byte $09,%01001010 + !byte $89,%11000011 + !byte $99,%01000010 + !byte $71,%10100001 + !byte $77,%01000010 + !byte $7D,%00000100 + !byte $9D,%00100010 + !byte $AD,%11000001 + !byte $B7,%01100000 + !byte $B7,%10000001; + !byte $03,%01101010 + !byte $03,%10001011; + !byte $83,%11100011 + !byte $93,%01100010 + !byte $93,%10000011; + !byte $7B,%11000011 + !byte $A7,%11100001 + !byte $BB,%01000000 + !byte $0D,%00101010 + !byte $97,%01000010 + !byte $A1,%00000010 + !byte $8D,%10100011 + !byte $6F,%01000000 + !byte $07,%01001010 + !byte $AB,%11000001 + !byte $75,%00000010 + !byte $87,%11000011 + !byte $91,%01100010 + !byte $91,%10000011; + !byte $B1,%10100001 + !byte $B5,%01100000 + !byte $B5,%10000001; + !byte $A5,%11100001 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $9B,%00100010 + !byte $BF,%00100000 + !byte $6D,%00000000 + !byte $73,%11000001 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $81,%11100011 + !byte $0F,%11001001 + !byte $0F,%01001000 + !byte $0F,%00101000 + !byte $0F,%00001000 + !byte $0F,%01000110 + !byte $0F,%00000110 + !byte $0F,%11100101 + !byte $0F,%11000101 + !byte $0F,%01000100 + !byte $0F,%10100011 + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $0F,%11100001 + !byte $0F,%11000001 + !byte $8B,%10100011 + !byte $B9,%01000000 + !byte $0F,%00001010 + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $0F,%11100111 + !byte $0F,%11000111 + !byte $0F,%11100011 + !byte $0F,%00000000 + !byte $0B,%00101010 + !byte $0F,%11101001 + !byte $0F,%10100111 + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $0F,%10100101 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $0F,%01000010 + !byte $0F,%10100001 + !byte $0F,%00100000 + !byte $0F,%10101001 + !byte $0F,%00100110 + !byte $0F,%01000000 + !byte $0F,%00000100 + !byte $0F,%11000011 + !byte $0F,%00100010 + !byte $0F,%00000010 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $7D,%11100011 + !byte $AF,%10100001 + !byte $0F,%00100100 + !byte $05,%01001010 + !byte $85,%11000011 + !byte $95,%01000010 + !byte $77,%00100010 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $9F,%00000010 + !byte $B3,%01100000 + !byte $B3,%10000001; + !byte $99,%00100010 + !byte $8F,%01100010 + !byte $8F,%10000011; + !byte $A9,%11000001 + !byte $BD,%00100000 + !byte $7F,%11100011 + !byte $7B,%10100011 + !byte $75,%11100001 + !byte $09,%00101010 + !byte $89,%10100011 + !byte $A3,%11100001 + !byte $6F,%00100000 + !byte $93,%01000010 + !byte $AD,%10100001 + !byte $79,%01000010 + !byte $73,%10100001 + !byte $03,%01001010 + !byte $0D,%00001010 + !byte $9D,%00000010 + !byte $83,%11000011 + !byte $A7,%11000001 + !byte $8D,%01100010 + !byte $8D,%10000011; + !byte $B1,%01100000 + !byte $B1,%10000001; + !byte $B7,%01000000 + !byte $7D,%11000011 + !byte $77,%00000010 + !byte $97,%00100010 + !byte $A1,%11100001 + !byte $BB,%00100000 + !byte $07,%00101010 + !byte $AB,%10100001 + !byte $87,%10100011 + !byte $71,%01000000 + !byte $91,%01000010 + !byte $75,%11000001 + !byte $01,%01001010 + !byte $0B,%00001010 + !byte $AF,%01100000 + !byte $AF,%10000001; + !byte $B5,%01000000 + !byte $BF,%00000000 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $A5,%11000001 + !byte $81,%11000011 + !byte $8B,%01100010 + !byte $8B,%10000011; + !byte $9B,%00000010 + !byte $95,%00100010 + !byte $9F,%11100001 + !byte $B9,%00100000 + !byte $6F,%00000000 + !byte $A9,%10100001 + !byte $05,%00101010 + !byte $8F,%01000010 + !byte $79,%00100010 + !byte $73,%01100000 + !byte $73,%10000001; + !byte $0D,%11001001 + !byte $0D,%10101001 + !byte $0D,%00101000 + !byte $0D,%00001000 + !byte $0D,%11100111 + !byte $0D,%10100011 + !byte $0D,%00000010 + !byte $0D,%11100001 + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $A3,%11000001 + !byte $0D,%11101001 + !byte $0D,%01001000 + !byte $0D,%11000111 + !byte $0D,%10100111 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $0D,%00000100 + !byte $0D,%11100011 + !byte $0D,%00100010 + !byte $0D,%10100001 + !byte $85,%10100011 + !byte $99,%00000010 + !byte $B3,%01000000 + !byte $0D,%01000110 + !byte $0D,%00100110 + !byte $0D,%11100101 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $0D,%01000100 + !byte $0D,%01000010 + !byte $0D,%01000000 + !byte $0D,%11000011 + !byte $0D,%00000000 + !byte $77,%11100001 + !byte $09,%00001010 + !byte $7F,%11000011 + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $0D,%00100100 + !byte $0D,%00100000 + !byte $71,%00100000 + !byte $7D,%10100011 + !byte $BD,%00000000 + !byte $0D,%00000110 + !byte $0D,%11000101 + !byte $0D,%10100101 + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $0D,%11000001 + !byte $B7,%00100000 + !byte $89,%01100010 + !byte $89,%10000011; + !byte $93,%00100010 + !byte $83,%10100011 + !byte $03,%00101010 + !byte $9D,%11100001 + !byte $AD,%01100000 + !byte $AD,%10000001; + !byte $7B,%01000010 + !byte $8D,%01000010 + !byte $75,%10100001 + !byte $A7,%10100001 + !byte $B1,%01000000 + !byte $BB,%00000000 + !byte $07,%00001010 + !byte $87,%01100010 + !byte $87,%10000011; + !byte $73,%01000000 + !byte $97,%00000010 + !byte $A1,%11000001 + !byte $79,%00000010 + !byte $91,%00100010 + !byte $B5,%00100000 + !byte $AB,%01100000 + !byte $AB,%10000001; + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $9B,%11100001 + !byte $0B,%11101001 + !byte $81,%10100011 + !byte $01,%00101010 + !byte $A5,%10100001 + !byte $AF,%01000000 + !byte $77,%11000001 + !byte $95,%00000010 + !byte $71,%00000000 + !byte $8B,%01000010 + !byte $B9,%00000000 + !byte $9F,%11000001 + !byte $B3,%00100000 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $7B,%00100010 + !byte $A9,%01100000 + !byte $A9,%10000001; + !byte $05,%00001010 + !byte $85,%01100010 + !byte $85,%10000011; + !byte $8F,%00100010 + !byte $79,%11100001 + !byte $73,%00100000 + !byte $7F,%10100011 + !byte $99,%11100001 + !byte $09,%11101001 + !byte $89,%01000010 + !byte $A3,%10100001 + !byte $AD,%01000000 + !byte $B7,%00000000 + !byte $0B,%11001001 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $0B,%00001000 + !byte $0B,%11100111 + !byte $0B,%11000111 + !byte $0B,%11100011 + !byte $0B,%11000011 + !byte $0B,%00100010 + !byte $0B,%00000010 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $0B,%10100111 + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $0B,%01000110 + !byte $0B,%00100110 + !byte $0B,%11000101 + !byte $0B,%01000100 + !byte $0B,%00100000 + !byte $77,%10100001 + !byte $93,%00000010 + !byte $0B,%10101001 + !byte $0B,%00101000 + !byte $0B,%00000110 + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $0B,%11100001 + !byte $0B,%01000000 + !byte $0B,%00100100 + !byte $0B,%00000100 + !byte $0B,%10100001 + !byte $0B,%00000000 + !byte $03,%00001010 + !byte $A7,%01100000 + !byte $A7,%10000001; + !byte $0B,%01001000 + !byte $0B,%11100101 + !byte $0B,%10100101 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $0B,%01000010 + !byte $0B,%11000001 + !byte $83,%01100010 + !byte $83,%10000011; + !byte $9D,%11000001 + !byte $0B,%10100011 + !byte $7D,%01000010 + !byte $A1,%10100001 + !byte $75,%01000000 + !byte $97,%11100001 + !byte $AB,%01000000 + !byte $8D,%00100010 + !byte $B1,%00100000 + !byte $7B,%00000010 + !byte $07,%11101001 + !byte $87,%01000010 + !byte $91,%00000010 + !byte $B5,%00000000 + !byte $79,%11000001 + !byte $9B,%11000001 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $01,%00001010 + !byte $8B,%00100010 + !byte $81,%01100010 + !byte $81,%10000011; + !byte $AF,%00100000 + !byte $73,%00000000 + !byte $A5,%01100000 + !byte $A5,%10000001; + !byte $77,%01100000 + !byte $77,%10000001; + !byte $05,%11101001 + !byte $95,%11100001 + !byte $9F,%10100001 + !byte $7D,%00100010 + !byte $85,%01000010 + !byte $A9,%01000000 + !byte $99,%11000001 + !byte $B3,%00000000 + !byte $8F,%00000010 + !byte $09,%11001001 + !byte $A3,%01100000 + !byte $A3,%10000001; + !byte $75,%00100000 + !byte $89,%00100010 + !byte $AD,%00100000 + !byte $93,%11100001 + !byte $7B,%11100001 + !byte $03,%11101001 + !byte $83,%01000010 + !byte $9D,%10100001 + !byte $7F,%01000010 + !byte $A7,%01000000 + !byte $79,%10100001 + !byte $B1,%00000000 + !byte $8D,%00000010 + !byte $07,%11001001 + !byte $97,%11000001 + !byte $09,%10101001 + !byte $09,%11100111 + !byte $09,%11000111 + !byte $09,%10100111 + !byte $09,%01000100 + !byte $09,%00100100 + !byte $09,%00100010 + !byte $09,%00000010 + !byte $09,%10100001 + !byte $09,%00000000 + !byte $A1,%01100000 + !byte $A1,%10000001; + !byte $09,%01101000 + !byte $09,%10001001; + !byte $09,%01001000 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $09,%01000110 + !byte $09,%00100110 + !byte $09,%00000110 + !byte $09,%10100101 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $09,%01000010 + !byte $09,%11000001 + !byte $09,%00100000 + !byte $09,%00001000 + !byte $09,%11100011 + !byte $09,%11100001 + !byte $77,%01000000 + !byte $7D,%00000010 + !byte $09,%01100100 + !byte $09,%10000101; + !byte $09,%00000100 + !byte $AB,%00100000 + !byte $09,%00101000 + !byte $09,%11100101 + !byte $09,%11000101 + !byte $09,%10100011 + !byte $09,%01000000 + !byte $87,%00100010 + !byte $09,%11000011 + !byte $09,%01100000 + !byte $09,%10000001; + !byte $01,%11101001 + !byte $91,%11100001 + !byte $81,%01000010 + !byte $A5,%01000000 + !byte $9B,%10100001 + !byte $95,%11000001 + !byte $9F,%01100000 + !byte $9F,%10000001; + !byte $8B,%00000010 + !byte $7B,%11000001 + !byte $05,%11001001 + !byte $75,%00000000 + !byte $85,%00100010 + !byte $A9,%00100000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $7F,%00100010 + !byte $8F,%11100001 + !byte $99,%10100001 + !byte $AF,%00000000 + !byte $89,%00000010 + !byte $77,%00100000 + !byte $7D,%11100001 + !byte $03,%11001001 + !byte $93,%11000001 + !byte $A3,%01000000 + !byte $AD,%00000000 + !byte $83,%00100010 + !byte $9D,%01100000 + !byte $9D,%10000001; + !byte $97,%10100001 + !byte $7B,%10100001 + !byte $8D,%11100001 + !byte $A7,%00100000 + !byte $87,%00000010 + !byte $A1,%01000000 + !byte $79,%01000000 + !byte $7F,%00000010 + !byte $07,%10101001 + !byte $AB,%00000000 + !byte $91,%11000001 + !byte $01,%11001001 + !byte $9B,%01100000 + !byte $9B,%10000001; + !byte $8B,%11100001 + !byte $81,%00100010 + !byte $A5,%00100000 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $07,%01001000 + !byte $07,%11000111 + !byte $07,%10100111 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $07,%00000110 + !byte $07,%11100101 + !byte $07,%10100101 + !byte $07,%01000100 + !byte $07,%00100100 + !byte $07,%00000100 + !byte $07,%01000010 + !byte $07,%10100001 + !byte $07,%00100000 + !byte $7D,%11000001 + !byte $07,%00101000 + !byte $07,%00100110 + !byte $07,%01100010 + !byte $07,%10000011; + !byte $95,%10100001 + !byte $07,%11100111 + !byte $07,%11100011 + !byte $07,%11000011 + !byte $07,%00000010 + !byte $07,%01100000 + !byte $07,%10000001; + !byte $07,%01000110 + !byte $07,%11000101 + !byte $07,%01100100 + !byte $07,%10000101; + !byte $07,%00100010 + !byte $07,%11000001 + !byte $07,%00001000 + !byte $07,%10100011 + !byte $07,%11100001 + !byte $07,%01000000 + !byte $77,%00000000 + !byte $A9,%00000000 + !byte $07,%00000000 + !byte $9F,%01000000 + !byte $05,%10101001 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $85,%00000010 + !byte $8F,%11000001 + !byte $7F,%11100001 + !byte $A3,%00100000 + !byte $89,%11100001 + !byte $99,%01100000 + !byte $99,%10000001; + !byte $93,%10100001 + !byte $9D,%01000000 + !byte $79,%00100000 + !byte $83,%00000010 + !byte $A7,%00000000 + !byte $03,%10101001 + !byte $8D,%11000001 + !byte $97,%01100000 + !byte $97,%10000001; + !byte $A1,%00100000 + !byte $7D,%10100001 + !byte $7B,%01000000 + !byte $81,%00000010 + !byte $87,%11100001 + !byte $91,%10100001 + !byte $01,%10101001 + !byte $9B,%01000000 + !byte $95,%01100000 + !byte $95,%10000001; + !byte $8B,%11000001 + !byte $A5,%00000000 + !byte $79,%00000000 + !byte $7F,%11000001 + !byte $05,%01101000 + !byte $05,%10001001; + !byte $85,%11100001 + !byte $8F,%10100001 + !byte $9F,%00100000 + !byte $05,%01001000 + !byte $05,%11000111 + !byte $05,%10100111 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $05,%01000110 + !byte $05,%11100101 + !byte $05,%11000101 + !byte $05,%01100100 + !byte $05,%10000101; + !byte $05,%11000001 + !byte $05,%10100001 + !byte $05,%00100000 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $99,%01000000 + !byte $05,%00101000 + !byte $05,%00001000 + !byte $05,%11000011 + !byte $05,%11100001 + !byte $05,%01000000 + !byte $05,%00100100 + !byte $05,%01100000 + !byte $05,%10000001; + !byte $05,%00100110 + !byte $05,%00000110 + !byte $05,%10100101 + !byte $05,%01000100 + !byte $05,%01100010 + !byte $05,%10000011; + !byte $05,%01000010 + !byte $05,%11100111 + !byte $05,%11100011 + !byte $05,%10100011 + !byte $05,%00000010 + !byte $A3,%00000000 + !byte $05,%00000100 + !byte $05,%00100010 + !byte $05,%00000000 + !byte $81,%11100001 + !byte $93,%01100000 + !byte $93,%10000001; + !byte $9D,%00100000 + !byte $7B,%00100000 + !byte $89,%11000001 + !byte $03,%01101000 + !byte $03,%10001001; + !byte $83,%11100001 + !byte $8D,%10100001 + !byte $A1,%00000000 + !byte $7F,%10100001 + !byte $97,%01000000 + !byte $87,%11000001 + !byte $91,%01100000 + !byte $91,%10000001; + !byte $7D,%01000000 + !byte $9B,%00100000 + !byte $8B,%10100001 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $95,%01000000 + !byte $9F,%00000000 + !byte $7B,%00000000 + !byte $81,%11000001 + !byte $85,%11000001 + !byte $8F,%01100000 + !byte $8F,%10000001; + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $99,%00100000 + !byte $89,%10100001 + !byte $7D,%00100000 + !byte $03,%01001000 + !byte $83,%11000001 + !byte $03,%00101000 + !byte $03,%10100111 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $03,%01000110 + !byte $03,%00100110 + !byte $03,%11000101 + !byte $03,%10100101 + !byte $03,%01000100 + !byte $03,%00100000 + !byte $8D,%01100000 + !byte $8D,%10000001; + !byte $03,%00001000 + !byte $03,%11100111 + !byte $03,%10100011 + !byte $03,%00000010 + !byte $03,%11100001 + !byte $93,%01000000 + !byte $9D,%00000000 + !byte $03,%00000110 + !byte $03,%01100100 + !byte $03,%10000101; + !byte $03,%00000100 + !byte $03,%01000010 + !byte $03,%10100001 + !byte $03,%00000000 + !byte $03,%11100101 + !byte $03,%01100010 + !byte $03,%10000011; + !byte $03,%11000001 + !byte $03,%11000111 + !byte $03,%11100011 + !byte $03,%11000011 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $03,%01000000 + !byte $03,%00100100 + !byte $03,%00100010 + !byte $81,%10100001 + !byte $97,%00100000 + !byte $7F,%01000000 + !byte $91,%01000000 + !byte $01,%01001000 + !byte $87,%10100001 + !byte $9B,%00000000 + !byte $8B,%01100000 + !byte $8B,%10000001; + !byte $7D,%00000000 + !byte $95,%00100000 + !byte $85,%10100001 + !byte $8F,%01000000 + !byte $99,%00000000 + !byte $81,%01100000 + !byte $81,%10000001; + !byte $93,%00100000 + !byte $7F,%00100000 + !byte $89,%01100000 + !byte $89,%10000001; + !byte $83,%10100001 + !byte $8D,%01000000 + !byte $97,%00000000 + !byte $01,%00101000 + !byte $01,%01100110 + !byte $01,%10000111; + !byte $01,%01000110 + !byte $01,%00100110 + !byte $01,%00000110 + !byte $01,%10100101 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $01,%10100011 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $01,%11100001 + !byte $01,%11000001 + !byte $01,%01000000 + !byte $01,%00100000 + !byte $81,%01000000 + !byte $87,%01100000 + !byte $87,%10000001; + !byte $01,%11100111 + !byte $01,%11000111 + !byte $01,%11100011 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $01,%11100101 + !byte $01,%01000100 + !byte $01,%00100100 + !byte $01,%01000010 + !byte $01,%00100010 + !byte $01,%00000000 + !byte $01,%11000101 + !byte $01,%00001000 + !byte $01,%10100111 + !byte $01,%00000100 + !byte $01,%11000011 + !byte $01,%00000010 + !byte $01,%10100001 + !byte $91,%00100000 + !byte $95,%00000000 + !byte $8B,%01000000 + !byte $7F,%00000000 + !byte $85,%01100000 + !byte $85,%10000001; + !byte $8F,%00100000 + !byte $83,%01100000 + !byte $83,%10000001; + !byte $89,%01000000 + !byte $93,%00000000 + !byte $81,%00100000 + !byte $8D,%00100000 + !byte $91,%00000000 + !byte $87,%01000000 + !byte $83,%01000000 + !byte $8B,%00100000 + !byte $81,%00000000 + !byte $85,%01000000 + !byte $8F,%00000000 + !byte $89,%00100000 + !byte $83,%00100000 + !byte $8D,%00000000 + !byte $87,%00100000 + !byte $8B,%00000000 + !byte $83,%00000000 + !byte $85,%00100000 + !byte $89,%00000000 + !byte $87,%00000000 + !byte $85,%00000000 diff --git a/src/fx/fx.hgr.star.in.a b/src/fx/fx.hgr.star.in.a new file mode 100644 index 0000000..e0eeab1 --- /dev/null +++ b/src/fx/fx.hgr.star.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/STAR.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.hgr.star.ripple.a b/src/fx/fx.hgr.star.ripple.a new file mode 100644 index 0000000..2ac2b82 --- /dev/null +++ b/src/fx/fx.hgr.star.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/STAR.RIPPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 12 + !text "FX/STAR.DATA" diff --git a/src/fx/fx.hgr.swirl.a b/src/fx/fx.hgr.swirl.a new file mode 100644 index 0000000..0cf9d92 --- /dev/null +++ b/src/fx/fx.hgr.swirl.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/SWIRL",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + + +FX_INITONCE_1BIT CoordinatesFile, Start + +FX_RIPPLE_1BIT aslmod4 +Start + +FX_PRECOMPUTED_1BIT Coordinates1Bit + +CoordinatesFile + !byte 15 + !text "FX/CORNER4.DATA" diff --git a/src/fx/fx.hgr.tri.fizzle.a b/src/fx/fx.hgr.tri.fizzle.a new file mode 100644 index 0000000..f831211 --- /dev/null +++ b/src/fx/fx.hgr.tri.fizzle.a @@ -0,0 +1,113 @@ +;license:MIT +;(c) 2018 by 4am +; +!cpu 6502 +!to "build/FX/TRI.FIZZLE",plain +*=$6000 + +phase = $FC ; byte, $80 or $00 +maskindex = $FD ; byte + + !source "src/fx/fx.hgr.block.fizzle.common.a" + + +BUILD_BLOCK_FIZZLE_DATA + + lda #$80 + sta phase + lda #0 + sta maskindex +@outerloop + +LDADDR Coordinates + +ST16 coord +@loop + dec maskindex + bpl + + lda #3 + sta maskindex ++ ldx maskindex + lda maskslo,x + ldy maskshi,x + jsr SetCopyMask + ldy #0 + lda (coord),y + bmi @nextPhase + tax + iny + lda (coord),y + tay + txa + bit phase + bmi + + jsr HGRBlockCopy + jmp @wait ++ jsr HGRBlockCopyWithMask +@wait + lda #$0C + jsr WaitForKeyWithTimeout + bmi @exit + inc coord + bne + + inc coord+1 ++ inc coord + bne + + inc coord+1 ++ bne @loop +@nextPhase + bit phase + bpl @exit + asl phase + bcs @outerloop ; always branches +@exit rts + +maskslo + !byte mask1 + !byte >mask2 + !byte >mask3 + !byte >mask4 + +mask1 + !byte %11111111 + !byte %11111110 + !byte %11111100 + !byte %11111000 + !byte %11110000 + !byte %11100000 + !byte %11000000 + !byte %10000000 +mask2 + !byte %11111111 + !byte %10111111 + !byte %10011111 + !byte %10001111 + !byte %10000111 + !byte %10000011 + !byte %10000001 + !byte %10000000 +mask3 + !byte %10000000 + !byte %10000001 + !byte %10000011 + !byte %10000111 + !byte %10001111 + !byte %10011111 + !byte %10111111 + !byte %11111111 +mask4 + !byte %10000000 + !byte %11000000 + !byte %11100000 + !byte %11110000 + !byte %11111000 + !byte %11111100 + !byte %11111110 + !byte %11111111 + + !source "src/wait.a" + !source "src/fx/fx.hgr.common.a" + +HGR_COPY_MASK_ROUTINES + +HGR_BLOCK_COPY_ROUTINES diff --git a/src/fx/fx.hgr.vertical.blinds.a b/src/fx/fx.hgr.vertical.blinds.a new file mode 100755 index 0000000..cb5c9de --- /dev/null +++ b/src/fx/fx.hgr.vertical.blinds.a @@ -0,0 +1,259 @@ +;license:MIT +;(c) 2019 by qkumba +; +!cpu 6502 +!to "build/FX/VERTICAL.BLINDS",plain +*=$6000 + + ldx #0 + clc + + ;build pre-shift tables + +- txa + and #%11111100 + sta tbl00000000a,x + adc #1 + sta tbl00000001,x + adc #1 + sta tbl00000010,x + adc #1 + sta tbl00000011,x + txa + and #%11110011 + sta tbl00000000b,x + ora #%00000100 + sta tbl00000100,x + adc #4 + sta tbl00001000,x + adc #4 + sta tbl00001100,x + txa + and #%11001111 + sta tbl00000000c,x + ora #%00010000 + sta tbl00010000,x + adc #16 + sta tbl00100000,x + adc #16 + sta tbl00110000,x + txa + and #%00111111 + sta tbl00000000d,x + ora #%01000000 + sta tbl01000000,x + adc #64 + sta tbl10000000,x + adc #64 + sta tbl11000000,x + + ;build index table + + txa + and #3 + adc #>tbl00000000a + sta tblx00,x + txa + lsr + lsr + pha + and #3 + clc + adc #>tbl00000000b + sta tblx01,x + pla + lsr + lsr + pha + and #3 + clc + adc #>tbl00000000c + sta tblx02,x + pla + lsr + lsr + clc + adc #>tbl00000000d + sta tblx03,x + inx + bne - + + stx $26 + lda #$20 + sta $27 + stx $fe + lda #>shift + sta $ff + + lda #>tblx03 + sta patchtbl + 1 + lda #<(shift + 2) + sta loop1 + 6 + lda #>(shift + 2) + sta loop1 + 7 + + ;generate unrolled rotate-left code + + lda #4 + sta $fd +-- ldx #0 + ldy #0 + lda #$a2 + sta ($fe),y + iny + lda #0 + sta ($fe),y + clc +- ldy #2 + lda #$bc + sta ($fe),y + iny + lda $26 + sta ($fe),y + iny + lda $27 + eor #$60 + sta ($fe),y + iny + lda #$b9 + sta ($fe),y + iny + lda #0 + sta ($fe),y + iny +patchtbl + lda #>tblx00 + sta ($fe),y + iny + lda #$8d + sta ($fe),y + iny + lda $fe + adc #16 + sta ($fe),y + iny + lda $ff + adc #0 + sta ($fe),y + iny + lda #$bc + sta ($fe),y + iny + lda $26 + sta ($fe),y + iny + lda $27 + sta ($fe),y + iny + lda #$b9 + sta ($fe),y + iny + lda #0 + sta ($fe),y + iny + iny + lda #$9d + sta ($fe),y + iny + lda $26 + sta ($fe),y + iny + lda $27 + sta ($fe),y + lda #18 + adc $fe + sta $fe + bcc + + inc $ff ++ jsr nextline + inx + cpx #<$c0 + bne - + + ;copy loop1 code + + ldy #2 +- lda loop1 - $c0,x + sta ($fe),y + inx + iny + cpx #<($c0 + (loop1_e - loop1)) + bne - + + lda $fe + clc + adc #(loop1_e - loop1) + 2 + sta $fe + bcc + + inc $ff ++ adc #2 + sta loop1 + 6 + lda $ff + adc #0 + sta loop1 + 7 + dec patchtbl + 1 + dec $fd + beq + + jmp -- ++ ldy #0 + lda #$60 + sta ($fe),y + + jmp shift + +loop1 inx + cpx #$28 + beq + + jmp shift + 2 ++ +loop1_e + +nextline + clc + lda $27 + adc #4 + bit x1c + bne + + asl $26 + bcc ++ + adc #$e0 + clc + bit x04 + beq +++ + lda $26 + adc #$50 + eor #$f0 + beq ++++ + eor #$f0 +++++ sta $26 + lda #$20 + bcc +++ +++ adc #$e0 ++++ ror $26 ++ sta $27 + rts + +x1c !byte $1c +x04 !byte $04 + +tblx00 = (loop1_e + 255) and -256 +tblx01 = tblx00 + 256 +tblx02 = tblx01 + 256 +tblx03 = tblx02 + 256 +tbl00000000a = tblx03 + 256 +tbl00000001 = tbl00000000a + 256 +tbl00000010 = tbl00000001 + 256 +tbl00000011 = tbl00000010 + 256 +tbl00000000b = tbl00000011 + 256 +tbl00000100 = tbl00000000b + 256 +tbl00001000 = tbl00000100 + 256 +tbl00001100 = tbl00001000 + 256 +tbl00000000c = tbl00001100 + 256 +tbl00010000 = tbl00000000c + 256 +tbl00100000 = tbl00010000 + 256 +tbl00110000 = tbl00100000 + 256 +tbl00000000d = tbl00110000 + 256 +tbl01000000 = tbl00000000d + 256 +tbl10000000 = tbl01000000 + 256 +tbl11000000 = tbl10000000 + 256 +shift = tbl11000000 + 256 diff --git a/src/fx/fx.hgr.wavy.iris.a b/src/fx/fx.hgr.wavy.iris.a new file mode 100644 index 0000000..3abbbe1 --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/WAVY.IRIS",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.hgr.wavy.iris.bloom.a b/src/fx/fx.hgr.wavy.iris.bloom.a new file mode 100644 index 0000000..76d7a7a --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.bloom.a @@ -0,0 +1,16 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/W.IRIS.BLOOM",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.hgr.wavy.iris.bloom.data.a b/src/fx/fx.hgr.wavy.iris.bloom.data.a new file mode 100644 index 0000000..c538f24 --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.bloom.data.a @@ -0,0 +1,7683 @@ +!cpu 6502 +!to "build/FX/W.IR.BLOOM.DATA",plain +*=$8100 + !byte $5F,%11110011 + !byte $61,%11110011 + !byte $5D,%11110011 + !byte $5F,%11010011 + !byte $61,%11010011 + !byte $5D,%11010011 + !byte $5B,%11110011 + !byte $63,%11110011 + !byte $5F,%10110011 + !byte $63,%11010011 + !byte $5B,%11010011 + !byte $5D,%10110011 + !byte $61,%10110011 + !byte $59,%11110011 + !byte $65,%11110011 + !byte $63,%10110011 + !byte $5B,%10110011 + !byte $65,%11010011 + !byte $61,%01110010 + !byte $61,%10010011; + !byte $59,%11010011 + !byte $5D,%01110010 + !byte $5D,%10010011; + !byte $5F,%01110010 + !byte $5F,%10010011; + !byte $5B,%01110010 + !byte $5B,%10010011; + !byte $59,%10110011 + !byte $63,%01110010 + !byte $63,%10010011; + !byte $67,%11110011 + !byte $57,%11110011 + !byte $5D,%01010010 + !byte $61,%01010010 + !byte $5F,%01010010 + !byte $65,%10110011 + !byte $65,%01110010 + !byte $65,%10010011; + !byte $67,%11010011 + !byte $67,%10110011 + !byte $57,%11010011 + !byte $5B,%01010010 + !byte $57,%10110011 + !byte $69,%11110011 + !byte $57,%01110010 + !byte $57,%10010011; + !byte $59,%01110010 + !byte $59,%10010011; + !byte $5D,%00110010 + !byte $55,%11010011 + !byte $61,%00110010 + !byte $65,%01010010 + !byte $5F,%00110010 + !byte $63,%01010010 + !byte $55,%11110011 + !byte $59,%01010010 + !byte $63,%00110010 + !byte $69,%10110011 + !byte $5B,%00110010 + !byte $59,%00110010 + !byte $67,%01010010 + !byte $69,%11010011 + !byte $5F,%00010010 + !byte $5D,%00010010 + !byte $67,%01110010 + !byte $67,%10010011; + !byte $6B,%11110011 + !byte $63,%00010010 + !byte $57,%01010010 + !byte $53,%11010011 + !byte $55,%10110011 + !byte $55,%01010010 + !byte $67,%00110010 + !byte $55,%01110010 + !byte $55,%10010011; + !byte $59,%00010010 + !byte $61,%00010010 + !byte $53,%10110011 + !byte $6B,%10110011 + !byte $5B,%00010010 + !byte $69,%01110010 + !byte $69,%10010011; + !byte $5F,%11110001 + !byte $65,%00110010 + !byte $6B,%01110010 + !byte $6B,%10010011; + !byte $5D,%11110001 + !byte $63,%11110001 + !byte $53,%11110011 + !byte $69,%00110010 + !byte $6B,%11010011 + !byte $55,%00110010 + !byte $6D,%11110011 + !byte $65,%00010010 + !byte $69,%01010010 + !byte $57,%00110010 + !byte $59,%11110001 + !byte $51,%10110011 + !byte $65,%11110001 + !byte $5F,%11010001 + !byte $5B,%11110001 + !byte $6D,%10110011 + !byte $6D,%01110010 + !byte $6D,%10010011; + !byte $53,%01110010 + !byte $53,%10010011; + !byte $61,%11110001 + !byte $51,%11110011 + !byte $69,%00010010 + !byte $51,%01110010 + !byte $51,%10010011; + !byte $51,%11010011 + !byte $53,%00110010 + !byte $65,%11010001 + !byte $55,%00010010 + !byte $59,%11010001 + !byte $5D,%11010001 + !byte $53,%00010010 + !byte $6B,%00010010 + !byte $6B,%00110010 + !byte $6D,%11010011 + !byte $67,%00010010 + !byte $5F,%10110001 + !byte $57,%00010010 + !byte $61,%11010001 + !byte $5B,%11010001 + !byte $4F,%11110011 + !byte $6F,%11110011 + !byte $63,%11010001 + !byte $6B,%01010010 + !byte $4F,%01110010 + !byte $4F,%10010011; + !byte $53,%01010010 + !byte $6F,%01110010 + !byte $6F,%10010011; + !byte $6F,%10110011 + !byte $67,%11110001 + !byte $4F,%10110011 + !byte $67,%11010001 + !byte $59,%10110001 + !byte $61,%10110001 + !byte $57,%11110001 + !byte $51,%01010010 + !byte $53,%11110001 + !byte $65,%10110001 + !byte $55,%11110001 + !byte $5F,%01110000 + !byte $5F,%10010001; + !byte $4F,%01010010 + !byte $67,%10110001 + !byte $4D,%11110011 + !byte $6D,%00010010 + !byte $6F,%11010011 + !byte $5B,%10110001 + !byte $57,%11010001 + !byte $61,%01110000 + !byte $61,%10010001; + !byte $6B,%11110001 + !byte $6D,%00110010 + !byte $4F,%11010011 + !byte $71,%01110010 + !byte $71,%10010011; + !byte $5D,%10110001 + !byte $6D,%11110001 + !byte $6D,%01010010 + !byte $71,%10110011 + !byte $59,%01110000 + !byte $59,%10010001; + !byte $4D,%01010010 + !byte $53,%11010001 + !byte $57,%10110001 + !byte $69,%11110001 + !byte $4B,%11110011 + !byte $51,%11110001 + !byte $63,%10110001 + !byte $4D,%01110010 + !byte $4D,%10010011; + !byte $51,%00110010 + !byte $61,%01010000 + !byte $67,%01110000 + !byte $67,%10010001; + !byte $4D,%11010011 + !byte $55,%11010001 + !byte $5F,%01010000 + !byte $69,%11010001 + !byte $5B,%01110000 + !byte $5B,%10010001; + !byte $4F,%00110010 + !byte $51,%11010001 + !byte $69,%10110001 + !byte $71,%11010011 + !byte $71,%11110011 + !byte $4D,%00110010 + !byte $6F,%11110001 + !byte $6F,%00010010 + !byte $6F,%01010010 + !byte $57,%01110000 + !byte $57,%10010001; + !byte $69,%01110000 + !byte $69,%10010001; + !byte $73,%01110010 + !byte $73,%10010011; + !byte $59,%01010000 + !byte $51,%00010010 + !byte $63,%01110000 + !byte $63,%10010001; + !byte $73,%10110011 + !byte $4B,%11010011 + !byte $6F,%00110010 + !byte $53,%10110001 + !byte $51,%10110001 + !byte $61,%00110000 + !byte $5B,%01010000 + !byte $5D,%01110000 + !byte $5D,%10010001; + !byte $49,%11110011 + !byte $63,%01010000 + !byte $4D,%10110011 + !byte $4B,%00110010 + !byte $55,%10110001 + !byte $71,%01010010 + !byte $69,%01010000 + !byte $57,%01010000 + !byte $73,%11010011 + !byte $49,%11010011 + !byte $4D,%00010010 + !byte $4F,%00010010 + !byte $59,%00110000 + !byte $6B,%11010001 + !byte $71,%11110001 + !byte $65,%01110000 + !byte $65,%10010001; + !byte $6F,%11010001 + !byte $75,%01110010 + !byte $75,%10010011; + !byte $63,%00110000 + !byte $6B,%01110000 + !byte $6B,%10010001; + !byte $6B,%10110001 + !byte $71,%00010010 + !byte $75,%10110011 + !byte $4B,%10110011 + !byte $4B,%00010010 + !byte $51,%01110000 + !byte $51,%10010001; + !byte $53,%01110000 + !byte $53,%10010001; + !byte $5B,%00110000 + !byte $4B,%01010010 + !byte $6B,%01010000 + !byte $71,%11010001 + !byte $61,%00010000 + !byte $5F,%00110000 + !byte $5D,%01010000 + !byte $6D,%11010001 + !byte $71,%00110010 + !byte $63,%00010000 + !byte $73,%11110011 + !byte $47,%11010011 + !byte $49,%10110011 + !byte $59,%00010000 + !byte $75,%11010011 + !byte $55,%01110000 + !byte $55,%10010001; + !byte $67,%01010000 + !byte $65,%01010000 + !byte $73,%01010010 + !byte $57,%00110000 + !byte $4D,%11110001 + !byte $4F,%11110001 + !byte $47,%11110011 + !byte $4B,%11110001 + !byte $51,%01010000 + !byte $73,%11110001 + !byte $5B,%00010000 + !byte $77,%01110010 + !byte $77,%10010011; + !byte $77,%10110011 + !byte $73,%11010001 + !byte $4B,%01110010 + !byte $4B,%10010011; + !byte $65,%00110000 + !byte $6B,%00110000 + !byte $53,%01010000 + !byte $5D,%00110000 + !byte $47,%10110011 + !byte $73,%00010010 + !byte $49,%00010010 + !byte $63,%11101111 + !byte $6D,%01010000 + !byte $6D,%01110000 + !byte $6D,%10010001; + !byte $6D,%10110001 + !byte $49,%11110001 + !byte $4F,%01110000 + !byte $4F,%10010001; + !byte $65,%00010000 + !byte $75,%11110011 + !byte $59,%11101111 + !byte $6D,%00110000 + !byte $4F,%01010000 + !byte $77,%11010011 + !byte $49,%01110010 + !byte $49,%10010011; + !byte $73,%00110010 + !byte $55,%01010000 + !byte $4F,%11010001 + !byte $5B,%11101111 + !byte $51,%00110000 + !byte $61,%11101111 + !byte $45,%11010011 + !byte $4F,%10110001 + !byte $45,%10110011 + !byte $4B,%11010001 + !byte $65,%11101111 + !byte $4D,%11010001 + !byte $69,%00110000 + !byte $5D,%00010000 + !byte $75,%11010001 + !byte $79,%10110011 + !byte $75,%11110001 + !byte $57,%00010000 + !byte $49,%11010001 + !byte $47,%01110010 + !byte $47,%10010011; + !byte $53,%00110000 + !byte $75,%01010010 + !byte $4F,%00110000 + !byte $79,%01110010 + !byte $79,%10010011; + !byte $63,%11001111 + !byte $67,%00110000 + !byte $75,%00010010 + !byte $59,%11001111 + !byte $79,%11010011 + !byte $77,%11110011 + !byte $65,%11001111 + !byte $6F,%01010000 + !byte $6F,%10110001 + !byte $45,%01110010 + !byte $45,%10010011; + !byte $6D,%00010000 + !byte $6F,%00110000 + !byte $5B,%11001111 + !byte $6F,%01110000 + !byte $6F,%10010001; + !byte $49,%01010010 + !byte $5D,%11101111 + !byte $55,%00110000 + !byte $5F,%00010000 + !byte $51,%00010000 + !byte $67,%00010000 + !byte $49,%00110010 + !byte $4F,%00010000 + !byte $6F,%00010000 + !byte $75,%00110010 + !byte $49,%10110001 + !byte $4B,%10110001 + !byte $77,%11010001 + !byte $67,%11101111 + !byte $43,%10110011 + !byte $4D,%10110001 + !byte $53,%00010000 + !byte $77,%11110001 + !byte $7B,%10110011 + !byte $47,%01010010 + !byte $47,%11010001 + !byte $79,%11110011 + !byte $75,%10110001 + !byte $43,%01110010 + !byte $43,%10010011; + !byte $5D,%11001111 + !byte $7B,%11010011 + !byte $5B,%10101111 + !byte $59,%10101111 + !byte $65,%10101111 + !byte $67,%11001111 + !byte $73,%10110001 + !byte $47,%10110001 + !byte $71,%10110001 + !byte $45,%01010010 + !byte $77,%00010010 + !byte $51,%11101111 + !byte $5F,%11101111 + !byte $7B,%01110010 + !byte $7B,%10010011; + !byte $4F,%11101111 + !byte $55,%00010000 + !byte $71,%00110000 + !byte $77,%10110001 + !byte $71,%01010000 + !byte $71,%00010000 + !byte $67,%10101111 + !byte $49,%01110000 + !byte $49,%10010001; + !byte $71,%01110000 + !byte $71,%10010001; + !byte $43,%01010010 + !byte $77,%01010010 + !byte $69,%00010000 + !byte $57,%11101111 + !byte $4B,%01110000 + !byte $4B,%10010001; + !byte $53,%11101111 + !byte $47,%11110001 + !byte $5D,%10101111 + !byte $79,%11010001 + !byte $77,%00110010 + !byte $7B,%11110011 + !byte $47,%01110000 + !byte $47,%10010001; + !byte $6B,%00010000 + !byte $47,%00110010 + !byte $4D,%01110000 + !byte $4D,%10010001; + !byte $5B,%01101110 + !byte $5B,%10001111; + !byte $79,%11110001 + !byte $7D,%10110011 + !byte $7D,%11010011 + !byte $63,%10101111 + !byte $69,%11101111 + !byte $5F,%11001111 + !byte $6F,%11101111 + !byte $71,%11101111 + !byte $41,%01110010 + !byte $41,%10010011; + !byte $51,%11001111 + !byte $45,%11110011 + !byte $45,%00110010 + !byte $67,%01101110 + !byte $67,%10001111; + !byte $4F,%11001111 + !byte $79,%10110001 + !byte $41,%01010010 + !byte $69,%11001111 + !byte $79,%00010010 + !byte $55,%11101111 + !byte $59,%01101110 + !byte $59,%10001111; + !byte $65,%01101110 + !byte $65,%10001111; + !byte $5D,%01101110 + !byte $5D,%10001111; + !byte $43,%00110010 + !byte $7D,%11110011 + !byte $69,%10101111 + !byte $73,%00010000 + !byte $73,%00110000 + !byte $49,%01010000 + !byte $53,%11001111 + !byte $47,%01010000 + !byte $47,%00010010 + !byte $5F,%10101111 + !byte $73,%01010000 + !byte $4B,%01010000 + !byte $5B,%01001110 + !byte $7B,%11010001 + !byte $61,%11001111 + !byte $73,%11101111 + !byte $4D,%01010000 + !byte $73,%01110000 + !byte $73,%10010001; + !byte $69,%01101110 + !byte $69,%10001111; + !byte $7B,%11110001 + !byte $79,%00110010 + !byte $7F,%11010011 + !byte $41,%00110010 + !byte $51,%10101111 + !byte $4F,%10101111 + !byte $5D,%01001110 + !byte $45,%01110000 + !byte $45,%10010001; + !byte $79,%01010010 + !byte $6B,%11101111 + !byte $7B,%10110001 + !byte $7F,%10110011 + !byte $45,%00010010 + !byte $55,%11001111 + !byte $45,%01010000 + !byte $43,%11010011 + !byte $5F,%01101110 + !byte $5F,%10001111; + !byte $7F,%11110011 + !byte $43,%11110011 + !byte $67,%01001110 + !byte $7B,%00010010 + !byte $53,%10101111 + !byte $57,%11001111 + !byte $43,%00010010 + !byte $47,%00110000 + !byte $69,%01001110 + !byte $6B,%11001111 + !byte $3F,%01010010 + !byte $49,%00110000 + !byte $3F,%00110010 + !byte $61,%10101111 + !byte $75,%00010000 + !byte $6B,%10101111 + !byte $75,%11101111 + !byte $75,%00110000 + !byte $5B,%00101110 + !byte $4B,%00110000 + !byte $4D,%00110000 + !byte $5D,%00101110 + !byte $7D,%11010001 + !byte $41,%00010010 + !byte $45,%00110000 + !byte $51,%01101110 + !byte $51,%10001111; + !byte $5F,%01001110 + !byte $4F,%01101110 + !byte $4F,%10001111; + !byte $6B,%01101110 + !byte $6B,%10001111; + !byte $75,%01010000 + !byte $7B,%00110010 + !byte $7D,%11110001 + !byte $75,%01110000 + !byte $75,%10010001; + !byte $73,%11001111 + !byte $81,%11010011 + !byte $55,%10101111 + !byte $81,%11110011 + !byte $6D,%11101111 + !byte $41,%11110011 + !byte $3F,%00010010 + !byte $45,%11110001 + !byte $53,%01101110 + !byte $53,%10001111; + !byte $6B,%01001110 + !byte $75,%11001111 + !byte $7D,%10110001 + !byte $61,%01101110 + !byte $61,%10001111; + !byte $7D,%00010010 + !byte $47,%00010000 + !byte $7B,%01010010 + !byte $5F,%00101110 + !byte $43,%11110001 + !byte $45,%00010000 + !byte $49,%00010000 + !byte $5D,%00001110 + !byte $69,%00101110 + !byte $4D,%00010000 + !byte $57,%10101111 + !byte $6D,%11001111 + !byte $51,%01001110 + !byte $41,%11110001 + !byte $4F,%01001110 + !byte $77,%11101111 + !byte $77,%00010000 + !byte $4B,%00010000 + !byte $3F,%11110011 + !byte $41,%10110011 + !byte $6B,%00101110 + !byte $7F,%11010001 + !byte $61,%01001110 + !byte $77,%00110000 + !byte $7F,%11110001 + !byte $7D,%00110010 + !byte $6D,%10101111 + !byte $55,%01101110 + !byte $55,%10001111; + !byte $41,%11010011 + !byte $3F,%11110001 + !byte $7D,%01110010 + !byte $7D,%10010011; + !byte $3D,%00010010 + !byte $5F,%00001110 + !byte $6D,%01101110 + !byte $6D,%10001111; + !byte $77,%11001111 + !byte $45,%11010001 + !byte $5B,%00001110 + !byte $53,%01001110 + !byte $45,%10110001 + !byte $77,%01010000 + !byte $77,%01110000 + !byte $77,%10010001; + !byte $83,%11110011 + !byte $3D,%00110010 + !byte $63,%01101110 + !byte $63,%10001111; + !byte $6D,%01001110 + !byte $45,%11101111 + !byte $47,%11101111 + !byte $7F,%00010010 + !byte $61,%00101110 + !byte $7F,%10110001 + !byte $3D,%11110011 + !byte $49,%11101111 + !byte $3D,%11110001 + !byte $43,%11010001 + !byte $51,%00101110 + !byte $7D,%01010010 + !byte $83,%11010011 + !byte $4D,%11101111 + !byte $5D,%11101101 + !byte $6D,%00101110 + !byte $57,%01101110 + !byte $57,%10001111; + !byte $41,%11010001 + !byte $3F,%11010011 + !byte $4F,%00101110 + !byte $55,%01001110 + !byte $5F,%11101101 + !byte $79,%11101111 + !byte $4B,%11101111 + !byte $6F,%11001111 + !byte $81,%11010001 + !byte $79,%00010000 + !byte $3F,%11010001 + !byte $63,%01001110 + !byte $79,%11001111 + !byte $53,%00101110 + !byte $61,%00001110 + !byte $81,%11110001 + !byte $7F,%00110010 + !byte $6B,%00001110 + !byte $59,%01001110 + !byte $3B,%11110011 + !byte $43,%00010000 + !byte $79,%00110000 + !byte $6F,%10101111 + !byte $3D,%11010001 + !byte $43,%11101111 + !byte $47,%11001111 + !byte $45,%11001111 + !byte $6D,%00001110 + !byte $6F,%01101110 + !byte $6F,%10001111; + !byte $3D,%11010011 + !byte $79,%01010000 + !byte $81,%00010010 + !byte $51,%00001110 + !byte $6F,%01001110 + !byte $79,%01110000 + !byte $79,%10010001; + !byte $85,%11110011 + !byte $49,%11001111 + !byte $63,%00101110 + !byte $61,%11101101 + !byte $43,%10110001 + !byte $57,%01001110 + !byte $7F,%01010010 + !byte $3F,%10110011 + !byte $4D,%11001111 + !byte $5F,%11001101 + !byte $6F,%00101110 + !byte $71,%11001111 + !byte $55,%00101110 + !byte $53,%00001110 + !byte $41,%10110001 + !byte $43,%11001111 + !byte $4F,%00001110 + !byte $3B,%11110001 + !byte $65,%01001110 + !byte $4B,%11001111 + !byte $7B,%11101111 + !byte $81,%10110001 + !byte $39,%11110011 + !byte $3F,%10110001 + !byte $3B,%11010011 + !byte $3B,%11010001 + !byte $63,%00001110 + !byte $6F,%00001110 + !byte $7B,%11001111 + !byte $83,%11010001 + !byte $81,%00110010 + !byte $83,%11110001 + !byte $79,%10101111 + !byte $7B,%00010000 + !byte $5D,%11001101 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $45,%10101111 + !byte $7F,%01110010 + !byte $7F,%10010011; + !byte $3D,%10110001 + !byte $61,%11001101 + !byte $47,%10101111 + !byte $3D,%10110011 + !byte $51,%11101101 + !byte $7B,%00110000 + !byte $83,%00010010 + !byte $71,%10101111 + !byte $57,%00101110 + !byte $55,%00001110 + !byte $49,%10101111 + !byte $63,%11101101 + !byte $6D,%11101101 + !byte $43,%10101111 + !byte $43,%01110000 + !byte $43,%10010001; + !byte $39,%11010011 + !byte $3B,%10110001 + !byte $65,%00101110 + !byte $71,%01101110 + !byte $71,%10001111; + !byte $7B,%10101111 + !byte $53,%11101101 + !byte $71,%01001110 + !byte $77,%10101111 + !byte $7B,%01010000 + !byte $81,%01010010 + !byte $6F,%11101101 + !byte $37,%11110011 + !byte $5F,%10101101 + !byte $7B,%01110000 + !byte $7B,%10010001; + !byte $4D,%10101111 + !byte $41,%01110000 + !byte $41,%10010001; + !byte $71,%00101110 + !byte $4F,%11101101 + !byte $83,%00110010 + !byte $4B,%10101111 + !byte $61,%10101101 + !byte $3B,%10110011 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $71,%00001110 + !byte $63,%11001101 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $45,%01101110 + !byte $45,%10001111; + !byte $7D,%11001111 + !byte $7D,%11101111 + !byte $85,%11110001 + !byte $81,%10110011 + !byte $59,%00101110 + !byte $47,%01101110 + !byte $47,%10001111; + !byte $65,%00001110 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $7D,%00010000 + !byte $85,%11010001 + !byte $51,%11001101 + !byte $81,%01110010 + !byte $81,%10010011; + !byte $37,%11010011 + !byte $55,%11101101 + !byte $57,%00001110 + !byte $43,%01101110 + !byte $43,%10001111; + !byte $85,%00010010 + !byte $71,%11101101 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $39,%10110011 + !byte $43,%01010000 + !byte $53,%11001101 + !byte $67,%00101110 + !byte $7D,%10101111 + !byte $49,%01101110 + !byte $49,%10001111; + !byte $7D,%00110000 + !byte $63,%10101101 + !byte $65,%11101101 + !byte $73,%10101111 + !byte $83,%01010010 + !byte $39,%10110001 + !byte $61,%01101100 + !byte $61,%10001101; + !byte $85,%00110010 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $73,%01101110 + !byte $73,%10001111; + !byte $3D,%01010010 + !byte $41,%01010000 + !byte $7D,%01010000 + !byte $4B,%01101110 + !byte $4B,%10001111; + !byte $73,%01001110 + !byte $4D,%01101110 + !byte $4D,%10001111; + !byte $3F,%01010000 + !byte $45,%01001110 + !byte $73,%00101110 + !byte $35,%11110011 + !byte $37,%10110011 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $3D,%01010000 + !byte $59,%00001110 + !byte $7D,%01110000 + !byte $7D,%10010001; + !byte $55,%11001101 + !byte $65,%11001101 + !byte $57,%11101101 + !byte $35,%11010011 + !byte $43,%00110000 + !byte $43,%01001110 + !byte $47,%01001110 + !byte $73,%00001110 + !byte $7F,%11001111 + !byte $7F,%11101111 + !byte $87,%11110001 + !byte $3B,%01010000 + !byte $51,%10101101 + !byte $63,%01101100 + !byte $63,%10001101; + !byte $71,%11001101 + !byte $67,%00001110 + !byte $73,%11101101 + !byte $53,%10101101 + !byte $87,%00010010 + !byte $83,%01110010 + !byte $83,%10010011; + !byte $39,%01110010 + !byte $39,%10010011; + !byte $7F,%10101111 + !byte $7F,%00010000 + !byte $49,%01001110 + !byte $65,%10101101 + !byte $85,%01010010 + !byte $6F,%11001101 + !byte $75,%10101111 + !byte $35,%10110011 + !byte $39,%01010000 + !byte $7F,%00110000 + !byte $87,%11010001 + !byte $67,%11101101 + !byte $3B,%01010010 + !byte $57,%11001101 + !byte $87,%00110010 + !byte $45,%00101110 + !byte $55,%10101101 + !byte $73,%11001101 + !byte $83,%10110011 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $59,%11101101 + !byte $4B,%01001110 + !byte $41,%00110000 + !byte $43,%00101110 + !byte $47,%00101110 + !byte $65,%01101100 + !byte $65,%10001101; + !byte $3D,%00110000 + !byte $3F,%00110000 + !byte $63,%01001100 + !byte $7F,%01010000 + !byte $4D,%01001110 + !byte $69,%00001110 + !byte $75,%01101110 + !byte $75,%10001111; + !byte $3B,%00110000 + !byte $53,%01101100 + !byte $53,%10001101; + !byte $61,%01001100 + !byte $81,%11001111 + !byte $67,%11001101 + !byte $75,%00101110 + !byte $75,%01001110 + !byte $81,%11101111 + !byte $75,%00001110 + !byte $85,%01110010 + !byte $85,%10010011; + !byte $51,%01101100 + !byte $51,%10001101; + !byte $89,%00010010 + !byte $39,%01010010 + !byte $89,%11110001 + !byte $7F,%01110000 + !byte $7F,%10010001; + !byte $75,%11101101 + !byte $87,%01010010 + !byte $33,%11010011 + !byte $39,%00110000 + !byte $49,%00101110 + !byte $81,%10101111 + !byte $81,%00010000 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $33,%10110011 + !byte $5B,%11101101 + !byte $65,%01001100 + !byte $67,%10101101 + !byte $55,%01101100 + !byte $55,%10001101; + !byte $57,%10101101 + !byte $3B,%00110010 + !byte $59,%11001101 + !byte $75,%11001101 + !byte $89,%00110010 + !byte $45,%00001110 + !byte $37,%01010010 + !byte $43,%00001110 + !byte $4B,%00101110 + !byte $69,%11101101 + !byte $81,%00110000 + !byte $41,%00010000 + !byte $47,%00001110 + !byte $85,%10110011 + !byte $67,%01101100 + !byte $67,%10001101; + !byte $33,%01110010 + !byte $33,%10010011; + !byte $37,%01010000 + !byte $3B,%00010000 + !byte $3D,%00010000 + !byte $3F,%00010000 + !byte $53,%01001100 + !byte $87,%01110010 + !byte $87,%10010011; + !byte $3B,%00010010 + !byte $39,%00010000 + !byte $4D,%00101110 + !byte $63,%00101100 + !byte $73,%10101101 + !byte $83,%11001111 + !byte $81,%01010000 + !byte $89,%01010010 + !byte $37,%00110000 + !byte $39,%00110010 + !byte $57,%01101100 + !byte $57,%10001101; + !byte $35,%01010010 + !byte $65,%00101100 + !byte $77,%01101110 + !byte $77,%10001111; + !byte $83,%11101111 + !byte $49,%00001110 + !byte $69,%11001101 + !byte $55,%01001100 + !byte $59,%10101101 + !byte $75,%10101101 + !byte $77,%00001110 + !byte $77,%00101110 + !byte $77,%01001110 + !byte $8B,%00010010 + !byte $67,%01001100 + !byte $83,%10101111 + !byte $5B,%11001101 + !byte $77,%11101101 + !byte $85,%11010011 + !byte $83,%00010000 + !byte $81,%01110000 + !byte $81,%10010001; + !byte $45,%11101101 + !byte $77,%11001101 + !byte $8B,%00110010 + !byte $37,%00110010 + !byte $43,%11101101 + !byte $51,%01001100 + !byte $69,%10101101 + !byte $8B,%11110001 + !byte $33,%01010010 + !byte $6B,%11101101 + !byte $47,%11101101 + !byte $37,%00010000 + !byte $31,%10110011 + !byte $4B,%00001110 + !byte $87,%10110011 + !byte $41,%11101111 + !byte $57,%01001100 + !byte $89,%01110010 + !byte $89,%10010011; + !byte $31,%01110010 + !byte $31,%10010011; + !byte $67,%00101100 + !byte $83,%00110000 + !byte $3B,%11101111 + !byte $3D,%11101111 + !byte $53,%00101100 + !byte $69,%01101100 + !byte $69,%10001101; + !byte $59,%01101100 + !byte $59,%10001101; + !byte $39,%11101111 + !byte $3F,%11101111 + !byte $55,%00101100 + !byte $77,%10101101 + !byte $35,%00110010 + !byte $8B,%01010010 + !byte $39,%00010010 + !byte $49,%11101101 + !byte $4D,%00001110 + !byte $85,%11001111 + !byte $5B,%10101101 + !byte $83,%01010000 + !byte $85,%11101111 + !byte $65,%00001100 + !byte $69,%01001100 + !byte $6B,%11001101 + !byte $31,%01010010 + !byte $45,%11001101 + !byte $79,%01101110 + !byte $79,%10001111; + !byte $85,%10101111 + !byte $37,%11101111 + !byte $87,%11010011 + !byte $43,%11001101 + !byte $79,%11101101 + !byte $79,%00001110 + !byte $79,%00101110 + !byte $83,%10110001 + !byte $8D,%00010010 + !byte $8D,%00110010 + !byte $33,%00110010 + !byte $57,%00101100 + !byte $67,%00001100 + !byte $79,%01001110 + !byte $85,%00010000 + !byte $89,%10110011 + !byte $79,%11001101 + !byte $37,%00010010 + !byte $47,%11001101 + !byte $83,%01110000 + !byte $83,%10010001; + !byte $59,%01001100 + !byte $8B,%01110010 + !byte $8B,%10010011; + !byte $4B,%11101101 + !byte $69,%00101100 + !byte $6B,%10101101 + !byte $41,%11001111 + !byte $39,%11110001 + !byte $3B,%11001111 + !byte $55,%00001100 + !byte $5B,%01101100 + !byte $5B,%10001101; + !byte $5D,%10101101 + !byte $79,%10101101 + !byte $8D,%01010010 + !byte $87,%11110011 + !byte $85,%00110000 + !byte $35,%00010010 + !byte $39,%11001111 + !byte $3D,%11001111 + !byte $49,%11001101 + !byte $31,%00110010 + !byte $3F,%11001111 + !byte $6B,%01101100 + !byte $6B,%10001101; + !byte $53,%00001100 + !byte $4D,%11101101 + !byte $87,%11001111 + !byte $37,%11001111 + !byte $69,%00001100 + !byte $45,%10101101 + !byte $87,%11101111 + !byte $89,%11010011 + !byte $57,%00001100 + !byte $59,%00101100 + !byte $2F,%01010010 + !byte $6D,%11001101 + !byte $85,%01010000 + !byte $33,%00010010 + !byte $6B,%01001100 + !byte $8B,%10110011 + !byte $43,%10101101 + !byte $47,%10101101 + !byte $8D,%01110010 + !byte $8D,%10010011; + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $77,%01101100 + !byte $77,%10001101; + !byte $37,%11110001 + !byte $4B,%11001101 + !byte $5B,%01001100 + !byte $87,%10101111 + !byte $39,%11010001 + !byte $7B,%11101101 + !byte $7B,%00001110 + !byte $8F,%00110010 + !byte $7B,%11001101 + !byte $7B,%01101110 + !byte $7B,%10001111; + !byte $87,%00010000 + !byte $67,%11101011 + !byte $6B,%00101100 + !byte $79,%01101100 + !byte $79,%10001101; + !byte $5D,%01101100 + !byte $5D,%10001101; + !byte $7B,%00101110 + !byte $7B,%01001110 + !byte $2F,%00110010 + !byte $31,%00010010 + !byte $85,%01110000 + !byte $85,%10010001; + !byte $8F,%01010010 + !byte $39,%10101111 + !byte $3B,%10101111 + !byte $41,%10101111 + !byte $55,%11101011 + !byte $6D,%10101101 + !byte $7B,%10101101 + !byte $49,%10101101 + !byte $35,%11110001 + !byte $35,%11101111 + !byte $3D,%10101111 + !byte $69,%11101011 + !byte $87,%00110000 + !byte $37,%10101111 + !byte $3F,%10101111 + !byte $4F,%11001101 + !byte $59,%00001100 + !byte $85,%10110001 + !byte $89,%11110011 + !byte $57,%11101011 + !byte $35,%11001111 + !byte $6B,%00001100 + !byte $8D,%10110011 + !byte $4D,%11001101 + !byte $8F,%00010010 + !byte $45,%01101100 + !byte $45,%10001101; + !byte $6D,%01101100 + !byte $6D,%10001101; + !byte $8B,%11010011 + !byte $33,%11110001 + !byte $5B,%00101100 + !byte $89,%11001111 + !byte $8F,%01110010 + !byte $8F,%10010011; + !byte $5F,%01101100 + !byte $5F,%10001101; + !byte $43,%01101100 + !byte $43,%10001101; + !byte $47,%01101100 + !byte $47,%10001101; + !byte $7B,%01101100 + !byte $7B,%10001101; + !byte $89,%11101111 + !byte $2F,%00010010 + !byte $37,%11010001 + !byte $5D,%01001100 + !byte $87,%01010000 + !byte $6D,%01001100 + !byte $4B,%10101101 + !byte $6B,%11101011 + !byte $89,%00010000 + !byte $31,%11110001 + !byte $59,%11101011 + !byte $89,%10101111 + !byte $35,%10101111 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $7D,%11001101 + !byte $7D,%11101101 + !byte $49,%01101100 + !byte $49,%10001101; + !byte $6D,%00101100 + !byte $7D,%01101110 + !byte $7D,%10001111; + !byte $37,%01101110 + !byte $37,%10001111; + !byte $41,%01101110 + !byte $41,%10001111; + !byte $7D,%00001110 + !byte $91,%01010010 + !byte $7D,%10101101 + !byte $8D,%11010011 + !byte $5B,%00001100 + !byte $8B,%11110011 + !byte $35,%11010001 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $57,%11001011 + !byte $7D,%00101110 + !byte $87,%01110000 + !byte $87,%10010001; + !byte $8F,%10110011 + !byte $91,%00110010 + !byte $2D,%00110010 + !byte $4D,%10101101 + !byte $55,%11001011 + !byte $7D,%01001110 + !byte $6F,%10101101 + !byte $89,%00110000 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $45,%01001100 + !byte $69,%11001011 + !byte $2F,%11110001 + !byte $6D,%00001100 + !byte $7D,%01101100 + !byte $7D,%10001101; + !byte $91,%01110010 + !byte $91,%10010011; + !byte $5D,%00101100 + !byte $2D,%00010010 + !byte $33,%11010001 + !byte $87,%10110001 + !byte $47,%01001100 + !byte $4B,%01101100 + !byte $4B,%10001101; + !byte $59,%11001011 + !byte $5F,%01001100 + !byte $6B,%11001011 + !byte $37,%10110001 + !byte $35,%01101110 + !byte $35,%10001111; + !byte $43,%01001100 + !byte $4F,%10101101 + !byte $5B,%11101011 + !byte $6F,%01101100 + !byte $6F,%10001101; + !byte $8B,%11001111 + !byte $8B,%11101111 + !byte $89,%01010000 + !byte $31,%11010001 + !byte $6D,%11101011 + !byte $8B,%00010000 + !byte $49,%01001100 + !byte $39,%01001110 + !byte $91,%10110011 + !byte $8F,%11010011 + !byte $6F,%01001100 + !byte $8D,%11110011 + !byte $2D,%11110001 + !byte $37,%01001110 + !byte $3B,%01001110 + !byte $5D,%00001100 + !byte $7F,%11001101 + !byte $7F,%11101101 + !byte $41,%01001110 + !byte $35,%10110001 + !byte $7F,%10101101 + !byte $3D,%01001110 + !byte $45,%00101100 + !byte $4D,%01101100 + !byte $4D,%10001101; + !byte $57,%10101011 + !byte $8B,%10101111 + !byte $2F,%11010001 + !byte $89,%01110000 + !byte $89,%10010001; + !byte $6F,%00101100 + !byte $7F,%00001110 + !byte $8B,%00110000 + !byte $5F,%00101100 + !byte $6D,%11001011 + !byte $71,%10101101 + !byte $7F,%01101110 + !byte $7F,%10001111; + !byte $35,%01001110 + !byte $3F,%01001110 + !byte $47,%00101100 + !byte $59,%10101011 + !byte $5B,%11001011 + !byte $7F,%00101110 + !byte $93,%01010010 + !byte $33,%10110001 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $4B,%01001100 + !byte $93,%01110010 + !byte $93,%10010011; + !byte $6F,%00001100 + !byte $7F,%01101100 + !byte $7F,%10001101; + !byte $33,%11110011 + !byte $7F,%01001110 + !byte $5D,%11101011 + !byte $43,%00101100 + !byte $91,%11010011 + !byte $8F,%11110011 + !byte $4F,%01101100 + !byte $4F,%10001101; + !byte $8D,%11101111 + !byte $89,%10110001 + !byte $2D,%11010001 + !byte $31,%10110001 + !byte $6F,%11101011 + !byte $8D,%11001111 + !byte $8B,%01010000 + !byte $71,%01101100 + !byte $71,%10001101; + !byte $49,%00101100 + !byte $93,%10110011 + !byte $39,%00101110 + !byte $6B,%10101011 + !byte $37,%00101110 + !byte $3B,%00101110 + !byte $8D,%00010000 + !byte $89,%11010001 + !byte $5F,%00001100 + !byte $6D,%10101011 + !byte $5B,%10101011 + !byte $4D,%01001100 + !byte $2F,%10110001 + !byte $2B,%11110001 + !byte $3D,%00101110 + !byte $45,%00001100 + !byte $6F,%11001011 + !byte $35,%00101110 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $71,%01001100 + !byte $41,%00101110 + !byte $47,%00001100 + !byte $61,%00101100 + !byte $7D,%01001100 + !byte $81,%10101101 + !byte $81,%11001101 + !byte $5D,%11001011 + !byte $59,%01101010 + !byte $59,%10001011; + !byte $81,%11101101 + !byte $8B,%01110000 + !byte $8B,%10010001; + !byte $4B,%00101100 + !byte $8D,%00110000 + !byte $2B,%00010010 + !byte $3F,%00101110 + !byte $57,%01101010 + !byte $57,%10001011; + !byte $71,%00101100 + !byte $81,%00001110 + !byte $93,%11010011 + !byte $91,%11110011 + !byte $7F,%01001100 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $81,%01101100 + !byte $81,%10001101; + !byte $2B,%11010001 + !byte $2D,%10110001 + !byte $81,%00101110 + !byte $31,%11110011 + !byte $49,%00001100 + !byte $5F,%11101011 + !byte $71,%00001100 + !byte $81,%01101110 + !byte $81,%10001111; + !byte $4F,%01001100 + !byte $95,%01110010 + !byte $95,%10010011; + !byte $5B,%01101010 + !byte $5B,%10001011; + !byte $6F,%10101011 + !byte $81,%01001110 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $95,%10110011 + !byte $37,%00001110 + !byte $39,%00001110 + !byte $71,%11101011 + !byte $8F,%11101111 + !byte $8B,%10110001 + !byte $5D,%10101011 + !byte $8D,%01010000 + !byte $3B,%00001110 + !byte $4D,%00101100 + !byte $35,%00001110 + !byte $43,%00001100 + !byte $61,%00001100 + !byte $73,%01101100 + !byte $73,%10001101; + !byte $8F,%11001111 + !byte $8F,%00010000 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $2B,%10110001 + !byte $45,%11101011 + !byte $47,%11101011 + !byte $81,%01001100 + !byte $93,%11110011 + !byte $35,%01010000 + !byte $71,%11001011 + !byte $4B,%00001100 + !byte $3D,%00001110 + !byte $31,%11010011 + !byte $5F,%11001011 + !byte $95,%11010011 + !byte $8D,%01110000 + !byte $8D,%10010001; + !byte $41,%00001110 + !byte $8B,%11010001 + !byte $73,%01001100 + !byte $83,%10101101 + !byte $83,%11001101 + !byte $8F,%00110000 + !byte $2F,%11110011 + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $3F,%00001110 + !byte $49,%11101011 + !byte $59,%01001010 + !byte $5D,%01101010 + !byte $5D,%10001011; + !byte $33,%01010000 + !byte $83,%01101100 + !byte $83,%10001101; + !byte $83,%11101101 + !byte $5B,%01001010 + !byte $71,%10101011 + !byte $4F,%00101100 + !byte $6F,%01101010 + !byte $6F,%10001011; + !byte $73,%00101100 + !byte $83,%00001110 + !byte $61,%11101011 + !byte $37,%11101101 + !byte $5F,%10101011 + !byte $31,%01010000 + !byte $39,%11101101 + !byte $4D,%00001100 + !byte $73,%00001100 + !byte $83,%00101110 + !byte $95,%11110011 + !byte $63,%00001100 + !byte $6D,%01101010 + !byte $6D,%10001011; + !byte $8F,%01010000 + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $83,%01101110 + !byte $83,%10001111; + !byte $8D,%10110001 + !byte $3B,%11101101 + !byte $35,%11101101 + !byte $2F,%01010000 + !byte $4B,%11101011 + !byte $73,%11101011 + !byte $83,%01001110 + !byte $91,%11101111 + !byte $47,%11001011 + !byte $2D,%11110011 + !byte $91,%00010000 + !byte $97,%10110011 + !byte $35,%00110000 + !byte $83,%01001100 + !byte $2F,%11010011 + !byte $3D,%11101101 + !byte $45,%11001011 + !byte $51,%00101100 + !byte $61,%11001011 + !byte $71,%01101010 + !byte $71,%10001011; + !byte $75,%01101100 + !byte $75,%10001101; + !byte $33,%00101110 + !byte $5D,%01001010 + !byte $73,%11001011 + !byte $97,%11010011 + !byte $2D,%01010000 + !byte $29,%10110001 + !byte $91,%00110000 + !byte $33,%00001110 + !byte $49,%11001011 + !byte $5F,%01101010 + !byte $5F,%10001011; + !byte $91,%11001111 + !byte $3F,%11101101 + !byte $41,%11101101 + !byte $85,%10101101 + !byte $8F,%01110000 + !byte $8F,%10010001; + !byte $85,%11001101 + !byte $33,%00110000 + !byte $4F,%00001100 + !byte $8D,%11010001 + !byte $85,%01101100 + !byte $85,%10001101; + !byte $73,%10101011 + !byte $75,%01001100 + !byte $2B,%01010000 + !byte $5B,%00101010 + !byte $29,%11010001 + !byte $85,%11101101 + !byte $63,%11101011 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $2B,%11110011 + !byte $37,%11001101 + !byte $39,%11001101 + !byte $4D,%11101011 + !byte $97,%11110011 + !byte $61,%10101011 + !byte $31,%00110000 + !byte $75,%00101100 + !byte $85,%00001110 + !byte $91,%01010000 + !byte $35,%11001101 + !byte $4B,%11001011 + !byte $2D,%11010011 + !byte $5D,%00101010 + !byte $8D,%11110001 + !byte $3B,%11001101 + !byte $5F,%01001010 + !byte $2F,%10110011 + !byte $2F,%00110000 + !byte $47,%10101011 + !byte $75,%00001100 + !byte $8F,%10110001 + !byte $33,%11101101 + !byte $35,%00010000 + !byte $73,%01101010 + !byte $73,%10001011; + !byte $85,%00101110 + !byte $85,%01001100 + !byte $2D,%00110000 + !byte $3D,%11001101 + !byte $75,%11101011 + !byte $93,%11101111 + !byte $93,%00010000 + !byte $49,%10101011 + !byte $51,%00001100 + !byte $85,%01001110 + !byte $63,%11001011 + !byte $85,%01101110 + !byte $85,%10001111; + !byte $29,%01010000 + !byte $61,%01101010 + !byte $61,%10001011; + !byte $45,%10101011 + !byte $75,%11001011 + !byte $93,%00110000 + !byte $29,%11110011 + !byte $59,%00101010 + !byte $91,%01110000 + !byte $91,%10010001; + !byte $2B,%00110000 + !byte $4F,%11101011 + !byte $3F,%11001101 + !byte $4D,%11001011 + !byte $33,%00010000 + !byte $5F,%00101010 + !byte $71,%01001010 + !byte $87,%10101101 + !byte $99,%11010011 + !byte $41,%11001101 + !byte $8F,%11010001 + !byte $2B,%11010011 + !byte $65,%11101011 + !byte $37,%10101101 + !byte $75,%10101011 + !byte $87,%11001101 + !byte $99,%11110011 + !byte $4B,%10101011 + !byte $87,%01101100 + !byte $87,%10001101; + !byte $33,%11001101 + !byte $39,%10101101 + !byte $35,%10101101 + !byte $87,%11101101 + !byte $31,%00010000 + !byte $5D,%00001010 + !byte $61,%01001010 + !byte $63,%10101011 + !byte $77,%01001100 + !byte $2D,%10110011 + !byte $73,%01001010 + !byte $93,%01010000 + !byte $3B,%10101101 + !byte $2F,%00010000 + !byte $5B,%00001010 + !byte $27,%11110011 + !byte $47,%01101010 + !byte $47,%10001011; + !byte $87,%00001110 + !byte $91,%10110001 + !byte $29,%00110000 + !byte $75,%01101010 + !byte $75,%10001011; + !byte $49,%01101010 + !byte $49,%10001011; + !byte $77,%00101100 + !byte $87,%01001100 + !byte $8F,%11110001 + !byte $51,%11101011 + !byte $2D,%00010000 + !byte $3D,%10101101 + !byte $77,%00001100 + !byte $29,%11010011 + !byte $4F,%11001011 + !byte $87,%00101110 + !byte $95,%00010000 + !byte $4D,%10101011 + !byte $63,%01101010 + !byte $63,%10001011; + !byte $5F,%00001010 + !byte $65,%11001011 + !byte $93,%01110000 + !byte $93,%10010001; + !byte $77,%11101011 + !byte $2B,%00010000 + !byte $61,%00101010 + !byte $3F,%10101101 + !byte $4B,%01101010 + !byte $4B,%10001011; + !byte $95,%00110000 + !byte $2B,%10110011 + !byte $77,%11001011 + !byte $37,%01101100 + !byte $37,%10001101; + !byte $75,%01001010 + !byte $87,%01001110 + !byte $33,%11101111 + !byte $95,%11101111 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $33,%10101101 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $39,%01101100 + !byte $39,%10001101; + !byte $53,%11101011 + !byte $89,%10101101 + !byte $87,%01101110 + !byte $87,%10001111; + !byte $91,%11010001 + !byte $27,%01010000 + !byte $41,%10101101 + !byte $77,%10101011 + !byte $89,%01101100 + !byte $89,%10001101; + !byte $89,%11001101 + !byte $95,%01010000 + !byte $25,%11110011 + !byte $27,%11010011 + !byte $29,%00010000 + !byte $31,%11101111 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $63,%01001010 + !byte $89,%11101101 + !byte $93,%10110001 + !byte $45,%01101010 + !byte $45,%10001011; + !byte $65,%10101011 + !byte $51,%11001011 + !byte $77,%01101010 + !byte $77,%10001011; + !byte $2F,%11101111 + !byte $27,%00110000 + !byte $49,%01001010 + !byte $61,%00001010 + !byte $79,%01001100 + !byte $9B,%11110011 + !byte $47,%01001010 + !byte $4F,%10101011 + !byte $29,%10110011 + !byte $2D,%11101111 + !byte $4D,%01101010 + !byte $4D,%10001011; + !byte $5D,%11101001 + !byte $5F,%11101001 + !byte $89,%01001100 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $67,%11001011 + !byte $89,%00001110 + !byte $91,%11110001 + !byte $2B,%11101111 + !byte $4B,%01001010 + !byte $63,%00101010 + !byte $79,%00101100 + !byte $95,%01110000 + !byte $95,%10010001; + !byte $65,%01101010 + !byte $65,%10001011; + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $2D,%01010010 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $77,%01001010 + !byte $37,%01001100 + !byte $79,%00001100 + !byte $97,%00010000 + !byte $25,%11010011 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $89,%00101110 + !byte $97,%00110000 + !byte $35,%01001100 + !byte $79,%11101011 + !byte $27,%00010000 + !byte $39,%01001100 + !byte $23,%11110011 + !byte $33,%11001111 + !byte $93,%11010001 + !byte $29,%11101111 + !byte $79,%11001011 + !byte $53,%11001011 + !byte $61,%11101001 + !byte $27,%10110011 + !byte $41,%01101100 + !byte $41,%10001101; + !byte $8B,%10101101 + !byte $91,%00010010 + !byte $4F,%01101010 + !byte $4F,%10001011; + !byte $75,%00101010 + !byte $89,%01001110 + !byte $97,%01010000 + !byte $3B,%01001100 + !byte $51,%10101011 + !byte $31,%11001111 + !byte $4D,%01001010 + !byte $8B,%11001101 + !byte $95,%10110001 + !byte $63,%00001010 + !byte $65,%01001010 + !byte $79,%10101011 + !byte $8B,%01101100 + !byte $8B,%10001101; + !byte $29,%01110010 + !byte $29,%10010011; + !byte $49,%00101010 + !byte $67,%10101011 + !byte $89,%01101110 + !byte $89,%10001111; + !byte $2F,%11001111 + !byte $79,%01101010 + !byte $79,%10001011; + !byte $8B,%11101101 + !byte $2D,%11001111 + !byte $4B,%00101010 + !byte $93,%11110001 + !byte $3D,%01001100 + !byte $23,%11010011 + !byte $2B,%01010010 + !byte $47,%00101010 + !byte $25,%10110011 + !byte $2B,%11001111 + !byte $77,%00101010 + !byte $7B,%01001100 + !byte $27,%11101111 + !byte $97,%01110000 + !byte $97,%10010001; + !byte $8B,%01001100 + !byte $8B,%00001110 + !byte $65,%00101010 + !byte $33,%01001100 + !byte $37,%00101100 + !byte $5F,%11001001 + !byte $79,%01001010 + !byte $67,%01101010 + !byte $67,%10001011; + !byte $95,%11010001 + !byte $35,%00101100 + !byte $39,%00101100 + !byte $63,%11101001 + !byte $7B,%00101100 + !byte $29,%11001111 + !byte $3F,%01001100 + !byte $61,%11001001 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $51,%01101010 + !byte $51,%10001011; + !byte $53,%10101011 + !byte $4F,%01001010 + !byte $21,%11110011 + !byte $33,%10101111 + !byte $8B,%00101110 + !byte $4D,%00101010 + !byte $7B,%00001100 + !byte $99,%00110000 + !byte $7B,%11101011 + !byte $41,%01001100 + !byte $65,%00001010 + !byte $7B,%11001011 + !byte $97,%10110001 + !byte $3B,%00101100 + !byte $93,%00010010 + !byte $23,%10110011 + !byte $29,%01010010 + !byte $31,%10101111 + !byte $8D,%10101101 + !byte $99,%01010000 + !byte $7B,%10101011 + !byte $99,%00010000 + !byte $79,%00101010 + !byte $27,%11001111 + !byte $2F,%10101111 + !byte $49,%00001010 + !byte $4B,%00001010 + !byte $67,%01001010 + !byte $8D,%01101100 + !byte $8D,%10001101; + !byte $8D,%11001101 + !byte $8B,%01001110 + !byte $21,%11010011 + !byte $69,%10101011 + !byte $2D,%10101111 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $63,%11001001 + !byte $7B,%01101010 + !byte $7B,%10001011; + !byte $3D,%00101100 + !byte $2B,%00110010 + !byte $2B,%10101111 + !byte $8B,%01101110 + !byte $8B,%10001111; + !byte $95,%11110001 + !byte $55,%10101011 + !byte $8D,%11101101 + !byte $99,%01110000 + !byte $99,%10010001; + !byte $35,%00001100 + !byte $37,%00001100 + !byte $4F,%00101010 + !byte $7B,%01001010 + !byte $51,%01001010 + !byte $65,%11101001 + !byte $93,%00110010 + !byte $97,%11010001 + !byte $29,%10101111 + !byte $53,%01101010 + !byte $53,%10001011; + !byte $27,%01010010 + !byte $39,%00001100 + !byte $33,%00101100 + !byte $4D,%00001010 + !byte $67,%00101010 + !byte $8D,%01001100 + !byte $8D,%00001110 + !byte $3F,%00101100 + !byte $69,%01101010 + !byte $69,%10001011; + !byte $21,%10110011 + !byte $23,%01110010 + !byte $23,%10010011; + !byte $33,%01101110 + !byte $33,%10001111; + !byte $29,%00110010 + !byte $25,%11101111 + !byte $3B,%00001100 + !byte $61,%10101001 + !byte $99,%10110001 + !byte $7D,%00101100 + !byte $8D,%00101110 + !byte $27,%10101111 + !byte $67,%00001010 + !byte $7B,%00101010 + !byte $41,%00101100 + !byte $95,%00010010 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $65,%11001001 + !byte $7D,%11101011 + !byte $9B,%01010000 + !byte $25,%01010010 + !byte $63,%10101001 + !byte $7D,%00001100 + !byte $9B,%00110000 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $49,%11101001 + !byte $4B,%11101001 + !byte $4F,%00001010 + !byte $69,%01001010 + !byte $7D,%11001011 + !byte $8F,%10101101 + !byte $25,%11001111 + !byte $97,%11110001 + !byte $8F,%11001101 + !byte $3D,%00001100 + !byte $55,%01101010 + !byte $55,%10001011; + !byte $8F,%01101100 + !byte $8F,%10001101; + !byte $51,%00101010 + !byte $7D,%10101011 + !byte $8D,%01001110 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $53,%01001010 + !byte $9B,%01110000 + !byte $9B,%10010001; + !byte $1F,%11010011 + !byte $37,%11101011 + !byte $7D,%01101010 + !byte $7D,%10001011; + !byte $35,%11101011 + !byte $39,%11101011 + !byte $67,%11101001 + !byte $8F,%11101101 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $29,%01101110 + !byte $29,%10001111; + !byte $4D,%11101001 + !byte $99,%11010001 + !byte $27,%00110010 + !byte $1F,%11110011 + !byte $23,%01010010 + !byte $3F,%00001100 + !byte $7D,%01001010 + !byte $8D,%01101110 + !byte $8D,%10001111; + !byte $1F,%10110011 + !byte $79,%00001010 + !byte $95,%00110010 + !byte $69,%00101010 + !byte $8F,%00001110 + !byte $65,%10101001 + !byte $33,%00001100 + !byte $6B,%01101010 + !byte $6B,%10001011; + !byte $8F,%01001100 + !byte $8D,%10101111 + !byte $25,%10101111 + !byte $33,%01001110 + !byte $3B,%11101011 + !byte $9B,%10110001 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $29,%00010010 + !byte $97,%00010010 + !byte $51,%00001010 + !byte $7B,%00001010 + !byte $67,%11001001 + !byte $7D,%00101010 + !byte $4F,%11101001 + !byte $41,%00001100 + !byte $69,%00001010 + !byte $25,%00110010 + !byte $8F,%00101110 + !byte $53,%00101010 + !byte $2F,%01001110 + !byte $31,%01001110 + !byte $4B,%11001001 + !byte $55,%01001010 + !byte $7F,%00101100 + !byte $3D,%11101011 + !byte $99,%11110001 + !byte $95,%01010010 + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $21,%01010010 + !byte $2D,%01001110 + !byte $91,%10101101 + !byte $2B,%01001110 + !byte $37,%11001011 + !byte $4D,%11001001 + !byte $63,%01101000 + !byte $63,%10001001; + !byte $6B,%01001010 + !byte $7F,%11101011 + !byte $7F,%00001100 + !byte $91,%11001101 + !byte $9D,%01010000 + !byte $9B,%11010001 + !byte $7F,%11001011 + !byte $91,%01101100 + !byte $91,%10001101; + !byte $27,%00010010 + !byte $29,%01001110 + !byte $39,%11001011 + !byte $7F,%10101011 + !byte $8F,%01001110 + !byte $9D,%01110000 + !byte $9D,%10010001; + !byte $25,%01101110 + !byte $25,%10001111; + !byte $7F,%01101010 + !byte $7F,%10001011; + !byte $23,%00110010 + !byte $35,%11001011 + !byte $67,%10101001 + !byte $91,%11101101 + !byte $65,%01101000 + !byte $65,%10001001; + !byte $69,%11101001 + !byte $3F,%11101011 + !byte $97,%00110010 + !byte $7D,%00001010 + !byte $7F,%01001010 + !byte $27,%01001110 + !byte $51,%11101001 + !byte $29,%11110001 + !byte $3B,%11001011 + !byte $4F,%11001001 + !byte $53,%00001010 + !byte $8F,%01101110 + !byte $8F,%10001111; + !byte $9D,%10110001 + !byte $99,%00010010 + !byte $6B,%00101010 + !byte $49,%11001001 + !byte $91,%00001110 + !byte $55,%00101010 + !byte $57,%01001010 + !byte $7F,%00101010 + !byte $1F,%01010010 + !byte $9D,%00110000 + !byte $25,%00010010 + !byte $69,%11001001 + !byte $9B,%11110001 + !byte $3D,%11001011 + !byte $41,%11101011 + !byte $21,%00110010 + !byte $31,%00101110 + !byte $8F,%10101111 + !byte $67,%01101000 + !byte $67,%10001001; + !byte $1D,%10110011 + !byte $25,%01001110 + !byte $2B,%00101110 + !byte $2D,%00101110 + !byte $2F,%00101110 + !byte $37,%10101011 + !byte $4D,%10101001 + !byte $6B,%00001010 + !byte $91,%01001100 + !byte $91,%00101110 + !byte $9D,%11010001 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $29,%00101110 + !byte $39,%10101011 + !byte $4B,%10101001 + !byte $97,%01010010 + !byte $43,%11101011 + !byte $27,%11110001 + !byte $69,%10101001 + !byte $81,%00101100 + !byte $93,%10101101 + !byte $93,%11001101 + !byte $23,%00010010 + !byte $7F,%00001010 + !byte $6D,%01001010 + !byte $35,%10101011 + !byte $51,%11001001 + !byte $27,%00101110 + !byte $3F,%11001011 + !byte $81,%11001011 + !byte $81,%11101011 + !byte $81,%00001100 + !byte $99,%00110010 + !byte $6B,%11101001 + !byte $53,%11101001 + !byte $91,%01001110 + !byte $3B,%10101011 + !byte $4F,%10101001 + !byte $81,%01101010 + !byte $81,%10001011; + !byte $81,%10101011 + !byte $93,%01101100 + !byte $93,%10001101; + !byte $9F,%01110000 + !byte $9F,%10010001; + !byte $55,%00001010 + !byte $9B,%00010010 + !byte $1F,%00110010 + !byte $93,%11101101 + !byte $1D,%01010010 + !byte $57,%00101010 + !byte $81,%01001010 + !byte $9F,%10110001 + !byte $9D,%11110001 + !byte $21,%00010010 + !byte $25,%11110001 + !byte $9F,%01010000 + !byte $65,%01001000 + !byte $93,%00001110 + !byte $91,%01101110 + !byte $91,%10001111; + !byte $97,%01110010 + !byte $97,%10010011; + !byte $6B,%11001001 + !byte $6D,%00101010 + !byte $3D,%10101011 + !byte $41,%11001011 + !byte $67,%01001000 + !byte $81,%00101010 + !byte $25,%00101110 + !byte $69,%01101000 + !byte $69,%10001001; + !byte $9F,%11010001 + !byte $2B,%00001110 + !byte $2D,%00001110 + !byte $2F,%00001110 + !byte $31,%00001110 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $51,%10101001 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $53,%11001001 + !byte $99,%01010010 + !byte $29,%00001110 + !byte $4D,%01101000 + !byte $4D,%10001001; + !byte $6D,%00001010 + !byte $91,%10101111 + !byte $1D,%00110010 + !byte $27,%11010001 + !byte $55,%11101001 + !byte $23,%11110001 + !byte $93,%00101110 + !byte $43,%11001011 + !byte $6B,%10101001 + !byte $9B,%00110010 + !byte $1F,%00010010 + !byte $27,%00001110 + !byte $3F,%10101011 + !byte $81,%00001010 + !byte $35,%01101010 + !byte $35,%10001011; + !byte $4F,%01101000 + !byte $4F,%10001001; + !byte $95,%10101101 + !byte $95,%11001101 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $9D,%00010010 + !byte $57,%00001010 + !byte $6F,%01001010 + !byte $69,%01001000 + !byte $6D,%11101001 + !byte $83,%10101011 + !byte $83,%00101100 + !byte $95,%11101101 + !byte $93,%01001110 + !byte $9F,%11110001 + !byte $25,%00001110 + !byte $83,%01101010 + !byte $83,%10001011; + !byte $83,%11001011 + !byte $83,%00001100 + !byte $21,%11110001 + !byte $25,%11010001 + !byte $6B,%01101000 + !byte $6B,%10001001; + !byte $83,%11101011 + !byte $95,%01101100 + !byte $95,%10001101; + !byte $83,%01001010 + !byte $51,%01101000 + !byte $51,%10001001; + !byte $A1,%10110001 + !byte $99,%01110010 + !byte $99,%10010011; + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $53,%10101001 + !byte $41,%10101011 + !byte $55,%11001001 + !byte $83,%00101010 + !byte $A1,%01110000 + !byte $A1,%10010001; + !byte $6D,%11001001 + !byte $6F,%00101010 + !byte $95,%00001110 + !byte $9B,%01010010 + !byte $1B,%01010010 + !byte $1D,%00010010 + !byte $37,%01001010 + !byte $9D,%00110010 + !byte $93,%01101110 + !byte $93,%10001111; + !byte $23,%11010001 + !byte $29,%11101101 + !byte $2B,%11101101 + !byte $2D,%11101101 + !byte $39,%01001010 + !byte $57,%11101001 + !byte $A1,%11010001 + !byte $2F,%11101101 + !byte $1F,%11110001 + !byte $31,%11101101 + !byte $4B,%01101000 + !byte $4B,%10001001; + !byte $93,%01001100 + !byte $1B,%00110010 + !byte $23,%01001110 + !byte $27,%10110001 + !byte $27,%11101101 + !byte $23,%00101110 + !byte $9F,%00010010 + !byte $95,%00101110 + !byte $3B,%01001010 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $59,%00001010 + !byte $6B,%01001000 + !byte $6D,%10101001 + !byte $83,%00001010 + !byte $43,%10101011 + !byte $4F,%01001000 + !byte $6F,%00001010 + !byte $93,%10101111 + !byte $7F,%11101001 + !byte $4D,%01001000 + !byte $A1,%11110001 + !byte $99,%10110011 + !byte $67,%00101000 + !byte $69,%00101000 + !byte $81,%11101001 + !byte $35,%01001010 + !byte $53,%01101000 + !byte $53,%10001001; + !byte $25,%11101101 + !byte $97,%10101101 + !byte $97,%11001101 + !byte $55,%10101001 + !byte $21,%11010001 + !byte $3D,%01001010 + !byte $93,%11001111 + !byte $51,%01001000 + !byte $6D,%01101000 + !byte $6D,%10001001; + !byte $1B,%00010010 + !byte $1D,%11110001 + !byte $25,%10110001 + !byte $6F,%11101001 + !byte $97,%11101101 + !byte $95,%01001110 + !byte $9B,%01110010 + !byte $9B,%10010011; + !byte $41,%01101010 + !byte $41,%10001011; + !byte $57,%11001001 + !byte $85,%01101010 + !byte $85,%10001011; + !byte $85,%10101011 + !byte $85,%11001011 + !byte $9D,%01010010 + !byte $23,%00001110 + !byte $85,%00001100 + !byte $85,%00101100 + !byte $85,%01001010 + !byte $85,%11101011 + !byte $9F,%00110010 + !byte $2B,%11001101 + !byte $37,%00101010 + !byte $39,%00101010 + !byte $6B,%00101000 + !byte $6F,%11001001 + !byte $85,%00101010 + !byte $97,%00001110 + !byte $1F,%11010001 + !byte $27,%01110000 + !byte $27,%10010001; + !byte $71,%00101010 + !byte $97,%01101100 + !byte $97,%10001101; + !byte $29,%11001101 + !byte $2D,%11001101 + !byte $A1,%00010010 + !byte $23,%10110001 + !byte $59,%11101001 + !byte $95,%01101110 + !byte $95,%10001111; + !byte $3F,%01001010 + !byte $27,%11001101 + !byte $2F,%11001101 + !byte $31,%11001101 + !byte $6D,%01001000 + !byte $A3,%10110001 + !byte $A3,%11010001 + !byte $3B,%00101010 + !byte $83,%11101001 + !byte $55,%01101000 + !byte $55,%10001001; + !byte $85,%00001010 + !byte $43,%01101010 + !byte $43,%10001011; + !byte $53,%01001000 + !byte $6F,%10101001 + !byte $23,%11101101 + !byte $57,%10101001 + !byte $25,%11001101 + !byte $97,%00101110 + !byte $1B,%11110001 + !byte $1D,%11010001 + !byte $21,%10110001 + !byte $4F,%00101000 + !byte $71,%00001010 + !byte $A3,%11110001 + !byte $9B,%10110011 + !byte $95,%10101111 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $51,%00101000 + !byte $9D,%01110010 + !byte $9D,%10010011; + !byte $3D,%00101010 + !byte $9F,%01010010 + !byte $41,%01001010 + !byte $99,%11001101 + !byte $59,%11001001 + !byte $6D,%00101000 + !byte $6F,%01101000 + !byte $6F,%10001001; + !byte $A1,%00110010 + !byte $35,%00101010 + !byte $71,%11101001 + !byte $99,%10101101 + !byte $99,%11101101 + !byte $97,%01001110 + !byte $5B,%11101001 + !byte $39,%00001010 + !byte $87,%01101010 + !byte $87,%10001011; + !byte $55,%01001000 + !byte $95,%11001111 + !byte $1F,%10110001 + !byte $27,%10101101 + !byte $29,%10101101 + !byte $2B,%10101101 + !byte $37,%00001010 + !byte $3F,%00101010 + !byte $53,%00101000 + !byte $87,%11001011 + !byte $A3,%00010010 + !byte $87,%01001010 + !byte $87,%10101011 + !byte $1B,%11010001 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $85,%11101001 + !byte $19,%00010010 + !byte $2D,%10101101 + !byte $3B,%00001010 + !byte $57,%01101000 + !byte $57,%10001001; + !byte $6F,%01001000 + !byte $87,%00101010 + !byte $71,%11001001 + !byte $87,%11101011 + !byte $99,%00001110 + !byte $87,%00101100 + !byte $9B,%11010011 + !byte $2F,%10101101 + !byte $31,%10101101 + !byte $43,%01001010 + !byte $6B,%00001000 + !byte $73,%00101010 + !byte $87,%00001100 + !byte $97,%01101110 + !byte $97,%10001111; + !byte $23,%11001101 + !byte $19,%11110001 + !byte $9D,%10110011 + !byte $1D,%10110001 + !byte $25,%10101101 + !byte $9F,%01110010 + !byte $9F,%10010011; + !byte $87,%00001010 + !byte $A1,%01010010 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $3D,%00001010 + !byte $99,%00101110 + !byte $59,%10101001 + !byte $71,%10101001 + !byte $A3,%00110010 + !byte $6D,%00001000 + !byte $51,%00001000 + !byte $A5,%11010001 + !byte $A5,%11110001 + !byte $25,%01010000 + !byte $41,%00101010 + !byte $55,%00101000 + !byte $5B,%11001001 + !byte $99,%01101100 + !byte $99,%10001101; + !byte $6F,%00101000 + !byte $73,%00001010 + !byte $97,%10101111 + !byte $45,%01001010 + !byte $57,%01001000 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $1B,%10110001 + !byte $39,%11101001 + !byte $53,%00001000 + !byte $71,%01101000 + !byte $71,%10001001; + !byte $9B,%11001101 + !byte $99,%01001110 + !byte $19,%11010001 + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $9B,%11101101 + !byte $29,%01101100 + !byte $29,%10001101; + !byte $A5,%00010010 + !byte $3B,%11101001 + !byte $3F,%00001010 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $4F,%00001000 + !byte $23,%01010000 + !byte $23,%10101101 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $73,%11101001 + !byte $87,%11101001 + !byte $9F,%10110011 + !byte $37,%11101001 + !byte $59,%01101000 + !byte $59,%10001001; + !byte $9B,%10101101 + !byte $A1,%01110010 + !byte $A1,%10010011; + !byte $9D,%11010011 + !byte $89,%01001010 + !byte $89,%01101010 + !byte $89,%10001011; + !byte $97,%11001111 + !byte $71,%01001000 + !byte $89,%10101011 + !byte $9B,%00001110 + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $43,%00101010 + !byte $89,%00101010 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $89,%11001011 + !byte $A3,%01010010 + !byte $25,%01101100 + !byte $25,%10001101; + !byte $6F,%00001000 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $73,%11001001 + !byte $99,%01101110 + !byte $99,%10001111; + !byte $57,%00101000 + !byte $5B,%10101001 + !byte $89,%11101011 + !byte $A5,%00110010 + !byte $3D,%11101001 + !byte $21,%01010000 + !byte $41,%00001010 + !byte $89,%00001100 + !byte $89,%00101100 + !byte $9B,%00101110 + !byte $55,%00001000 + !byte $89,%00001010 + !byte $97,%11101111 + !byte $19,%10110001 + !byte $5D,%11001001 + !byte $73,%10101001 + !byte $25,%00110000 + !byte $71,%00101000 + !byte $45,%00101010 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $59,%01001000 + !byte $1F,%01010000 + !byte $99,%10101111 + !byte $9D,%11110011 + !byte $3F,%11101001 + !byte $23,%01101100 + !byte $23,%10001101; + !byte $39,%11001001 + !byte $53,%11100111 + !byte $75,%00001010 + !byte $29,%01001100 + !byte $3B,%11001001 + !byte $73,%01101000 + !byte $73,%10001001; + !byte $9F,%11010011 + !byte $9B,%01001110 + !byte $A1,%10110011 + !byte $A3,%01110010 + !byte $A3,%10010011; + !byte $27,%01001100 + !byte $2B,%01001100 + !byte $51,%11100111 + !byte $89,%11101001 + !byte $9D,%11001101 + !byte $9D,%11101101 + !byte $A5,%01010010 + !byte $23,%00110000 + !byte $5B,%01101000 + !byte $5B,%10001001; + !byte $1D,%01010000 + !byte $25,%01001100 + !byte $2D,%01001100 + !byte $57,%00001000 + !byte $A7,%11110001 + !byte $A7,%00010010 + !byte $43,%00001010 + !byte $71,%00001000 + !byte $8B,%01001010 + !byte $9D,%00001110 + !byte $2F,%01001100 + !byte $3D,%11001001 + !byte $6D,%11100111 + !byte $55,%11100111 + !byte $73,%01001000 + !byte $75,%11101001 + !byte $19,%01110000 + !byte $19,%10010001; + !byte $37,%11001001 + !byte $6F,%11100111 + !byte $8B,%00101010 + !byte $8B,%01101010 + !byte $8B,%10001011; + !byte $99,%11001111 + !byte $21,%00110000 + !byte $5D,%10101001 + !byte $8B,%10101011 + !byte $41,%11101001 + !byte $31,%01001100 + !byte $59,%00101000 + !byte $8B,%11001011 + !byte $A7,%00110010 + !byte $9B,%01101110 + !byte $9B,%10001111; + !byte $75,%11001001 + !byte $17,%11010001 + !byte $25,%00010000 + !byte $8B,%11101011 + !byte $9D,%10101101 + !byte $1B,%01010000 + !byte $5B,%01001000 + !byte $8B,%00001010 + !byte $9D,%00101110 + !byte $73,%00101000 + !byte $A5,%01110010 + !byte $A5,%10010011; + !byte $A3,%10110011 + !byte $17,%10110001 + !byte $A1,%11010011 + !byte $1F,%00110000 + !byte $23,%01001100 + !byte $45,%00001010 + !byte $8B,%00001100 + !byte $8B,%00101100 + !byte $75,%10101001 + !byte $9F,%11110011 + !byte $3F,%11001001 + !byte $99,%11101111 + !byte $27,%00101100 + !byte $29,%00101100 + !byte $3B,%10101001 + !byte $39,%10101001 + !byte $57,%11100111 + !byte $71,%11100111 + !byte $9B,%10101111 + !byte $2B,%00101100 + !byte $43,%11101001 + !byte $59,%00001000 + !byte $5D,%01101000 + !byte $5D,%10001001; + !byte $9D,%01001110 + !byte $A7,%01010010 + !byte $25,%00101100 + !byte $53,%11000111 + !byte $75,%01101000 + !byte $75,%10001001; + !byte $23,%00010000 + !byte $2D,%00101100 + !byte $77,%00001010 + !byte $19,%01010000 + !byte $1D,%00110000 + !byte $73,%00001000 + !byte $3D,%10101001 + !byte $47,%00001010 + !byte $55,%11000111 + !byte $8B,%11101001 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $41,%11001001 + !byte $9F,%11101101 + !byte $5B,%00101000 + !byte $5F,%10101001 + !byte $75,%01001000 + !byte $9F,%00001110 + !byte $2F,%00101100 + !byte $9B,%11001111 + !byte $21,%00010000 + !byte $31,%00101100 + !byte $77,%11101001 + !byte $8D,%01101010 + !byte $8D,%10001011; + !byte $A5,%10110011 + !byte $A3,%11010011 + !byte $8D,%01001010 + !byte $9F,%11001101 + !byte $9D,%01101110 + !byte $9D,%10001111; + !byte $1B,%00110000 + !byte $8D,%00101010 + !byte $A7,%01110010 + !byte $A7,%10010011; + !byte $8D,%10101011 + !byte $59,%11100111 + !byte $A1,%11110011 + !byte $3F,%10101001 + !byte $75,%00101000 + !byte $9F,%00101110 + !byte $A9,%00010010 + !byte $A9,%00110010 + !byte $45,%11101001 + !byte $5D,%01001000 + !byte $73,%11100111 + !byte $23,%00101100 + !byte $8D,%00001010 + !byte $8D,%11001011 + !byte $57,%11000111 + !byte $1F,%00010000 + !byte $77,%11001001 + !byte $27,%00001100 + !byte $29,%00001100 + !byte $8D,%11101011 + !byte $9D,%10101111 + !byte $17,%01010000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $5B,%00001000 + !byte $9B,%11101111 + !byte $19,%00110000 + !byte $2B,%00001100 + !byte $77,%10101001 + !byte $A9,%01010010 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $5F,%01101000 + !byte $5F,%10001001; + !byte $8D,%00001100 + !byte $37,%10101001 + !byte $43,%11001001 + !byte $9F,%01001110 + !byte $1D,%00010000 + !byte $8D,%00101100 + !byte $25,%00001100 + !byte $23,%11101111 + !byte $2D,%00001100 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $75,%00001000 + !byte $41,%10101001 + !byte $47,%11101001 + !byte $A7,%10110011 + !byte $A5,%11010011 + !byte $5D,%00101000 + !byte $2F,%00001100 + !byte $8D,%11101001 + !byte $A3,%11110011 + !byte $77,%01101000 + !byte $77,%10001001; + !byte $1B,%00010000 + !byte $55,%10100111 + !byte $59,%11000111 + !byte $71,%11000111 + !byte $9F,%01101110 + !byte $9F,%10001111; + !byte $9B,%00010000 + !byte $21,%11101111 + !byte $A9,%01110010 + !byte $A9,%10010011; + !byte $31,%00001100 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $A1,%11101101 + !byte $A1,%00001110 + !byte $45,%11001001 + !byte $77,%01001000 + !byte $9D,%11001111 + !byte $5B,%11100111 + !byte $17,%00110000 + !byte $23,%00001100 + !byte $57,%10100111 + !byte $8F,%00101010 + !byte $8F,%01101010 + !byte $8F,%10001011; + !byte $75,%11100111 + !byte $8F,%01001010 + !byte $73,%11000111 + !byte $79,%11101001 + !byte $8F,%10101011 + !byte $A1,%00101110 + !byte $19,%00010000 + !byte $1F,%11101111 + !byte $43,%10101001 + !byte $5F,%01001000 + !byte $27,%11101011 + !byte $29,%11101011 + !byte $77,%00101000 + !byte $5D,%00001000 + !byte $8F,%00001010 + !byte $8F,%11001011 + !byte $2B,%11101011 + !byte $3B,%01001000 + !byte $61,%01101000 + !byte $61,%10001001; + !byte $79,%11001001 + !byte $A1,%11001101 + !byte $A5,%11110011 + !byte $1D,%11101111 + !byte $9F,%10101111 + !byte $A7,%11010011 + !byte $3D,%01001000 + !byte $8F,%11101011 + !byte $A1,%01001110 + !byte $25,%11101011 + !byte $41,%01101000 + !byte $41,%10001001; + !byte $9D,%11101111 + !byte $A9,%10110011 + !byte $5B,%11000111 + !byte $AB,%01010010 + !byte $23,%11001111 + !byte $2D,%11101011 + !byte $59,%10100111 + !byte $77,%00001000 + !byte $79,%10101001 + !byte $5F,%00101000 + !byte $1D,%11110011 + !byte $15,%01010000 + !byte $AB,%00110010 + !byte $1B,%11101111 + !byte $8F,%00001100 + !byte $39,%01001000 + !byte $47,%11001001 + !byte $2F,%11101011 + !byte $45,%10101001 + !byte $8F,%11101001 + !byte $8F,%00101100 + !byte $17,%00010000 + !byte $75,%11000111 + !byte $3F,%01001000 + !byte $79,%01101000 + !byte $79,%10001001; + !byte $5D,%11100111 + !byte $21,%11001111 + !byte $AB,%01110010 + !byte $AB,%10010011; + !byte $77,%11100111 + !byte $A1,%01101110 + !byte $A1,%10001111; + !byte $9F,%11001111 + !byte $9D,%00010000 + !byte $23,%11101011 + !byte $31,%11101011 + !byte $43,%01101000 + !byte $43,%10001001; + !byte $79,%01001000 + !byte $15,%00110000 + !byte $19,%11101111 + !byte $1F,%11001111 + !byte $33,%11101011 + !byte $91,%01001010 + !byte $A3,%00001110 + !byte $61,%01001000 + !byte $A9,%11010011 + !byte $A7,%11110011 + !byte $27,%11001011 + !byte $29,%11001011 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $5B,%10100111 + !byte $91,%00101010 + !byte $91,%01101010 + !byte $91,%10001011; + !byte $A3,%00101110 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $79,%00101000 + !byte $A3,%11101101 + !byte $5F,%00001000 + !byte $2B,%11001011 + !byte $41,%01001000 + !byte $7B,%11101001 + !byte $91,%10101011 + !byte $1D,%11001111 + !byte $25,%11001011 + !byte $3D,%00101000 + !byte $AB,%10110011 + !byte $3B,%00101000 + !byte $91,%00001010 + !byte $1D,%11010011 + !byte $59,%01100110 + !byte $59,%10000111; + !byte $5D,%11000111 + !byte $A1,%10101111 + !byte $1B,%11110011 + !byte $47,%10101001 + !byte $91,%11001011 + !byte $23,%10101111 + !byte $2D,%11001011 + !byte $9F,%11101111 + !byte $15,%00010000 + !byte $17,%11101111 + !byte $77,%11000111 + !byte $79,%00001000 + !byte $7B,%11001001 + !byte $A3,%01001110 + !byte $1B,%11001111 + !byte $3F,%00101000 + !byte $91,%11101011 + !byte $45,%01101000 + !byte $45,%10001001; + !byte $61,%00101000 + !byte $2F,%11001011 + !byte $7B,%10101001 + !byte $55,%01100110 + !byte $55,%10000111; + !byte $A9,%11110011 + !byte $21,%10101111 + !byte $23,%11001011 + !byte $5F,%11100111 + !byte $91,%00001100 + !byte $43,%01001000 + !byte $A3,%01101110 + !byte $A3,%10001111; + !byte $AB,%11010011 + !byte $79,%11100111 + !byte $31,%11001011 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $63,%01001000 + !byte $7B,%01101000 + !byte $7B,%10001001; + !byte $91,%11101001 + !byte $A1,%11001111 + !byte $19,%11001111 + !byte $5D,%10100111 + !byte $9F,%00010000 + !byte $19,%11110011 + !byte $49,%10101001 + !byte $91,%00101100 + !byte $1F,%10101111 + !byte $27,%10101011 + !byte $41,%00101000 + !byte $29,%10101011 + !byte $33,%11001011 + !byte $7B,%01001000 + !byte $AD,%01110010 + !byte $AD,%10010011; + !byte $1B,%11010011 + !byte $15,%11101111 + !byte $1D,%10101111 + !byte $25,%10101011 + !byte $61,%00001000 + !byte $93,%01001010 + !byte $2B,%10101011 + !byte $47,%01101000 + !byte $47,%10001001; + !byte $93,%00101010 + !byte $93,%01101010 + !byte $93,%10001011; + !byte $A5,%00101110 + !byte $A5,%00001110 + !byte $5F,%11000111 + !byte $3D,%00001000 + !byte $75,%10100111 + !byte $7B,%00101000 + !byte $AD,%10110011 + !byte $17,%11001111 + !byte $93,%10101011 + !byte $A3,%10101111 + !byte $A1,%11101111 + !byte $2D,%10101011 + !byte $3B,%00001000 + !byte $3F,%00001000 + !byte $59,%01000110 + !byte $79,%11000111 + !byte $93,%00001010 + !byte $9F,%00110000 + !byte $45,%01001000 + !byte $AB,%11110011 + !byte $1B,%10101111 + !byte $23,%01101110 + !byte $23,%10001111; + !byte $7D,%11101001 + !byte $A5,%01001110 + !byte $AD,%01010010 + !byte $77,%10100111 + !byte $93,%11001011 + !byte $43,%00101000 + !byte $7B,%00001000 + !byte $63,%00101000 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $61,%11100111 + !byte $17,%11110011 + !byte $2F,%10101011 + !byte $7D,%11001001 + !byte $57,%01000110 + !byte $5B,%01000110 + !byte $AD,%11010011 + !byte $19,%10101111 + !byte $23,%10101011 + !byte $A5,%11101101 + !byte $A3,%11001111 + !byte $21,%01101110 + !byte $21,%10001111; + !byte $41,%00001000 + !byte $93,%11101011 + !byte $5F,%10100111 + !byte $31,%10101011 + !byte $39,%00101000 + !byte $49,%01101000 + !byte $49,%10001001; + !byte $19,%11010011 + !byte $15,%11001111 + !byte $A5,%01101110 + !byte $A5,%10001111; + !byte $7B,%11100111 + !byte $7D,%10101001 + !byte $1B,%10110011 + !byte $27,%01101010 + !byte $27,%10001011; + !byte $29,%01101010 + !byte $29,%10001011; + !byte $A1,%00010000 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $93,%00001100 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $47,%01001000 + !byte $79,%10100111 + !byte $7D,%01101000 + !byte $7D,%10001001; + !byte $33,%10101011 + !byte $25,%01101010 + !byte $25,%10001011; + !byte $93,%11101001 + !byte $17,%10101111 + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $45,%00101000 + !byte $61,%11000111 + !byte $63,%00001000 + !byte $93,%00101100 + !byte $7D,%01001000 + !byte $A5,%10101111 + !byte $3D,%11100111 + !byte $95,%01001010 + !byte $95,%01101010 + !byte $95,%10001011; + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $5D,%01000110 + !byte $7B,%11000111 + !byte $95,%00101010 + !byte $15,%11110011 + !byte $AD,%11110011 + !byte $3F,%11100111 + !byte $43,%00001000 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $A7,%00101110 + !byte $A3,%11101111 + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $7D,%00101000 + !byte $A1,%00110000 + !byte $95,%00001010 + !byte $95,%10101011 + !byte $17,%11010011 + !byte $A7,%01001110 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $63,%11100111 + !byte $7D,%00001000 + !byte $A7,%00001110 + !byte $95,%11001011 + !byte $65,%00101000 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $15,%10101111 + !byte $41,%11100111 + !byte $61,%10100111 + !byte $A5,%11001111 + !byte $AF,%10110011 + !byte $19,%10110011 + !byte $21,%01001110 + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $5B,%00100110 + !byte $AF,%11010011 + !byte $13,%11101111 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $A7,%01101110 + !byte $A7,%10001111; + !byte $23,%01101010 + !byte $23,%10001011; + !byte $3B,%11100111 + !byte $49,%01001000 + !byte $47,%00101000 + !byte $13,%11110011 + !byte $1F,%01001110 + !byte $27,%01001010 + !byte $7B,%10100111 + !byte $7F,%11001001 + !byte $95,%11101011 + !byte $A3,%00010000 + !byte $29,%01001010 + !byte $7D,%11100111 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $25,%01001010 + !byte $2B,%01001010 + !byte $45,%00001000 + !byte $13,%11001111 + !byte $5F,%01000110 + !byte $7F,%10101001 + !byte $15,%11010011 + !byte $1D,%01001110 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $43,%11100111 + !byte $59,%00100110 + !byte $5D,%00100110 + !byte $63,%11000111 + !byte $65,%00001000 + !byte $A1,%01010000 + !byte $95,%00001100 + !byte $1B,%01001110 + !byte $61,%01100110 + !byte $61,%10000111; + !byte $7F,%01101000 + !byte $7F,%10001001; + !byte $95,%11101001 + !byte $A7,%10101111 + !byte $A5,%11101111 + !byte $2D,%01001010 + !byte $AF,%11110011 + !byte $7D,%11000111 + !byte $17,%10110011 + !byte $3F,%11000111 + !byte $7F,%01001000 + !byte $97,%01001010 + !byte $95,%00101100 + !byte $3D,%11000111 + !byte $97,%00101010 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $97,%01101010 + !byte $97,%10001011; + !byte $A3,%00110000 + !byte $4B,%01001000 + !byte $7F,%00101000 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $49,%00101000 + !byte $2F,%01001010 + !byte $41,%11000111 + !byte $11,%11110011 + !byte $19,%01001110 + !byte $97,%10101011 + !byte $95,%01001100 + !byte $47,%00001000 + !byte $13,%11010011 + !byte $97,%00001010 + !byte $A9,%01001110 + !byte $A7,%11001111 + !byte $13,%10101111 + !byte $63,%10100111 + !byte $65,%11100111 + !byte $A9,%00101110 + !byte $45,%11100111 + !byte $5F,%00100110 + !byte $7F,%00001000 + !byte $27,%00101010 + !byte $29,%00101010 + !byte $A5,%00010000 + !byte $21,%00101110 + !byte $61,%01000110 + !byte $97,%11001011 + !byte $31,%01001010 + !byte $7D,%10100111 + !byte $17,%01001110 + !byte $15,%10110011 + !byte $7F,%11100111 + !byte $A9,%01101110 + !byte $A9,%10001111; + !byte $23,%01001010 + !byte $2B,%00101010 + !byte $43,%11000111 + !byte $1F,%00101110 + !byte $25,%00101010 + !byte $97,%11101011 + !byte $A3,%01010000 + !byte $1D,%00101110 + !byte $2D,%00101010 + !byte $33,%01001010 + !byte $81,%11001001 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $63,%01100110 + !byte $63,%10000111; + !byte $65,%11000111 + !byte $A7,%11101111 + !byte $15,%01001110 + !byte $1B,%00101110 + !byte $5D,%00000110 + !byte $67,%00001000 + !byte $A9,%10101111 + !byte $4B,%00101000 + !byte $7F,%11000111 + !byte $81,%10101001 + !byte $97,%00001100 + !byte $0F,%11110011 + !byte $19,%01010010 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $3F,%10100111 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $11,%11010011 + !byte $47,%11100111 + !byte $49,%00001000 + !byte $81,%01101000 + !byte $81,%10001001; + !byte $41,%10100111 + !byte $99,%01001010 + !byte $97,%00101100 + !byte $A5,%00110000 + !byte $B1,%11110011 + !byte $13,%10110011 + !byte $19,%00101110 + !byte $2F,%00101010 + !byte $45,%11000111 + !byte $61,%00100110 + !byte $81,%01001000 + !byte $5F,%00000110 + !byte $81,%00101000 + !byte $99,%00101010 + !byte $99,%01101010 + !byte $99,%10001011; + !byte $97,%11101001 + !byte $A9,%11001111 + !byte $17,%00101110 + !byte $7F,%10100111 + !byte $99,%10101011 + !byte $29,%00001010 + !byte $5B,%00000110 + !byte $63,%01000110 + !byte $65,%10100111 + !byte $67,%11100111 + !byte $A3,%01110000 + !byte $A3,%10010001; + !byte $A7,%00010000 + !byte $21,%00001110 + !byte $27,%00001010 + !byte $31,%00101010 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $99,%00001010 + !byte $43,%10100111 + !byte $81,%00001000 + !byte $97,%01001100 + !byte $15,%01110010 + !byte $15,%10010011; + !byte $B1,%11010011 + !byte $99,%11001011 + !byte $AB,%01001110 + !byte $2B,%00001010 + !byte $1F,%00001110 + !byte $3D,%10100111 + !byte $4D,%00101000 + !byte $0F,%11010011 + !byte $23,%00101010 + !byte $25,%00001010 + !byte $81,%11100111 + !byte $AB,%01101110 + !byte $AB,%10001111; + !byte $A5,%01010000 + !byte $13,%01001110 + !byte $11,%10110011 + !byte $17,%01010010 + !byte $15,%00101110 + !byte $2D,%00001010 + !byte $47,%11000111 + !byte $49,%11100111 + !byte $4B,%00001000 + !byte $0D,%11110011 + !byte $1D,%00001110 + !byte $33,%00101010 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $99,%11101011 + !byte $61,%00000110 + !byte $1B,%00001110 + !byte $81,%11000111 + !byte $AB,%10101111 + !byte $A9,%11101111 + !byte $19,%00110010 + !byte $69,%00001000 + !byte $63,%00100110 + !byte $67,%11000111 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $45,%10100111 + !byte $83,%11001001 + !byte $A7,%00110000 + !byte $19,%00001110 + !byte $AB,%00101110 + !byte $99,%00001100 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $83,%10101001 + !byte $2F,%00001010 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $15,%01010010 + !byte $9B,%01001010 + !byte $83,%01101000 + !byte $83,%10001001; + !byte $17,%00001110 + !byte $67,%10100111 + !byte $AB,%11001111 + !byte $0F,%10110011 + !byte $27,%11101001 + !byte $29,%11101001 + !byte $83,%01001000 + !byte $9B,%00101010 + !byte $9B,%01101010 + !byte $9B,%10001011; + !byte $A5,%01110000 + !byte $A5,%10010001; + !byte $43,%01100110 + !byte $43,%10000111; + !byte $99,%00101100 + !byte $65,%01000110 + !byte $81,%10100111 + !byte $13,%00101110 + !byte $21,%11101101 + !byte $2B,%11101001 + !byte $31,%00001010 + !byte $4B,%11100111 + !byte $4D,%00001000 + !byte $5F,%11100101 + !byte $83,%00101000 + !byte $A9,%00010000 + !byte $0D,%11010011 + !byte $9B,%10101011 + !byte $69,%11100111 + !byte $49,%11000111 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $17,%00110010 + !byte $83,%00001000 + !byte $A7,%01010000 + !byte $1F,%11101101 + !byte $63,%00000110 + !byte $47,%10100111 + !byte $1D,%11101101 + !byte $9B,%11001011 + !byte $99,%01001100 + !byte $15,%00001110 + !byte $25,%11101001 + !byte $2D,%11101001 + !byte $83,%11100111 + !byte $61,%11100101 + !byte $9B,%00001010 + !byte $33,%00001010 + !byte $45,%01100110 + !byte $45,%10000111; + !byte $13,%01010010 + !byte $1B,%11101101 + !byte $65,%00100110 + !byte $67,%01100110 + !byte $67,%10000111; + !byte $AB,%11101111 + !byte $69,%11000111 + !byte $9B,%11101011 + !byte $AD,%01101110 + !byte $AD,%10001111; + !byte $A9,%00110000 + !byte $19,%11101101 + !byte $23,%00001010 + !byte $2F,%11101001 + !byte $83,%11000111 + !byte $AD,%10101111 + !byte $A5,%10110001 + !byte $35,%00001010 + !byte $99,%11101001 + !byte $0B,%11110011 + !byte $81,%01100110 + !byte $81,%10000111; + !byte $41,%01000110 + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $15,%00110010 + !byte $0D,%10110011 + !byte $AD,%01001110 + !byte $17,%11101101 + !byte $29,%11001001 + !byte $85,%11001001 + !byte $9B,%00001100 + !byte $AD,%11001111 + !byte $A7,%01110000 + !byte $A7,%10010001; + !byte $27,%11001001 + !byte $43,%01000110 + !byte $63,%11100101 + !byte $13,%00001110 + !byte $49,%10100111 + !byte $AB,%00010000 + !byte $67,%01000110 + !byte $4B,%11000111 + !byte $4D,%11100111 + !byte $65,%00000110 + !byte $69,%10100111 + !byte $85,%10101001 + !byte $0B,%11010011 + !byte $2B,%11001001 + !byte $83,%10100111 + !byte $9D,%01001010 + !byte $11,%01010010 + !byte $31,%11101001 + !byte $47,%01100110 + !byte $47,%10000111; + !byte $21,%11001101 + !byte $6B,%11100111 + !byte $9D,%00101010 + !byte $9D,%01101010 + !byte $9D,%10001011; + !byte $17,%00010010 + !byte $15,%11101101 + !byte $85,%01101000 + !byte $85,%10001001; + !byte $85,%01001000 + !byte $9B,%00101100 + !byte $A9,%01010000 + !byte $2D,%11001001 + !byte $85,%00101000 + !byte $9D,%10101011 + !byte $1F,%11001101 + !byte $1D,%11001101 + !byte $25,%11001001 + !byte $45,%01000110 + !byte $67,%00100110 + !byte $85,%00001000 + !byte $33,%11101001 + !byte $13,%00110010 + !byte $AD,%11101111 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $1B,%11001101 + !byte $3F,%01000110 + !byte $69,%01100110 + !byte $69,%10000111; + !byte $85,%11100111 + !byte $9D,%11001011 + !byte $9B,%01001100 + !byte $19,%11001101 + !byte $AB,%00110000 + !byte $A7,%10110001 + !byte $0B,%10110011 + !byte $2F,%11001001 + !byte $83,%01100110 + !byte $83,%10000111; + !byte $0F,%01010010 + !byte $11,%00101110 + !byte $13,%11101101 + !byte $17,%11001101 + !byte $49,%01100110 + !byte $49,%10000111; + !byte $65,%11100101 + !byte $6B,%11000111 + !byte $9D,%11101011 + !byte $15,%00010010 + !byte $4B,%10100111 + !byte $4D,%11000111 + !byte $4F,%11100111 + !byte $85,%11000111 + !byte $11,%00110010 + !byte $29,%10101001 + !byte $61,%11000101 + !byte $9B,%01101100 + !byte $9B,%10001101; + !byte $A9,%01110000 + !byte $A9,%10010001; + !byte $35,%11101001 + !byte $47,%01000110 + !byte $9D,%00001010 + !byte $AD,%00010000 + !byte $27,%10101001 + !byte $31,%11001001 + !byte $43,%00100110 + !byte $63,%11000101 + !byte $67,%00000110 + !byte $69,%01000110 + !byte $AF,%10101111 + !byte $17,%11110001 + !byte $2B,%10101001 + !byte $15,%11001101 + !byte $85,%10100111 + !byte $AF,%11001111 + !byte $41,%00100110 + !byte $6B,%10100111 + !byte $9D,%00001100 + !byte $AF,%01101110 + !byte $AF,%10001111; + !byte $11,%00001110 + !byte $21,%10101101 + !byte $87,%11001001 + !byte $9F,%01001010 + !byte $AB,%01010000 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $2D,%10101001 + !byte $45,%00100110 + !byte $9F,%01101010 + !byte $9F,%10001011; + !byte $0D,%01010010 + !byte $13,%00010010 + !byte $1F,%10101101 + !byte $87,%10101001 + !byte $A7,%11010001 + !byte $87,%01001000 + !byte $87,%01101000 + !byte $87,%10001001; + !byte $9D,%00101100 + !byte $1D,%10101101 + !byte $87,%00101000 + !byte $9F,%00101010 + !byte $AF,%11101111 + !byte $0F,%00110010 + !byte $1B,%10101101 + !byte $25,%10101001 + !byte $49,%01000110 + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $69,%00100110 + !byte $9F,%10101011 + !byte $33,%11001001 + !byte $AD,%00110000 + !byte $13,%11001101 + !byte $19,%10101101 + !byte $2F,%10101001 + !byte $65,%11000101 + !byte $87,%00001000 + !byte $4D,%10100111 + !byte $67,%11100101 + !byte $9F,%11001011 + !byte $4F,%11000111 + !byte $85,%01100110 + !byte $85,%10000111; + !byte $87,%11100111 + !byte $A9,%10110001 + !byte $15,%11110001 + !byte $47,%00100110 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $9D,%01001100 + !byte $09,%11010011 + !byte $11,%11101101 + !byte $AB,%01110000 + !byte $AB,%10010001; + !byte $11,%00010010 + !byte $17,%10101101 + !byte $35,%11001001 + !byte $6D,%11000111 + !byte $87,%11000111 + !byte $29,%01101000 + !byte $29,%10001001; + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $9F,%11101011 + !byte $09,%10110011 + !byte $69,%00000110 + !byte $0B,%01010010 + !byte $31,%10101001 + !byte $AF,%00010000 + !byte $15,%10101101 + !byte $9D,%01101100 + !byte $9D,%10001101; + !byte $27,%01101000 + !byte $27,%10001001; + !byte $0D,%00110010 + !byte $6B,%01000110 + !byte $45,%00000110 + !byte $87,%10100111 + !byte $9F,%00001100 + !byte $AD,%01010000 + !byte $43,%00000110 + !byte $83,%01000110 + !byte $13,%11110001 + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $67,%11000101 + !byte $21,%01101100 + !byte $21,%10001101; + !byte $49,%00100110 + !byte $4B,%01000110 + !byte $09,%01110010 + !byte $09,%10010011; + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $B1,%11001111 + !byte $0F,%00010010 + !byte $6D,%10100111 + !byte $9F,%00001010 + !byte $A9,%11010001 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $33,%10101001 + !byte $A1,%01101010 + !byte $A1,%10001011; + !byte $B1,%10101111 + !byte $4F,%10100111 + !byte $51,%11000111 + !byte $A1,%01001010 + !byte $AF,%00110000 + !byte $13,%10101101 + !byte $89,%10101001 + !byte $89,%11001001 + !byte $A1,%10101011 + !byte $9F,%00101100 + !byte $B1,%11101111 + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $47,%00000110 + !byte $15,%11010001 + !byte $11,%11001101 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $69,%11100101 + !byte $6B,%00100110 + !byte $0B,%00110010 + !byte $89,%00101000 + !byte $AD,%01110000 + !byte $AD,%10010001; + !byte $AB,%10110001 + !byte $89,%01001000 + !byte $89,%01101000 + !byte $89,%10001001; + !byte $65,%10100101 + !byte $87,%01100110 + !byte $87,%10000111; + !byte $63,%10100101 + !byte $11,%11110001 + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $89,%00001000 + !byte $17,%01101100 + !byte $17,%10001101; + !byte $25,%01101000 + !byte $25,%10001001; + !byte $A1,%11001011 + !byte $85,%01000110 + !byte $A1,%00101010 + !byte $0D,%00010010 + !byte $29,%01001000 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $89,%11100111 + !byte $09,%01010010 + !byte $2B,%01001000 + !byte $35,%10101001 + !byte $6B,%00000110 + !byte $9F,%01001100 + !byte $B1,%00010000 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $4B,%00100110 + !byte $6F,%11000111 + !byte $89,%11000111 + !byte $A1,%11101011 + !byte $A9,%11110001 + !byte $AF,%01010000 + !byte $27,%01001000 + !byte $2D,%01001000 + !byte $49,%00000110 + !byte $4D,%01000110 + !byte $69,%11000101 + !byte $6D,%01000110 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $67,%10100101 + !byte $13,%11010001 + !byte $0F,%11110001 + !byte $51,%10100111 + !byte $AB,%11010001 + !byte $89,%10100111 + !byte $9F,%01101100 + !byte $9F,%10001101; + !byte $11,%10101101 + !byte $21,%01001100 + !byte $45,%11100101 + !byte $A1,%00001100 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $33,%01101000 + !byte $33,%10001001; + !byte $B1,%00110000 + !byte $1D,%01001100 + !byte $1F,%01001100 + !byte $6B,%11100101 + !byte $6D,%00100110 + !byte $AD,%10110001 + !byte $0B,%00010010 + !byte $1B,%01001100 + !byte $47,%11100101 + !byte $6F,%10100111 + !byte $09,%00110010 + !byte $2F,%01001000 + !byte $19,%01001100 + !byte $87,%01000110 + !byte $A3,%01101010 + !byte $A3,%10001011; + !byte $AF,%01110000 + !byte $AF,%10010001; + !byte $15,%10110001 + !byte $9F,%10101101 + !byte $A3,%10101011 + !byte $4D,%00100110 + !byte $8B,%11001001 + !byte $17,%01001100 + !byte $43,%11100101 + !byte $89,%01100110 + !byte $89,%10000111; + !byte $A3,%01001010 + !byte $A1,%00101100 + !byte $B3,%11101111 + !byte $0D,%11110001 + !byte $11,%11010001 + !byte $69,%10100101 + !byte $2B,%00101000 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $4B,%00000110 + !byte $8B,%10101001 + !byte $A3,%11001011 + !byte $B3,%11001111 + !byte $29,%00101000 + !byte $31,%01001000 + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $8B,%01001000 + !byte $8B,%01101000 + !byte $8B,%10001001; + !byte $15,%01001100 + !byte $8B,%00001000 + !byte $8B,%00101000 + !byte $49,%11100101 + !byte $4F,%01000110 + !byte $6B,%11000101 + !byte $8B,%11100111 + !byte $B3,%00010000 + !byte $B1,%01010000 + !byte $51,%01100110 + !byte $51,%10000111; + !byte $AB,%11110001 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $11,%01101100 + !byte $11,%10001101; + !byte $6D,%00000110 + !byte $A3,%11101011 + !byte $2D,%00101000 + !byte $53,%10100111 + !byte $A3,%00101010 + !byte $A1,%01001100 + !byte $AD,%11010001 + !byte $07,%01010010 + !byte $13,%10110001 + !byte $09,%00010010 + !byte $0F,%11010001 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $8B,%11000111 + !byte $27,%00101000 + !byte $0B,%11110001 + !byte $13,%01001100 + !byte $33,%01001000 + !byte $B3,%00110000 + !byte $AF,%10110001 + !byte $6F,%01000110 + !byte $1D,%00101100 + !byte $1F,%00101100 + !byte $21,%00101100 + !byte $25,%01001000 + !byte $2F,%00101000 + !byte $8B,%10100111 + !byte $A3,%00001100 + !byte $A1,%01101100 + !byte $A1,%10001101; + !byte $B1,%01110000 + !byte $B1,%10010001; + !byte $1B,%00101100 + !byte $6D,%11100101 + !byte $07,%00110010 + !byte $0D,%11010001 + !byte $11,%10110001 + !byte $19,%00101100 + !byte $45,%11000101 + !byte $47,%11000101 + !byte $4F,%00100110 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $6B,%10100101 + !byte $4B,%11100101 + !byte $4D,%00000110 + !byte $71,%10100111 + !byte $89,%01000110 + !byte $17,%00101100 + !byte $6F,%00100110 + !byte $AB,%00010010 + !byte $15,%00101100 + !byte $49,%11000101 + !byte $51,%01000110 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $A5,%10101011 + !byte $A3,%00101100 + !byte $A1,%10101101 + !byte $2B,%00001000 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $8B,%01100110 + !byte $8B,%10000111; + !byte $A5,%01101010 + !byte $A5,%10001011; + !byte $31,%00101000 + !byte $35,%01001000 + !byte $B3,%01010000 + !byte $29,%00001000 + !byte $A5,%01001010 + !byte $09,%11110001 + !byte $6D,%11000101 + !byte $AF,%11010001 + !byte $AD,%11110001 + !byte $A5,%11001011 + !byte $11,%01001100 + !byte $2D,%00001000 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $8D,%00001000 + !byte $8D,%10101001 + !byte $8D,%11001001 + !byte $0F,%10110001 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $8D,%01001000 + !byte $8D,%01101000 + !byte $8D,%10001001; + !byte $6F,%00000110 + !byte $8D,%00101000 + !byte $07,%00010010 + !byte $8D,%11100111 + !byte $A3,%01001100 + !byte $B1,%10110001 + !byte $0B,%11010001 + !byte $13,%00101100 + !byte $33,%00101000 + !byte $4D,%11100101 + !byte $A5,%11101011 + !byte $B5,%00010000 + !byte $B5,%11101111 + !byte $27,%00001000 + !byte $37,%01001000 + !byte $8D,%11000111 + !byte $2F,%00001000 + !byte $4B,%11000101 + !byte $4F,%00000110 + !byte $51,%00100110 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $71,%01000110 + !byte $B3,%01110000 + !byte $B3,%10010001; + !byte $B5,%00110000 + !byte $6D,%10100101 + !byte $6F,%11100101 + !byte $19,%00001100 + !byte $1D,%00001100 + !byte $1F,%00001100 + !byte $21,%00001100 + !byte $8D,%10100111 + !byte $1B,%00001100 + !byte $0D,%10110001 + !byte $11,%01110000 + !byte $11,%10010001; + !byte $A5,%00001100 + !byte $AD,%00010010 + !byte $A3,%01101100 + !byte $A3,%10001101; + !byte $07,%11110001 + !byte $53,%01000110 + !byte $17,%00001100 + !byte $31,%00001000 + !byte $35,%00101000 + !byte $8B,%01000110 + !byte $09,%11010001 + !byte $15,%00001100 + !byte $2B,%11100111 + !byte $47,%10100101 + !byte $71,%00100110 + !byte $73,%10100111 + !byte $B1,%11010001 + !byte $AF,%11110001 + !byte $49,%10100101 + !byte $11,%00101100 + !byte $8D,%01100110 + !byte $8D,%10000111; + !byte $A5,%00101010 + !byte $B5,%01010000 + !byte $A5,%00101100 + !byte $29,%11100111 + !byte $2D,%11100111 + !byte $4F,%11100101 + !byte $0B,%10110001 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $13,%01010000 + !byte $6F,%11000101 + !byte $A7,%01101010 + !byte $A7,%10001011; + !byte $B3,%10110001 + !byte $13,%00001100 + !byte $A7,%10101011 + !byte $4D,%11000101 + !byte $A3,%10101101 + !byte $33,%00001000 + !byte $51,%00000110 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $71,%00000110 + !byte $A7,%11001011 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $2F,%11100111 + !byte $37,%00101000 + !byte $8F,%11100111 + !byte $8F,%00001000 + !byte $8F,%00101000 + !byte $8F,%10101001 + !byte $8F,%11001001 + !byte $8F,%01101000 + !byte $8F,%10001001; + !byte $A7,%11101011 + !byte $4B,%10100101 + !byte $8F,%01001000 + !byte $53,%00100110 + !byte $6F,%10100101 + !byte $A7,%01001010 + !byte $B5,%01110000 + !byte $B5,%10010001; + !byte $AD,%00110010 + !byte $07,%11010001 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $8F,%11000111 + !byte $A5,%01001100 + !byte $A3,%11001101 + !byte $19,%11101011 + !byte $1D,%11101011 + !byte $1F,%11101011 + !byte $05,%00010010 + !byte $09,%10110001 + !byte $11,%01010000 + !byte $17,%11101011 + !byte $1B,%11101011 + !byte $55,%01000110 + !byte $71,%11100101 + !byte $B1,%11110001 + !byte $AF,%00010010 + !byte $6B,%01000100 + !byte $A7,%00001100 + !byte $21,%11101011 + !byte $8D,%01000110 + !byte $B3,%11010001 + !byte $31,%11100111 + !byte $73,%01000110 + !byte $8F,%10100111 + !byte $35,%00001000 + !byte $05,%00110010 + !byte $15,%11101011 + !byte $B7,%00110000 + !byte $4F,%11000101 + !byte $A5,%01101100 + !byte $A5,%10001101; + !byte $11,%00001100 + !byte $27,%11100111 + !byte $51,%11100101 + !byte $05,%11110001 + !byte $2B,%11000111 + !byte $2D,%11000111 + !byte $4D,%10100101 + !byte $71,%11000101 + !byte $B7,%00010000 + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $0F,%01010000 + !byte $73,%00100110 + !byte $B5,%10110001 + !byte $49,%01100100 + !byte $49,%10000101; + !byte $53,%00000110 + !byte $8F,%01100110 + !byte $8F,%10000111; + !byte $A7,%00101100 + !byte $B7,%01010000 + !byte $13,%11101011 + !byte $29,%11000111 + !byte $69,%01000100 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $13,%00110000 + !byte $33,%11100111 + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $6D,%01000100 + !byte $AF,%00110010 + !byte $A5,%10101101 + !byte $2F,%11000111 + !byte $37,%00001000 + !byte $07,%10110001 + !byte $A9,%11001011 + !byte $55,%00100110 + !byte $A9,%10101011 + !byte $73,%00000110 + !byte $A9,%01101010 + !byte $A9,%10001011; + !byte $09,%01110000 + !byte $09,%10010001; + !byte $0D,%01010000 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $91,%00001000 + !byte $91,%00101000 + !byte $A7,%01001100 + !byte $B1,%00010010 + !byte $05,%11010001 + !byte $B7,%01110000 + !byte $B7,%10010001; + !byte $B3,%11110001 + !byte $A9,%11101011 + !byte $11,%00110000 + !byte $19,%11001011 + !byte $1B,%11001011 + !byte $91,%11100111 + !byte $91,%01001000 + !byte $17,%11001011 + !byte $1D,%11001011 + !byte $31,%11000111 + !byte $4F,%10100101 + !byte $71,%10100101 + !byte $91,%01101000 + !byte $91,%10001001; + !byte $B5,%11010001 + !byte $51,%11000101 + !byte $1F,%11001011 + !byte $91,%11001001 + !byte $21,%11001011 + !byte $35,%11100111 + !byte $39,%00001000 + !byte $91,%11000111 + !byte $91,%10101001 + !byte $A5,%11001101 + !byte $11,%11101011 + !byte $15,%11001011 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $73,%11100101 + !byte $53,%11100101 + !byte $6F,%01000100 + !byte $75,%01000110 + !byte $47,%01100100 + !byte $47,%10000101; + !byte $8F,%01000110 + !byte $91,%10100111 + !byte $A9,%00001100 + !byte $2B,%10100111 + !byte $A7,%01101100 + !byte $A7,%10001101; + !byte $0B,%01010000 + !byte $0F,%00110000 + !byte $2D,%10100111 + !byte $B7,%10110001 + !byte $71,%01100100 + !byte $71,%10000101; + !byte $33,%11000111 + !byte $55,%00000110 + !byte $73,%11000101 + !byte $07,%01110000 + !byte $07,%10010001; + !byte $A9,%01001010 + !byte $AF,%01010010 + !byte $05,%10110001 + !byte $13,%11001011 + !byte $13,%00010000 + !byte $2F,%10100111 + !byte $37,%11100111 + !byte $B3,%00010010 + !byte $B1,%00110010 + !byte $57,%00100110 + !byte $75,%00100110 + !byte $91,%01100110 + !byte $91,%10000111; + !byte $A9,%00101100 + !byte $B5,%11110001 + !byte $A7,%10101101 + !byte $B9,%01010000 + !byte $29,%10100111 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $51,%10100101 + !byte $09,%01010000 + !byte $0D,%00110000 + !byte $4B,%01000100 + !byte $73,%10100101 + !byte $75,%00000110 + !byte $53,%11000101 + !byte $35,%11000111 + !byte $AB,%11001011 + !byte $19,%10101011 + !byte $1B,%10101011 + !byte $AB,%10101011 + !byte $B9,%00110000 + !byte $17,%10101011 + !byte $B7,%11010001 + !byte $11,%00010000 + !byte $1D,%10101011 + !byte $31,%10100111 + !byte $AB,%11101011 + !byte $A9,%01001100 + !byte $B9,%01110000 + !byte $B9,%10010001; + !byte $55,%11100101 + !byte $15,%10101011 + !byte $1F,%10101011 + !byte $39,%11100111 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $93,%11100111 + !byte $93,%00001000 + !byte $93,%00101000 + !byte $93,%01001000 + !byte $49,%01000100 + !byte $4D,%01000100 + !byte $71,%01000100 + !byte $11,%11001011 + !byte $05,%01110000 + !byte $05,%10010001; + !byte $0B,%00110000 + !byte $21,%10101011 + !byte $93,%01101000 + !byte $93,%10001001; + !byte $AB,%01101010 + !byte $AB,%10001011; + !byte $A7,%11001101 + !byte $75,%11100101 + !byte $93,%11000111 + !byte $07,%01010000 + !byte $0F,%00010000 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $51,%01100100 + !byte $51,%10000101; + !byte $57,%00000110 + !byte $91,%01000110 + !byte $93,%10101001 + !byte $93,%11001001 + !byte $AB,%00001100 + !byte $B3,%00110010 + !byte $B1,%01010010 + !byte $AF,%01110010 + !byte $AF,%10010011; + !byte $13,%10101011 + !byte $33,%10100111 + !byte $77,%01000110 + !byte $93,%10100111 + !byte $B9,%10110001 + !byte $B5,%00010010 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $6F,%00100100 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $75,%11000101 + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $37,%11000111 + !byte $6D,%00100100 + !byte $A9,%01101100 + !byte $A9,%10001101; + !byte $B7,%11110001 + !byte $A7,%11101101 + !byte $4F,%01000100 + !byte $AB,%00101100 + !byte $53,%10100101 + !byte $09,%00110000 + !byte $77,%00100110 + !byte $0D,%00010000 + !byte $93,%01100110 + !byte $93,%10000111; + !byte $55,%11000101 + !byte $03,%11010001 + !byte $03,%10110001 + !byte $31,%01100110 + !byte $31,%10000111; + !byte $35,%10100111 + !byte $A9,%10101101 + !byte $B9,%11010001 + !byte $17,%01101010 + !byte $17,%10001011; + !byte $19,%01101010 + !byte $19,%10001011; + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $71,%00100100 + !byte $77,%00000110 + !byte $11,%11101111 + !byte $AB,%01001100 + !byte $05,%01010000 + !byte $73,%01000100 + !byte $75,%10100101 + !byte $11,%10101011 + !byte $15,%01101010 + !byte $15,%10001011; + !byte $57,%11100101 + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $39,%11000111 + !byte $51,%01000100 + !byte $AD,%11001011 + !byte $0B,%00010000 + !byte $B1,%01110010 + !byte $B1,%10010011; + !byte $B5,%00110010 + !byte $21,%01101010 + !byte $21,%10001011; + !byte $33,%01100110 + !byte $33,%10000111; + !byte $4D,%00100100 + !byte $95,%00001000 + !byte $AD,%10101011 + !byte $AD,%11101011 + !byte $B7,%00010010 + !byte $53,%01100100 + !byte $53,%10000101; + !byte $59,%00000110 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $95,%11100111 + !byte $95,%00101000 + !byte $B3,%01010010 + !byte $07,%00110000 + !byte $29,%01100110 + !byte $29,%10000111; + !byte $4B,%00100100 + !byte $0F,%11101111 + !byte $2D,%01000110 + !byte $77,%11100101 + !byte $95,%01001000 + !byte $BB,%01110000 + !byte $BB,%10010001; + !byte $03,%01110000 + !byte $03,%10010001; + !byte $37,%10100111 + !byte $93,%01000110 + !byte $95,%11000111 + !byte $13,%01101010 + !byte $13,%10001011; + !byte $55,%10100101 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $A9,%11001101 + !byte $2F,%01000110 + !byte $95,%01101000 + !byte $95,%10001001; + !byte $95,%10101001 + !byte $AD,%00001100 + !byte $BB,%10110001 + !byte $B9,%11110001 + !byte $AB,%01101100 + !byte $AB,%10001101; + !byte $4F,%00100100 + !byte $95,%10100111 + !byte $09,%00010000 + !byte $57,%11000101 + !byte $77,%11000101 + !byte $3B,%11000111 + !byte $79,%01000110 + !byte $2B,%01000110 + !byte $95,%11001001 + !byte $0D,%11101111 + !byte $05,%00110000 + !byte $31,%01000110 + !byte $35,%01100110 + !byte $35,%10000111; + !byte $AD,%00101100 + !byte $73,%00100100 + !byte $11,%11001111 + !byte $75,%01000100 + !byte $A9,%11101101 + !byte $BB,%11010001 + !byte $B1,%10110011 + !byte $19,%01001010 + !byte $53,%01000100 + !byte $59,%11100101 + !byte $95,%01100110 + !byte $95,%10000111; + !byte $17,%01001010 + !byte $79,%00100110 + !byte $BB,%01010000 + !byte $B5,%01010010 + !byte $B7,%00110010 + !byte $11,%01101010 + !byte $11,%10001011; + !byte $15,%01001010 + !byte $1B,%01001010 + !byte $1D,%01001010 + !byte $39,%10100111 + !byte $B9,%00010010 + !byte $B3,%01110010 + !byte $B3,%10010011; + !byte $03,%01010000 + !byte $07,%00010000 + !byte $51,%00100100 + !byte $AB,%10101101 + !byte $AD,%01101010 + !byte $AD,%10001011; + !byte $0B,%11101111 + !byte $77,%10100101 + !byte $AD,%01001100 + !byte $1F,%01001010 + !byte $33,%01000110 + !byte $55,%01100100 + !byte $55,%10000101; + !byte $79,%00000110 + !byte $21,%01001010 + !byte $13,%01001010 + !byte $57,%10100101 + !byte $37,%01100110 + !byte $37,%10000111; + !byte $AF,%11101011 + !byte $A9,%00001110 + !byte $BB,%11110001 + !byte $0F,%11001111 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $AF,%11001011 + !byte $97,%00001000 + !byte $AB,%11001101 + !byte $97,%11100111 + !byte $2D,%00100110 + !byte $2F,%00100110 + !byte $3B,%10100111 + !byte $79,%11100101 + !byte $97,%11000111 + !byte $AD,%01101100 + !byte $AD,%10001101; + !byte $97,%00101000 + !byte $97,%01001000 + !byte $05,%00010000 + !byte $09,%11101111 + !byte $AF,%00001100 + !byte $03,%00110000 + !byte $4F,%00000100 + !byte $97,%10100111 + !byte $AF,%10101011 + !byte $53,%00100100 + !byte $59,%11000101 + !byte $75,%00100100 + !byte $97,%01101000 + !byte $97,%10001001; + !byte $0D,%11001111 + !byte $31,%00100110 + !byte $35,%01000110 + !byte $4D,%00000100 + !byte $95,%01000110 + !byte $B7,%01010010 + !byte $B5,%01110010 + !byte $B5,%10010011; + !byte $7B,%01000110 + !byte $97,%10101001 + !byte $55,%01000100 + !byte $B9,%00110010 + !byte $B3,%10110011 + !byte $79,%11000101 + !byte $07,%11101111 + !byte $17,%00101010 + !byte $97,%11001001 + !byte $19,%00101010 + !byte $1B,%00101010 + !byte $AF,%00101100 + !byte $2B,%00100110 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $51,%00000100 + !byte $5B,%11100101 + !byte $77,%01000100 + !byte $AB,%11101101 + !byte $0B,%11001111 + !byte $11,%10101111 + !byte $11,%01001010 + !byte $1D,%00101010 + !byte $57,%01100100 + !byte $57,%10000101; + !byte $AD,%10101101 + !byte $BD,%10110001 + !byte $BB,%00010010 + !byte $15,%00101010 + !byte $33,%00100110 + !byte $97,%01100110 + !byte $97,%10000111; + !byte $79,%10100101 + !byte $73,%00000100 + !byte $7B,%00100110 + !byte $BD,%11010001 + !byte $AF,%01001100 + !byte $1F,%00101010 + !byte $13,%00101010 + !byte $03,%00010000 + !byte $37,%01000110 + !byte $59,%10100101 + !byte $71,%00000100 + !byte $21,%00101010 + !byte $B7,%01110010 + !byte $B7,%10010011; + !byte $05,%11101111 + !byte $09,%11001111 + !byte $0F,%10101111 + !byte $55,%00100100 + !byte $7B,%00000110 + !byte $AB,%00001110 + !byte $B9,%01010010 + !byte $AD,%11001101 + !byte $B5,%10110011 + !byte $2D,%00000110 + !byte $2F,%00000110 + !byte $35,%00100110 + !byte $77,%00100100 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $53,%00000100 + !byte $BD,%11110001 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $57,%01000100 + !byte $B3,%11010011 + !byte $31,%00000110 + !byte $99,%11000111 + !byte $99,%11100111 + !byte $B1,%11101011 + !byte $75,%00000100 + !byte $7B,%11100101 + !byte $99,%00001000 + !byte $99,%00101000 + !byte $BB,%00110010 + !byte $0D,%10101111 + !byte $5B,%11000101 + !byte $AF,%01101100 + !byte $AF,%10001101; + !byte $59,%01100100 + !byte $59,%10000101; + !byte $99,%10100111 + !byte $39,%01000110 + !byte $99,%01001000 + !byte $B1,%11001011 + !byte $B1,%00001100 + !byte $07,%11001111 + !byte $17,%00001010 + !byte $19,%00001010 + !byte $79,%01000100 + !byte $97,%01000110 + !byte $15,%00001010 + !byte $1B,%00001010 + !byte $7B,%11000101 + !byte $99,%01101000 + !byte $99,%10001001; + !byte $B1,%00101100 + !byte $BD,%00010010 + !byte $33,%00000110 + !byte $0B,%10101111 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $1D,%00001010 + !byte $37,%00100110 + !byte $51,%11100011 + !byte $5D,%11100101 + !byte $7D,%01000110 + !byte $11,%00101010 + !byte $99,%10101001 + !byte $AD,%11101101 + !byte $4F,%11100011 + !byte $03,%11101111 + !byte $AF,%10101101 + !byte $01,%01010000 + !byte $01,%00110000 + !byte $1F,%00001010 + !byte $99,%11001001 + !byte $B9,%01110010 + !byte $B9,%10010011; + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $55,%00000100 + !byte $B7,%10110011 + !byte $05,%11001111 + !byte $09,%10101111 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $13,%00001010 + !byte $7D,%00100110 + !byte $99,%01100110 + !byte $99,%10000111; + !byte $3B,%01000110 + !byte $5B,%10100101 + !byte $B1,%01001100 + !byte $53,%11100011 + !byte $57,%00100100 + !byte $77,%00000100 + !byte $7B,%10100101 + !byte $BB,%01010010 + !byte $B5,%11010011 + !byte $AF,%11001101 + !byte $B3,%11110011 + !byte $21,%00001010 + !byte $79,%00100100 + !byte $35,%00000110 + !byte $BD,%00110010 + !byte $59,%01000100 + !byte $01,%00010000 + !byte $2F,%11100101 + !byte $31,%11100101 + !byte $7D,%00000110 + !byte $AD,%00001110 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $39,%00100110 + !byte $5D,%11000101 + !byte $07,%10101111 + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $B1,%01101100 + !byte $B1,%10001101; + !byte $17,%11101001 + !byte $19,%11101001 + !byte $7D,%11100101 + !byte $9B,%11000111 + !byte $9B,%11100111 + !byte $9B,%00001000 + !byte $BF,%11110001 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $9B,%00101000 + !byte $2D,%11100101 + !byte $15,%11101001 + !byte $B3,%11101011 + !byte $BF,%11010001 + !byte $BB,%01110010 + !byte $BB,%10010011; + !byte $11,%01001110 + !byte $1B,%11101001 + !byte $33,%11100101 + !byte $B3,%00001100 + !byte $B9,%10110011 + !byte $03,%11001111 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $37,%00000110 + !byte $57,%00000100 + !byte $7B,%01000100 + !byte $9B,%01001000 + !byte $B1,%10101011 + !byte $9B,%10100111 + !byte $01,%11101111 + !byte $3D,%01000110 + !byte $79,%00000100 + !byte $B3,%00101100 + !byte $AF,%11101101 + !byte $BF,%00010010 + !byte $BD,%01010010 + !byte $1D,%11101001 + !byte $55,%11100011 + !byte $7D,%11000101 + !byte $AD,%00101110 + !byte $05,%10101111 + !byte $11,%00001010 + !byte $9B,%01101000 + !byte $9B,%10001001; + !byte $B1,%10101101 + !byte $B7,%11010011 + !byte $1F,%11101001 + !byte $59,%00100100 + !byte $B5,%11110011 + !byte $13,%11101001 + !byte $99,%01000110 + !byte $5D,%10100101 + !byte $7F,%01000110 + !byte $9B,%10101001 + !byte $3B,%00100110 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $0F,%01001110 + !byte $35,%11100101 + !byte $7D,%10100101 + !byte $B3,%01001100 + !byte $7B,%00100100 + !byte $9B,%01100110 + !byte $9B,%10000111; + !byte $21,%11101001 + !byte $53,%11000011 + !byte $B3,%11001011 + !byte $BF,%00110010 + !byte $5B,%01000100 + !byte $9B,%11001001 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $51,%11000011 + !byte $5F,%11000101 + !byte $7F,%00100110 + !byte $23,%11101001 + !byte $39,%00000110 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $9B,%11101001 + !byte $AF,%00001110 + !byte $31,%11000101 + !byte $B1,%11001101 + !byte $0D,%01001110 + !byte $2F,%11000101 + !byte $7F,%00000110 + !byte $B3,%01101100 + !byte $B3,%10001101; + !byte $03,%10101111 + !byte $57,%11100011 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $BB,%10110011 + !byte $BD,%01110010 + !byte $BD,%10010011; + !byte $19,%11001001 + !byte $1B,%11001001 + !byte $33,%11000101 + !byte $37,%11100101 + !byte $B9,%11010011 + !byte $0B,%01001110 + !byte $17,%11001001 + !byte $B7,%11110011 + !byte $01,%11001111 + !byte $15,%11001001 + !byte $55,%11000011 + !byte $59,%00000100 + !byte $3D,%00100110 + !byte $7F,%11100101 + !byte $9D,%11100111 + !byte $9D,%00001000 + !byte $9D,%00101000 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $7D,%01000100 + !byte $9D,%11000111 + !byte $BF,%01010010 + !byte $11,%11101001 + !byte $35,%11000101 + !byte $5B,%00100100 + !byte $9D,%01001000 + !byte $1D,%11001001 + !byte $77,%11100011 + !byte $7B,%00000100 + !byte $B3,%10101101 + !byte $AF,%00101110 + !byte $B1,%11101101 + !byte $09,%01001110 + !byte $5F,%10100101 + !byte $7F,%11000101 + !byte $9D,%10100111 + !byte $9D,%01101000 + !byte $9D,%10001001; + !byte $B5,%00101100 + !byte $1F,%11001001 + !byte $3B,%00000110 + !byte $B5,%00001100 + !byte $13,%11001001 + !byte $0F,%00101110 + !byte $39,%11100101 + !byte $21,%11001001 + !byte $79,%11100011 + !byte $5D,%01000100 + !byte $7D,%00100100 + !byte $01,%10101111 + !byte $07,%01001110 + !byte $7F,%10100101 + !byte $9D,%10101001 + !byte $B5,%01001100 + !byte $B1,%00001110 + !byte $BB,%11010011 + !byte $81,%01000110 + !byte $B5,%11101011 + !byte $B9,%11110011 + !byte $57,%11000011 + !byte $59,%11100011 + !byte $BD,%10110011 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $0D,%00101110 + !byte $23,%11001001 + !byte $5B,%00000100 + !byte $9B,%01000110 + !byte $9D,%11001001 + !byte $9D,%01100110 + !byte $9D,%10000111; + !byte $B3,%11001101 + !byte $BF,%01110010 + !byte $BF,%10010011; + !byte $3F,%00100110 + !byte $17,%10101001 + !byte $19,%10101001 + !byte $31,%10100101 + !byte $33,%10100101 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $81,%00100110 + !byte $9D,%11101001 + !byte $B5,%01101100 + !byte $B5,%10001101; + !byte $AF,%01001110 + !byte $37,%11000101 + !byte $15,%10101001 + !byte $1B,%10101001 + !byte $09,%11110011 + !byte $05,%01001110 + !byte $0B,%00101110 + !byte $3D,%00000110 + !byte $2D,%11000101 + !byte $81,%00000110 + !byte $1D,%10101001 + !byte $3B,%11100101 + !byte $55,%10100011 + !byte $7D,%00000100 + !byte $2F,%10100101 + !byte $5D,%00100100 + !byte $53,%10100011 + !byte $7B,%11100011 + !byte $7F,%01000100 + !byte $81,%11100101 + !byte $B5,%10101101 + !byte $BD,%11010011 + !byte $35,%10100101 + !byte $9F,%11100111 + !byte $9F,%00001000 + !byte $9F,%00101000 + !byte $B3,%11101101 + !byte $09,%00101110 + !byte $59,%11000011 + !byte $9F,%11000111 + !byte $13,%10101001 + !byte $57,%10100011 + !byte $5B,%11100011 + !byte $B1,%00101110 + !byte $1F,%10101001 + !byte $61,%10100101 + !byte $9F,%01001000 + !byte $BB,%11110011 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $39,%11000101 + !byte $BF,%10110011 + !byte $0F,%00001110 + !byte $5F,%01000100 + !byte $81,%11000101 + !byte $9F,%10100111 + !byte $7F,%00100100 + !byte $9F,%01101000 + !byte $9F,%10001001; + !byte $03,%01001110 + !byte $07,%00101110 + !byte $11,%11001001 + !byte $21,%10101001 + !byte $B7,%00101100 + !byte $07,%11110011 + !byte $37,%10100101 + !byte $3F,%00000110 + !byte $5D,%00000100 + !byte $0D,%00001110 + !byte $23,%10101001 + !byte $3D,%11100101 + !byte $81,%10100101 + !byte $9F,%10101001 + !byte $B7,%01001100 + !byte $B5,%11001101 + !byte $B1,%01001110 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $19,%01101000 + !byte $19,%10001001; + !byte $B7,%00001100 + !byte $B3,%00001110 + !byte $05,%00101110 + !byte $0B,%00001110 + !byte $31,%01100100 + !byte $31,%10000101; + !byte $33,%01100100 + !byte $33,%10000101; + !byte $7D,%11100011 + !byte $15,%01101000 + !byte $15,%10001001; + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $61,%01100100 + !byte $61,%10000101; + !byte $9F,%11001001 + !byte $3B,%11000101 + !byte $59,%10100011 + !byte $5B,%11000011 + !byte $81,%01100100 + !byte $81,%10000101; + !byte $9F,%01100110 + !byte $9F,%10000111; + !byte $B7,%01101100 + !byte $B7,%10001101; + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $83,%00100110 + !byte $7F,%00000100 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $5F,%00100100 + !byte $9F,%11101001 + !byte $BF,%11010011 + !byte $01,%01001110 + !byte $09,%00001110 + !byte $39,%10100101 + !byte $B5,%11101101 + !byte $BD,%11110011 + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $81,%01000100 + !byte $B3,%00101110 + !byte $03,%00101110 + !byte $41,%00000110 + !byte $5D,%11100011 + !byte $83,%00000110 + !byte $A1,%11100111 + !byte $3F,%11100101 + !byte $A1,%11000111 + !byte $B7,%10101101 + !byte $05,%11110011 + !byte $0F,%11101101 + !byte $13,%01101000 + !byte $13,%10001001; + !byte $61,%01000100 + !byte $A1,%00101000 + !byte $B1,%01101110 + !byte $B1,%10001111; + !byte $83,%11100101 + !byte $A1,%00001000 + !byte $07,%00001110 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $37,%01100100 + !byte $37,%10000101; + !byte $81,%00100100 + !byte $A1,%01001000 + !byte $07,%11010011 + !byte $5F,%00000100 + !byte $5B,%10100011 + !byte $B7,%11001101 + !byte $11,%10101001 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $A1,%10100111 + !byte $0D,%11101101 + !byte $3D,%11000101 + !byte $83,%11000101 + !byte $A1,%01101000 + !byte $A1,%10001001; + !byte $7F,%11100011 + !byte $05,%00001110 + !byte $17,%01001000 + !byte $19,%01001000 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $3B,%10100101 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $B5,%00001110 + !byte $83,%10100101 + !byte $BF,%11110011 + !byte $01,%00101110 + !byte $0B,%11101101 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $B9,%00101100 + !byte $B9,%01001100 + !byte $B3,%01001110 + !byte $1B,%01001000 + !byte $33,%01000100 + !byte $59,%01100010 + !byte $59,%10000011; + !byte $5D,%11000011 + !byte $A1,%10101001 + !byte $15,%01001000 + !byte $35,%01000100 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $1D,%01001000 + !byte $61,%00100100 + !byte $81,%00000100 + !byte $03,%11110011 + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $83,%01100100 + !byte $83,%10000101; + !byte $B9,%01101100 + !byte $B9,%10001101; + !byte $41,%11100101 + !byte $B7,%11101101 + !byte $03,%00001110 + !byte $09,%11101101 + !byte $1F,%01001000 + !byte $31,%01000100 + !byte $85,%00100110 + !byte $5F,%11100011 + !byte $A1,%11001001 + !byte $B5,%00101110 + !byte $05,%11010011 + !byte $3F,%11000101 + !byte $07,%10110011 + !byte $B3,%01101110 + !byte $B3,%10001111; + !byte $83,%01000100 + !byte $A1,%11101001 + !byte $B9,%10101101 + !byte $37,%01000100 + !byte $A3,%11100111 + !byte $A3,%00001000 + !byte $07,%11101101 + !byte $0F,%11001101 + !byte $3D,%10100101 + !byte $85,%00000110 + !byte $13,%01001000 + !byte $A1,%01100110 + !byte $A1,%10000111; + !byte $21,%01001000 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $61,%00000100 + !byte $63,%01000100 + !byte $A3,%00101000 + !byte $5D,%10100011 + !byte $A3,%11000111 + !byte $A1,%00001010 + !byte $01,%11110011 + !byte $85,%11100101 + !byte $B7,%00001110 + !byte $0D,%11001101 + !byte $19,%00101000 + !byte $23,%01001000 + !byte $81,%11100011 + !byte $83,%00100100 + !byte $A3,%01001000 + !byte $17,%00101000 + !byte $05,%11101101 + !byte $5F,%11000011 + !byte $B9,%11001101 + !byte $01,%00001110 + !byte $1B,%00101000 + !byte $A3,%01101000 + !byte $A3,%10001001; + !byte $B9,%00001100 + !byte $B5,%01001110 + !byte $39,%01000100 + !byte $85,%11000101 + !byte $03,%11010011 + !byte $0B,%11001101 + !byte $15,%00101000 + !byte $41,%11000101 + !byte $A3,%10100111 + !byte $1D,%00101000 + !byte $63,%00100100 + !byte $85,%10100101 + !byte $65,%01100100 + !byte $65,%10000101; + !byte $03,%11101101 + !byte $09,%11001101 + !byte $35,%00100100 + !byte $61,%11100011 + !byte $83,%00000100 + !byte $A3,%10101001 + !byte $05,%10110011 + !byte $33,%00100100 + !byte $3F,%10100101 + !byte $B3,%10101111 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $59,%01000010 + !byte $7F,%11000011 + !byte $BB,%01001100 + !byte $B9,%11101101 + !byte $1F,%00101000 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $B7,%00101110 + !byte $85,%01100100 + !byte $85,%10000101; + !byte $BB,%01101100 + !byte $BB,%10001101; + !byte $7D,%11000011 + !byte $A3,%11001001 + !byte $07,%11001101 + !byte $37,%00100100 + !byte $3B,%01000100 + !byte $5F,%10100011 + !byte $85,%01000100 + !byte $A3,%11101001 + !byte $B5,%01101110 + !byte $B5,%10001111; + !byte $01,%11010011 + !byte $0F,%10101101 + !byte $21,%00101000 + !byte $87,%00100110 + !byte $BB,%10101101 + !byte $5B,%01000010 + !byte $13,%00101000 + !byte $43,%11000101 + !byte $57,%01000010 + !byte $61,%11000011 + !byte $B9,%00001110 + !byte $19,%00001000 + !byte $65,%01000100 + !byte $87,%00000110 + !byte $A5,%11100111 + !byte $A5,%00001000 + !byte $03,%10110011 + !byte $01,%11101101 + !byte $05,%11001101 + !byte $63,%00000100 + !byte $83,%11100011 + !byte $0D,%10101101 + !byte $17,%00001000 + !byte $1B,%00001000 + !byte $85,%00100100 + !byte $A5,%00101000 + !byte $A3,%00001010 + !byte $BB,%00101100 + !byte $23,%00101000 + !byte $39,%00100100 + !byte $87,%11100101 + !byte $A3,%01100110 + !byte $A3,%10000111; + !byte $41,%10100101 + !byte $A5,%11000111 + !byte $BB,%11001101 + !byte $B7,%01001110 + !byte $81,%11000011 + !byte $0B,%10101101 + !byte $1D,%00001000 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $A5,%01001000 + !byte $15,%00001000 + !byte $87,%11000101 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $03,%11001101 + !byte $09,%10101101 + !byte $25,%00101000 + !byte $A5,%01101000 + !byte $A5,%10001001; + !byte $B5,%10101111 + !byte $3D,%01000100 + !byte $5D,%01000010 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $87,%10100101 + !byte $1F,%00001000 + !byte $65,%00100100 + !byte $85,%00000100 + !byte $3B,%00100100 + !byte $63,%11100011 + !byte $A5,%10100111 + !byte $B9,%00101110 + !byte $35,%00000100 + !byte $BB,%11101101 + !byte $61,%10100011 + !byte $07,%10101101 + !byte $37,%00000100 + !byte $87,%01100100 + !byte $87,%10000101; + !byte $A5,%10101001 + !byte $01,%10110011 + !byte $B7,%01101110 + !byte $B7,%10001111; + !byte $01,%11001101 + !byte $21,%00001000 + !byte $43,%10100101 + !byte $65,%00000100 + !byte $03,%01110010 + !byte $03,%10010011; + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $41,%01100100 + !byte $41,%10000101; + !byte $63,%11000011 + !byte $85,%11100011 + !byte $87,%01000100 + !byte $A5,%11001001 + !byte $05,%10101101 + !byte $67,%01000100 + !byte $83,%11000011 + !byte $BD,%01101100 + !byte $BD,%10001101; + !byte $39,%00000100 + !byte $17,%11100111 + !byte $19,%11100111 + !byte $33,%00000100 + !byte $BB,%00001110 + !byte $1B,%11100111 + !byte $89,%00100110 + !byte $BD,%10101101 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $23,%00001000 + !byte $3F,%01000100 + !byte $5F,%01000010 + !byte $A5,%11101001 + !byte $B5,%11001111 + !byte $13,%00001000 + !byte $A7,%11100111 + !byte $A7,%00001000 + !byte $3D,%00100100 + !byte $89,%00000110 + !byte $B9,%01001110 + !byte $05,%01010010 + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $87,%00100100 + !byte $A7,%00101000 + !byte $BD,%11001101 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $03,%10101101 + !byte $15,%11100111 + !byte $1D,%11100111 + !byte $5B,%00100010 + !byte $89,%11100101 + !byte $A7,%01001000 + !byte $A5,%00001010 + !byte $BD,%01001100 + !byte $A7,%11000111 + !byte $B7,%10101111 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $3B,%00000100 + !byte $65,%11100011 + !byte $BB,%00101110 + !byte $1F,%11100111 + !byte $25,%00001000 + !byte $63,%10100011 + !byte $89,%11000101 + !byte $67,%00100100 + !byte $87,%00000100 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $5D,%00100010 + !byte $07,%01101100 + !byte $07,%10001101; + !byte $43,%01100100 + !byte $43,%10000101; + !byte $89,%10100101 + !byte $45,%10100101 + !byte $A7,%01101000 + !byte $A7,%10001001; + !byte $BD,%11101101 + !byte $37,%11100011 + !byte $41,%01000100 + !byte $01,%10101101 + !byte $03,%01010010 + !byte $A7,%10101001 + !byte $B9,%01101110 + !byte $B9,%10001111; + !byte $21,%11100111 + !byte $35,%11100011 + !byte $61,%01000010 + !byte $05,%01101100 + !byte $05,%10001101; + !byte $3F,%00100100 + !byte $85,%11000011 + !byte $89,%01100100 + !byte $89,%10000101; + !byte $19,%11000111 + !byte $1B,%11000111 + !byte $39,%11100011 + !byte $3D,%00000100 + !byte $5F,%00100010 + !byte $65,%11000011 + !byte $A7,%11001001 + !byte $0F,%01001100 + !byte $17,%11000111 + !byte $89,%01000100 + !byte $A7,%10100111 + !byte $BB,%01001110 + !byte $B7,%11001111 + !byte $67,%00000100 + !byte $BD,%00001110 + !byte $23,%11100111 + !byte $A5,%01100110 + !byte $A5,%10000111; + !byte $63,%01100010 + !byte $63,%10000011; + !byte $87,%11100011 + !byte $03,%01101100 + !byte $03,%10001101; + !byte $0D,%01001100 + !byte $0B,%01001100 + !byte $A9,%00001000 + !byte $A7,%11101001 + !byte $B9,%10101111 + !byte $1D,%11000111 + !byte $89,%00100100 + !byte $8B,%00100110 + !byte $09,%01001100 + !byte $25,%11100111 + !byte $3B,%11100011 + !byte $43,%01000100 + !byte $A9,%00101000 + !byte $BF,%10101101 + !byte $15,%11000111 + !byte $8B,%00000110 + !byte $A9,%11100111 + !byte $1F,%11000111 + !byte $BF,%11001101 + !byte $01,%01010010 + !byte $07,%01001100 + !byte $13,%11100111 + !byte $A9,%01001000 + !byte $A7,%00001010 + !byte $BD,%00101110 + !byte $45,%01100100 + !byte $45,%10000101; + !byte $67,%11100011 + !byte $8B,%11100101 + !byte $BF,%01101100 + !byte $BF,%10001101; + !byte $41,%00100100 + !byte $65,%10100011 + !byte $3F,%00000100 + !byte $61,%00100010 + !byte $69,%00100100 + !byte $89,%00000100 + !byte $A9,%11000111 + !byte $A9,%01101000 + !byte $A9,%10001001; + !byte $03,%00110010 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $63,%01000010 + !byte $8B,%11000101 + !byte $BF,%11101101 + !byte $BB,%01101110 + !byte $BB,%10001111; + !byte $B7,%11101111 + !byte $87,%11000011 + !byte $A7,%00101010 + !byte $05,%01001100 + !byte $21,%11000111 + !byte $8B,%10100101 + !byte $A9,%10101001 + !byte $39,%11000011 + !byte $3D,%11100011 + !byte $0F,%00101100 + !byte $19,%10100111 + !byte $1B,%10100111 + !byte $37,%11000011 + !byte $67,%11000011 + !byte $8B,%01100100 + !byte $8B,%10000101; + !byte $B9,%11001111 + !byte $65,%01100010 + !byte $65,%10000011; + !byte $17,%10100111 + !byte $69,%00000100 + !byte $89,%11100011 + !byte $BD,%01001110 + !byte $23,%11000111 + !byte $A9,%11001001 + !byte $03,%01001100 + !byte $0D,%00101100 + !byte $BF,%00001110 + !byte $8B,%01000100 + !byte $1D,%10100111 + !byte $5F,%00000010 + !byte $0B,%00101100 + !byte $3B,%11000011 + !byte $43,%00100100 + !byte $41,%00000100 + !byte $45,%01000100 + !byte $09,%00101100 + !byte $1F,%10100111 + !byte $A9,%10100111 + !byte $BB,%10101111 + !byte $01,%00110010 + !byte $25,%11000111 + !byte $5D,%00000010 + !byte $63,%00100010 + !byte $8B,%00100100 + !byte $01,%01001100 + !byte $07,%00101100 + !byte $3F,%11100011 + !byte $69,%11100011 + !byte $67,%10100011 + !byte $AB,%00101000 + !byte $A9,%11101001 + !byte $AB,%00001000 + !byte $BF,%00101110 + !byte $15,%10100111 + !byte $AB,%11100111 + !byte $8D,%00000110 + !byte $8D,%00100110 + !byte $AB,%01001000 + !byte $BD,%01101110 + !byte $BD,%10001111; + !byte $61,%00000010 + !byte $65,%01000010 + !byte $6B,%00100100 + !byte $B9,%11101111 + !byte $03,%00010010 + !byte $21,%10100111 + !byte $35,%11000011 + !byte $27,%11000111 + !byte $05,%00101100 + !byte $3D,%11000011 + !byte $8D,%11100101 + !byte $A9,%00001010 + !byte $89,%11000011 + !byte $8B,%00000100 + !byte $AB,%01101000 + !byte $AB,%10001001; + !byte $8D,%11000101 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $BB,%11001111 + !byte $41,%11100011 + !byte $45,%00100100 + !byte $69,%11000011 + !byte $BF,%01001110 + !byte $0F,%00001100 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $43,%00000100 + !byte $47,%01000100 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $8D,%10100101 + !byte $A9,%00101010 + !byte $03,%00101100 + !byte $23,%10100111 + !byte $AB,%11000111 + !byte $AB,%10101001 + !byte $39,%10100011 + !byte $8B,%11100011 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $8D,%01100100 + !byte $8D,%10000101; + !byte $0D,%00001100 + !byte $3B,%10100011 + !byte $63,%00000010 + !byte $6B,%00000100 + !byte $BD,%10101111 + !byte $0B,%00001100 + !byte $B9,%00010000 + !byte $01,%00010010 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $8D,%01000100 + !byte $37,%10100011 + !byte $3F,%11000011 + !byte $65,%00100010 + !byte $AB,%11001001 + !byte $01,%00101100 + !byte $07,%00001100 + !byte $09,%00001100 + !byte $8D,%00100100 + !byte $25,%10100111 + !byte $67,%01000010 + !byte $69,%10100011 + !byte $21,%01100110 + !byte $21,%10000111; + !byte $3D,%10100011 + !byte $BF,%01101110 + !byte $BF,%10001111; + !byte $03,%11110001 + !byte $6B,%11100011 + !byte $AB,%11101001 + !byte $AD,%00001000 + !byte $AD,%00101000 + !byte $BD,%11001111 + !byte $05,%00001100 + !byte $BB,%11101111 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $27,%10100111 + !byte $45,%00000100 + !byte $43,%11100011 + !byte $47,%00100100 + !byte $AD,%01001000 + !byte $AB,%00001010 + !byte $8F,%00000110 + !byte $8F,%00100110 + !byte $AD,%11100111 + !byte $41,%11000011 + !byte $8B,%11000011 + !byte $8D,%00000100 + !byte $1B,%01000110 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $65,%00000010 + !byte $AD,%01101000 + !byte $AD,%10001001; + !byte $19,%01000110 + !byte $8F,%11100101 + !byte $03,%00001100 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $1D,%01000110 + !byte $61,%11100001 + !byte $AD,%10101001 + !byte $0F,%11101011 + !byte $3F,%10100011 + !byte $8F,%10100101 + !byte $8F,%11000101 + !byte $01,%11110001 + !byte $0D,%11101011 + !byte $6B,%11000011 + !byte $67,%00100010 + !byte $0B,%11101011 + !byte $17,%01000110 + !byte $8D,%11100011 + !byte $AB,%00101010 + !byte $6D,%00000100 + !byte $8F,%01100100 + !byte $8F,%10000101; + !byte $BF,%10101111 + !byte $1F,%01000110 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $BB,%00010000 + !byte $01,%00001100 + !byte $09,%11101011 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $39,%01100010 + !byte $39,%10000011; + !byte $63,%11100001 + !byte $8F,%01000100 + !byte $AD,%11000111 + !byte $AD,%11001001 + !byte $BD,%11101111 + !byte $07,%11101011 + !byte $AB,%01001010 + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $45,%11100011 + !byte $6B,%10100011 + !byte $21,%01000110 + !byte $69,%01000010 + !byte $49,%00100100 + !byte $43,%11000011 + !byte $47,%00000100 + !byte $05,%11101011 + !byte $41,%10100011 + !byte $8F,%00100100 + !byte $AD,%11101001 + !byte $27,%01100110 + !byte $27,%10000111; + !byte $6D,%11100011 + !byte $BF,%11001111 + !byte $65,%11100001 + !byte $67,%00000010 + !byte $8D,%11000011 + !byte $8F,%00000100 + !byte $03,%11101011 + !byte $19,%00100110 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $AF,%00001000 + !byte $BB,%00110000 + !byte $01,%11010001 + !byte $1B,%00100110 + !byte $23,%01000110 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $AF,%00101000 + !byte $AF,%01001000 + !byte $1D,%00100110 + !byte $6D,%11000011 + !byte $0F,%11001011 + !byte $91,%00000110 + !byte $91,%00100110 + !byte $AF,%01101000 + !byte $AF,%10001001; + !byte $AD,%00001010 + !byte $69,%00100010 + !byte $BD,%00010000 + !byte $01,%11101011 + !byte $0B,%11001011 + !byte $0D,%11001011 + !byte $1F,%00100110 + !byte $45,%11000011 + !byte $91,%11000101 + !byte $91,%11100101 + !byte $AF,%11100111 + !byte $8F,%11100011 + !byte $AF,%10101001 + !byte $09,%11001011 + !byte $15,%01000110 + !byte $49,%00000100 + !byte $25,%01000110 + !byte $91,%10100101 + !byte $17,%00100110 + !byte $43,%10100011 + !byte $47,%11100011 + !byte $AD,%00101010 + !byte $6F,%00000100 + !byte $91,%01100100 + !byte $91,%10000101; + !byte $BF,%11101111 + !byte $07,%11001011 + !byte $21,%00100110 + !byte $6B,%01000010 + !byte $AF,%11001001 + !byte $6D,%10100011 + !byte $41,%01100010 + !byte $41,%10000011; + !byte $91,%01000100 + !byte $3B,%01000010 + !byte $3D,%01000010 + !byte $8B,%10100011 + !byte $05,%11001011 + !byte $67,%11100001 + !byte $69,%00000010 + !byte $BD,%00110000 + !byte $27,%01000110 + !byte $91,%00100100 + !byte $AD,%01001010 + !byte $03,%11001011 + !byte $1B,%00000110 + !byte $23,%00100110 + !byte $3F,%01000010 + !byte $6F,%11100011 + !byte $8F,%11000011 + !byte $91,%00000100 + !byte $AF,%11101001 + !byte $6B,%00100010 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $B1,%00101000 + !byte $B1,%01001000 + !byte $01,%10110001 + !byte $19,%00000110 + !byte $1D,%00000110 + !byte $43,%01100010 + !byte $43,%10000011; + !byte $47,%11000011 + !byte $45,%10100011 + !byte $AF,%11000111 + !byte $BF,%00010000 + !byte $01,%11001011 + !byte $0D,%10101011 + !byte $25,%00100110 + !byte $B1,%01101000 + !byte $B1,%10001001; + !byte $AF,%00001010 + !byte $1F,%00000110 + !byte $29,%01000110 + !byte $4B,%00000100 + !byte $65,%11000001 + !byte $B1,%00001000 + !byte $0F,%10101011 + !byte $49,%11100011 + !byte $6F,%11000011 + !byte $09,%10101011 + !byte $0B,%10101011 + !byte $41,%01000010 + !byte $8D,%10100011 + !byte $93,%11100101 + !byte $91,%11100011 + !byte $93,%00000110 + !byte $93,%00100110 + !byte $69,%11100001 + !byte $63,%11000001 + !byte $B1,%10101001 + !byte $07,%10101011 + !byte $17,%00000110 + !byte $21,%00000110 + !byte $93,%10100101 + !byte $93,%11000101 + !byte $BD,%01010000 + !byte $27,%00100110 + !byte $67,%11000001 + !byte $6D,%01000010 + !byte $B1,%11100111 + !byte $AF,%00101010 + !byte $05,%10101011 + !byte $6B,%00000010 + !byte $93,%01100100 + !byte $93,%10000101; + !byte $6F,%10100011 + !byte $B1,%11001001 + !byte $3D,%00100010 + !byte $47,%10100011 + !byte $BF,%00110000 + !byte $23,%00000110 + !byte $93,%01000100 + !byte $03,%10101011 + !byte $3F,%00100010 + !byte $43,%01000010 + !byte $4B,%11100011 + !byte $1B,%11100101 + !byte $1D,%11100101 + !byte $45,%01100010 + !byte $45,%10000011; + !byte $71,%11100011 + !byte $93,%00100100 + !byte $B1,%11101001 + !byte $AF,%01001010 + !byte $6D,%00100010 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $49,%11000011 + !byte $91,%11000011 + !byte $01,%10101011 + !byte $29,%00100110 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $19,%11100101 + !byte $1F,%11100101 + !byte $25,%00000110 + !byte $69,%11000001 + !byte $6B,%11100001 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $93,%00000100 + !byte $41,%00100010 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $8F,%10100011 + !byte $B3,%00101000 + !byte $71,%11000011 + !byte $B3,%01001000 + !byte $B1,%00001010 + !byte $AF,%01101010 + !byte $AF,%10001011; + !byte $BF,%01010000 + !byte $3B,%00100010 + !byte $B3,%01101000 + !byte $B3,%10001001; + !byte $BD,%01110000 + !byte $BD,%10010001; + !byte $21,%11100101 + !byte $B3,%00001000 + !byte $05,%01101010 + !byte $05,%10001011; + !byte $07,%01101010 + !byte $07,%10001011; + !byte $6F,%01000010 + !byte $47,%01100010 + !byte $47,%10000011; + !byte $6D,%00000010 + !byte $93,%11100011 + !byte $27,%00000110 + !byte $B3,%10101001 + !byte $95,%11000101 + !byte $95,%11100101 + !byte $95,%00000110 + !byte $95,%00100110 + !byte $B1,%00101010 + !byte $45,%01000010 + !byte $49,%10100011 + !byte $03,%01101010 + !byte $03,%10001011; + !byte $71,%10100011 + !byte $95,%01100100 + !byte $95,%10000101; + !byte $95,%10100101 + !byte $23,%11100101 + !byte $4B,%11000011 + !byte $B3,%11001001 + !byte $43,%00100010 + !byte $4D,%11100011 + !byte $95,%01000100 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $1B,%11000101 + !byte $73,%11100011 + !byte $1D,%11000101 + !byte $29,%00000110 + !byte $6F,%00100010 + !byte $93,%11000011 + !byte $95,%00100100 + !byte $17,%11100101 + !byte $6B,%11000001 + !byte $B1,%01001010 + !byte $1F,%11000101 + !byte $3F,%00000010 + !byte $6D,%11100001 + !byte $25,%11100101 + !byte $B3,%11101001 + !byte $BF,%01110000 + !byte $BF,%10010001; + !byte $71,%01100010 + !byte $71,%10000011; + !byte $0B,%01001010 + !byte $0D,%01001010 + !byte $0F,%01001010 + !byte $41,%00000010 + !byte $45,%00100010 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $91,%10100011 + !byte $B1,%01101010 + !byte $B1,%10001011; + !byte $09,%01001010 + !byte $21,%11000101 + !byte $47,%01000010 + !byte $19,%11000101 + !byte $95,%00000100 + !byte $3D,%00000010 + !byte $73,%11000011 + !byte $B5,%01001000 + !byte $B3,%00001010 + !byte $05,%01001010 + !byte $07,%01001010 + !byte $6F,%00000010 + !byte $B3,%11100111 + !byte $4D,%11000011 + !byte $69,%10100001 + !byte $71,%01000010 + !byte $B5,%01101000 + !byte $B5,%10001001; + !byte $23,%11000101 + !byte $2B,%00000110 + !byte $4B,%10100011 + !byte $B5,%00101000 + !byte $27,%11100101 + !byte $67,%10100001 + !byte $03,%01001010 + !byte $6D,%11000001 + !byte $95,%11100011 + !byte $B5,%10101001 + !byte $43,%00000010 + !byte $73,%10100011 + !byte $97,%11100101 + !byte $97,%00000110 + !byte $97,%00100110 + !byte $B3,%00101010 + !byte $BF,%10110001 + !byte $B5,%11001001 + !byte $97,%10100101 + !byte $97,%11000101 + !byte $01,%01001010 + !byte $1D,%10100101 + !byte $1F,%10100101 + !byte $71,%00100010 + !byte $1B,%10100101 + !byte $25,%11000101 + !byte $6B,%10100001 + !byte $6F,%11100001 + !byte $97,%01000100 + !byte $49,%01000010 + !byte $97,%01100100 + !byte $97,%10000101; + !byte $B5,%00001000 + !byte $29,%11100101 + !byte $47,%00100010 + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $95,%11000011 + !byte $B5,%11101001 + !byte $B3,%01001010 + !byte $97,%00100100 + !byte $0B,%00101010 + !byte $0D,%00101010 + !byte $0F,%00101010 + !byte $45,%00000010 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $75,%11100011 + !byte $07,%00101010 + !byte $09,%00101010 + !byte $21,%10100101 + !byte $41,%11100001 + !byte $4D,%10100011 + !byte $93,%10100011 + !byte $97,%00000100 + !byte $27,%11000101 + !byte $4F,%11000011 + !byte $05,%00101010 + !byte $71,%00000010 + !byte $B5,%00001010 + !byte $B3,%01101010 + !byte $B3,%10001011; + !byte $03,%00101010 + !byte $19,%10100101 + !byte $23,%10100101 + !byte $2B,%11100101 + !byte $3F,%11100001 + !byte $73,%01000010 + !byte $75,%11000011 + !byte $43,%11100001 + !byte $B7,%01001000 + !byte $6D,%10100001 + !byte $6F,%11000001 + !byte $B7,%01101000 + !byte $B7,%10001001; + !byte $97,%11100011 + !byte $47,%00000010 + !byte $4B,%01000010 + !byte $49,%00100010 + !byte $B7,%10101001 + !byte $B5,%00101010 + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $71,%11100001 + !byte $99,%11000101 + !byte $99,%11100101 + !byte $99,%00000110 + !byte $01,%00101010 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $29,%11000101 + !byte $B7,%00101000 + !byte $25,%10100101 + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $73,%00100010 + !byte $75,%10100011 + !byte $99,%10100101 + !byte $B3,%10101011 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $99,%00100110 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $45,%11100001 + !byte $99,%01000100 + !byte $99,%01100100 + !byte $99,%10000101; + !byte $B7,%11001001 + !byte $0F,%00001010 + !byte $4F,%10100011 + !byte $B7,%11101001 + !byte $B5,%01001010 + !byte $09,%00001010 + !byte $0B,%00001010 + !byte $0D,%00001010 + !byte $07,%00001010 + !byte $99,%00100100 + !byte $05,%00001010 + !byte $2B,%11000101 + !byte $27,%10100101 + !byte $6F,%10100001 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $97,%11000011 + !byte $03,%00001010 + !byte $23,%01100100 + !byte $23,%10000101; + !byte $71,%11000001 + !byte $99,%00000100 + !byte $B7,%00001010 + !byte $4B,%00100010 + !byte $73,%00000010 + !byte $49,%00000010 + !byte $B5,%01101010 + !byte $B5,%10001011; + !byte $4D,%01000010 + !byte $95,%10100011 + !byte $47,%11100001 + !byte $43,%11000001 + !byte $99,%11100011 + !byte $01,%00001010 + !byte $41,%11000001 + !byte $75,%01000010 + !byte $77,%11000011 + !byte $B7,%00001000 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $1D,%01000100 + !byte $1F,%01000100 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $B9,%01101000 + !byte $B9,%10001001; + !byte $B9,%10101001 + !byte $B7,%00101010 + !byte $B5,%10101011 + !byte $29,%10100101 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $73,%11100001 + !byte $B9,%01001000 + !byte $45,%11000001 + !byte $51,%10100011 + !byte $75,%00100010 + !byte $77,%10100011 + !byte $B9,%11001001 + !byte $21,%01000100 + !byte $07,%11101001 + !byte $49,%11100001 + !byte $4D,%00100010 + !byte $9B,%01100100 + !byte $9B,%10000101; + !byte $9B,%10100101 + !byte $9B,%11000101 + !byte $9B,%11100101 + !byte $9B,%00000110 + !byte $9B,%00100110 + !byte $0B,%11101001 + !byte $0D,%11101001 + !byte $71,%10100001 + !byte $09,%11101001 + !byte $9B,%01000100 + !byte $27,%01100100 + !byte $27,%10000101; + !byte $05,%11101001 + !byte $1B,%01000100 + !byte $0F,%11101001 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $4B,%00000010 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $B9,%00101000 + !byte $B9,%11101001 + !byte $B7,%01001010 + !byte $23,%01000100 + !byte $2B,%10100101 + !byte $9B,%00100100 + !byte $77,%01100010 + !byte $77,%10000011; + !byte $03,%11101001 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $75,%00000010 + !byte $B5,%11001011 + !byte $47,%11000001 + !byte $4F,%01000010 + !byte $73,%11000001 + !byte $99,%11000011 + !byte $9B,%00000100 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $B9,%00001010 + !byte $B7,%01101010 + !byte $B7,%10001011; + !byte $51,%01100010 + !byte $51,%10000011; + !byte $01,%11101001 + !byte $77,%01000010 + !byte $25,%01000100 + !byte $2D,%10100101 + !byte $1F,%00100100 + !byte $75,%11100001 + !byte $79,%11000011 + !byte $97,%10100011 + !byte $4B,%11100001 + !byte $1D,%00100100 + !byte $21,%00100100 + !byte $45,%10100001 + !byte $77,%00100010 + !byte $B7,%10101011 + !byte $9B,%11100011 + !byte $4D,%00000010 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $73,%10100001 + !byte $B9,%00101010 + !byte $49,%11000001 + !byte $05,%11001001 + !byte $07,%11001001 + !byte $09,%11001001 + !byte $BB,%01101000 + !byte $BB,%10001001; + !byte $BB,%10101001 + !byte $BB,%11001001 + !byte $0D,%11001001 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $43,%10100001 + !byte $4F,%00100010 + !byte $79,%10100011 + !byte $0B,%11001001 + !byte $27,%01000100 + !byte $03,%11001001 + !byte $23,%00100100 + !byte $51,%01000010 + !byte $9D,%01100100 + !byte $9D,%10000101; + !byte $9D,%10100101 + !byte $9D,%11000101 + !byte $B9,%01001010 + !byte $0F,%11001001 + !byte $9D,%11100101 + !byte $9D,%00000110 + !byte $BB,%01001000 + !byte $75,%11000001 + !byte $47,%10100001 + !byte $77,%00000010 + !byte $79,%01100010 + !byte $79,%10000011; + !byte $9D,%00100100 + !byte $9D,%01000100 + !byte $BB,%11101001 + !byte $9D,%00100110 + !byte $9D,%01000110 + !byte $25,%00100100 + !byte $4B,%11000001 + !byte $9B,%11000011 + !byte $B7,%11001011 + !byte $29,%01000100 + !byte $53,%01100010 + !byte $53,%10000011; + !byte $9D,%00000100 + !byte $BB,%00001010 + !byte $1B,%00100100 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $B9,%01101010 + !byte $B9,%10001011; + !byte $01,%11001001 + !byte $4D,%11100001 + !byte $4F,%00000010 + !byte $73,%01100000 + !byte $73,%10000001; + !byte $77,%11100001 + !byte $79,%01000010 + !byte $75,%10100001 + !byte $B7,%11101011 + !byte $49,%10100001 + !byte $1F,%00000100 + !byte $21,%00000100 + !byte $27,%00100100 + !byte $7B,%11000011 + !byte $9D,%11100011 + !byte $BB,%00101010 + !byte $51,%00100010 + !byte $05,%10101001 + !byte $07,%10101001 + !byte $09,%10101001 + !byte $0B,%10101001 + !byte $0D,%10101001 + !byte $53,%01000010 + !byte $1D,%00000100 + !byte $23,%00000100 + !byte $2B,%01000100 + !byte $B9,%10101011 + !byte $79,%00100010 + !byte $7B,%10100011 + !byte $BD,%10101001 + !byte $03,%10101001 + !byte $4D,%11000001 + !byte $0F,%10101001 + !byte $BB,%01001010 + !byte $77,%11000001 + !byte $47,%01100000 + !byte $47,%10000001; + !byte $4B,%10100001 + !byte $9F,%01000100 + !byte $9F,%01100100 + !byte $9F,%10000101; + !byte $BD,%01101000 + !byte $BD,%10001001; + !byte $29,%00100100 + !byte $45,%01100000 + !byte $45,%10000001; + !byte $9F,%10100101 + !byte $9F,%11000101 + !byte $9F,%11100101 + !byte $25,%00000100 + !byte $79,%00000010 + !byte $BD,%11001001 + !byte $2D,%01000100 + !byte $4F,%11100001 + !byte $9F,%00100100 + !byte $01,%10101001 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $9F,%00000110 + !byte $9F,%00100110 + !byte $BD,%11101001 + !byte $B9,%11001011 + !byte $71,%01000000 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $51,%00000010 + !byte $9F,%01000110 + !byte $BD,%00001010 + !byte $BB,%01101010 + !byte $BB,%10001011; + !byte $49,%01100000 + !byte $49,%10000001; + !byte $77,%10100001 + !byte $BB,%00101000 + !byte $9D,%11000011 + !byte $9F,%00000100 + !byte $27,%00000100 + !byte $79,%11100001 + !byte $7B,%01000010 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $09,%01101000 + !byte $09,%10001001; + !byte $53,%00100010 + !byte $73,%01000000 + !byte $BD,%01001000 + !byte $B9,%11101011 + !byte $21,%11100011 + !byte $2B,%00100100 + !byte $1F,%11100011 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $23,%11100011 + !byte $2F,%01000100 + !byte $4D,%10100001 + !byte $BD,%00101010 + !byte $05,%01101000 + !byte $05,%10001001; + !byte $4F,%11000001 + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $11,%01101000 + !byte $11,%10001001; + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $55,%01000010 + !byte $BB,%10101011 + !byte $03,%01101000 + !byte $03,%10001001; + !byte $51,%11100001 + !byte $29,%00000100 + !byte $79,%11000001 + !byte $7B,%00100010 + !byte $9F,%11100011 + !byte $25,%11100011 + !byte $BD,%01001010 + !byte $7D,%10100011 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $53,%00000010 + !byte $2D,%00100100 + !byte $75,%01000000 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $A1,%01000100 + !byte $A1,%01100100 + !byte $A1,%10000101; + !byte $A1,%10100101 + !byte $BF,%11001001 + !byte $7B,%00000010 + !byte $A1,%11000101 + !byte $BF,%10101001 + !byte $1D,%11100011 + !byte $A1,%00000110 + !byte $A1,%00100100 + !byte $BF,%11101001 + !byte $BB,%11001011 + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $A1,%11100101 + !byte $27,%11100011 + !byte $49,%01000000 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $51,%11000001 + !byte $A1,%00100110 + !byte $A1,%01000110 + !byte $47,%01000000 + !byte $4F,%10100001 + !byte $7B,%11100001 + !byte $BF,%00001010 + !byte $BD,%01101010 + !byte $BD,%10001011; + !byte $2B,%00000100 + !byte $55,%00100010 + !byte $79,%10100001 + !byte $09,%01001000 + !byte $21,%11000011 + !byte $05,%01001000 + !byte $07,%01001000 + !byte $0B,%01001000 + !byte $BF,%01101000 + !byte $BF,%10001001; + !byte $2F,%00100100 + !byte $7D,%01000010 + !byte $9F,%11000011 + !byte $A1,%00000100 + !byte $0D,%01001000 + !byte $23,%11000011 + !byte $4B,%01000000 + !byte $53,%11100001 + !byte $BF,%00101010 + !byte $BB,%11101011 + !byte $29,%11100011 + !byte $03,%01001000 + !byte $0F,%01001000 + !byte $1F,%11000011 + !byte $2D,%00000100 + !byte $7B,%11000001 + !byte $7D,%00100010 + !byte $25,%11000011 + !byte $77,%01000000 + !byte $BD,%10101011 + !byte $11,%01001000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $A1,%11100011 + !byte $55,%00000010 + !byte $BF,%01001010 + !byte $01,%01001000 + !byte $BB,%00001100 + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $31,%00100100 + !byte $7F,%10100011 + !byte $57,%00100010 + !byte $4D,%01000000 + !byte $51,%10100001 + !byte $BD,%11001011 + !byte $2B,%11100011 + !byte $7B,%10100001 + !byte $7D,%00000010 + !byte $27,%11000011 + !byte $A3,%01100100 + !byte $A3,%10000101; + !byte $A3,%10100101 + !byte $A3,%11000101 + !byte $A3,%11100101 + !byte $A3,%00000110 + !byte $BF,%01101010 + !byte $BF,%10001011; + !byte $53,%11000001 + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $A3,%00100100 + !byte $A3,%01000100 + !byte $05,%00101000 + !byte $2F,%00000100 + !byte $55,%11100001 + !byte $A3,%00100110 + !byte $07,%00101000 + !byte $09,%00101000 + !byte $0B,%00101000 + !byte $7D,%11100001 + !byte $03,%00101000 + !byte $21,%10100011 + !byte $A3,%00000100 + !byte $0D,%00101000 + !byte $23,%10100011 + !byte $79,%01000000 + !byte $7F,%01000010 + !byte $A3,%01000110 + !byte $BD,%11101011 + !byte $29,%11000011 + !byte $25,%10100011 + !byte $A1,%11000011 + !byte $0F,%00101000 + !byte $2D,%11100011 + !byte $BF,%10101011 + !byte $51,%01100000 + !byte $51,%10000001; + !byte $11,%00101000 + !byte $4B,%00100000 + !byte $4F,%01000000 + !byte $57,%00000010 + !byte $7D,%11000001 + !byte $7F,%00100010 + !byte $49,%00100000 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $01,%00101000 + !byte $31,%00000100 + !byte $53,%10100001 + !byte $27,%10100011 + !byte $A3,%11100011 + !byte $BD,%00001100 + !byte $2B,%11000011 + !byte $1F,%10100011 + !byte $4D,%00100000 + !byte $55,%11000001 + !byte $7F,%00000010 + !byte $59,%00100010 + !byte $81,%10100011 + !byte $2F,%11100011 + !byte $BF,%11001011 + !byte $07,%00001000 + !byte $7D,%10100001 + !byte $A5,%01100100 + !byte $A5,%10000101; + !byte $A5,%10100101 + !byte $A5,%11000101 + !byte $29,%10100011 + !byte $09,%00001000 + !byte $A5,%01000100 + !byte $05,%00001000 + !byte $2D,%11000011 + !byte $77,%00100000 + !byte $7F,%11100001 + !byte $A5,%11100101 + !byte $81,%01100010 + !byte $81,%10000011; + !byte $A5,%00000110 + !byte $0B,%00001000 + !byte $57,%11100001 + !byte $53,%01100000 + !byte $53,%10000001; + !byte $7B,%01000000 + !byte $A5,%00100100 + !byte $03,%00001000 + !byte $23,%01100010 + !byte $23,%10000011; + !byte $25,%01100010 + !byte $25,%10000011; + !byte $BF,%11101011 + !byte $BD,%00101100 + !byte $0D,%00001000 + !byte $51,%01000000 + !byte $A5,%00100110 + !byte $0F,%00001000 + !byte $4F,%00100000 + !byte $A5,%00000100 + !byte $59,%00000010 + !byte $79,%00100000 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $81,%01000010 + !byte $11,%00001000 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $55,%10100001 + !byte $A5,%01000110 + !byte $7F,%11000001 + !byte $2B,%10100011 + !byte $01,%00001000 + !byte $31,%11100011 + !byte $27,%01100010 + !byte $27,%10000011; + !byte $57,%11000001 + !byte $81,%00100010 + !byte $BF,%00001100 + !byte $2F,%11000011 + !byte $A3,%11000011 + !byte $05,%11100111 + !byte $07,%11100111 + !byte $09,%11100111 + !byte $0B,%11100111 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $33,%11100011 + !byte $53,%01000000 + !byte $59,%11100001 + !byte $7F,%10100001 + !byte $81,%00000010 + !byte $4D,%00000000 + !byte $51,%00100000 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $83,%10100011 + !byte $A5,%11100011 + !byte $0D,%11100111 + !byte $4B,%00000000 + !byte $A7,%01000100 + !byte $A7,%01100100 + !byte $A7,%10000101; + !byte $A7,%10100101 + !byte $03,%11100111 + !byte $2D,%10100011 + !byte $A7,%11000101 + !byte $7B,%00100000 + !byte $7D,%01000000 + !byte $0F,%11100111 + !byte $57,%10100001 + !byte $81,%11100001 + !byte $A7,%00100100 + !byte $31,%11000011 + !byte $4F,%00000000 + !byte $83,%01100010 + !byte $83,%10000011; + !byte $A7,%11100101 + !byte $23,%01000010 + !byte $25,%01000010 + !byte $5B,%00000010 + !byte $A7,%00000110 + !byte $BF,%00101100 + !byte $11,%11100111 + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $A7,%00100110 + !byte $83,%01000010 + !byte $A7,%01000110 + !byte $27,%01000010 + !byte $A7,%00000100 + !byte $2F,%10100011 + !byte $53,%00100000 + !byte $81,%11000001 + !byte $01,%11100111 + !byte $59,%11000001 + !byte $A7,%01100110 + !byte $A7,%10000111; + !byte $55,%01000000 + !byte $83,%00100010 + !byte $07,%11000111 + !byte $09,%11000111 + !byte $21,%01000010 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $BF,%01001100 + !byte $29,%01000010 + !byte $51,%00000000 + !byte $81,%10100001 + !byte $0B,%11000111 + !byte $57,%01100000 + !byte $57,%10000001; + !byte $7D,%00100000 + !byte $05,%11000111 + !byte $33,%11000011 + !byte $7F,%01000000 + !byte $5B,%11100001 + !byte $0D,%11000111 + !byte $83,%00000010 + !byte $A7,%11100011 + !byte $03,%11000111 + !byte $59,%10100001 + !byte $31,%10100011 + !byte $85,%10100011 + !byte $0F,%11000111 + !byte $55,%00100000 + !byte $2B,%01000010 + !byte $A9,%01000100 + !byte $A9,%01100100 + !byte $A9,%10000101; + !byte $A9,%10100101 + !byte $53,%00000000 + !byte $83,%11100001 + !byte $A9,%11000101 + !byte $11,%11000111 + !byte $81,%01100000 + !byte $81,%10000001; + !byte $85,%01100010 + !byte $85,%10000011; + !byte $A9,%00000110 + !byte $25,%00100010 + !byte $27,%00100010 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $5B,%11000001 + !byte $A9,%00100100 + !byte $57,%01000000 + !byte $A5,%11000011 + !byte $A9,%11100101 + !byte $13,%11000111 + !byte $23,%00100010 + !byte $A9,%00100110 + !byte $01,%11000111 + !byte $83,%11000001 + !byte $29,%00100010 + !byte $85,%01000010 + !byte $59,%01100000 + !byte $59,%10000001; + !byte $A9,%01000110 + !byte $2D,%01000010 + !byte $7F,%00100000 + !byte $A9,%00000100 + !byte $33,%10100011 + !byte $5D,%11100001 + !byte $81,%01000000 + !byte $85,%00100010 + !byte $07,%10100111 + !byte $09,%10100111 + !byte $0B,%10100111 + !byte $A9,%01100110 + !byte $A9,%10000111; + !byte $05,%10100111 + !byte $5B,%10100001 + !byte $0D,%10100111 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $83,%10100001 + !byte $55,%00000000 + !byte $03,%10100111 + !byte $2B,%00100010 + !byte $85,%00000010 + !byte $57,%00100000 + !byte $0F,%10100111 + !byte $35,%10100011 + !byte $2F,%01000010 + !byte $AB,%01100100 + !byte $AB,%10000101; + !byte $AB,%10100101 + !byte $25,%00000010 + !byte $27,%00000010 + !byte $59,%01000000 + !byte $AB,%01000100 + !byte $AB,%11000101 + !byte $AB,%11100101 + !byte $11,%10100111 + !byte $87,%10100011 + !byte $83,%01100000 + !byte $83,%10000001; + !byte $85,%11100001 + !byte $2D,%00100010 + !byte $5D,%11000001 + !byte $87,%01100010 + !byte $87,%10000011; + !byte $AB,%00000110 + !byte $13,%10100111 + !byte $81,%00100000 + !byte $01,%10100111 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $A9,%11100011 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $31,%01000010 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $AB,%00100100 + !byte $57,%00000000 + !byte $AB,%00100110 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $29,%00000010 + !byte $85,%11000001 + !byte $87,%01000010 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $5F,%11100001 + !byte $83,%01000000 + !byte $AB,%01000110 + !byte $59,%00100000 + !byte $87,%00100010 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $2F,%00100010 + !byte $85,%10100001 + !byte $AB,%00000100 + !byte $2B,%00000010 + !byte $5D,%10100001 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $5B,%01000000 + !byte $87,%00000010 + !byte $AB,%01100110 + !byte $AB,%10000111; + !byte $35,%01100010 + !byte $35,%10000011; + !byte $AB,%10100111 + !byte $5F,%11000001 + !byte $7F,%00000000 + !byte $85,%01100000 + !byte $85,%10000001; + !byte $11,%01100110 + !byte $11,%10000111; + !byte $23,%00000010 + !byte $83,%00100000 + !byte $89,%10100011 + !byte $AD,%01100100 + !byte $AD,%10000101; + !byte $AD,%10100101 + !byte $33,%01000010 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $AD,%11000101 + !byte $2D,%00000010 + !byte $87,%11100001 + !byte $27,%11100001 + !byte $AD,%01000100 + !byte $29,%11100001 + !byte $AD,%11100101 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $31,%00100010 + !byte $59,%00000000 + !byte $05,%01000110 + !byte $07,%01000110 + !byte $09,%01000110 + !byte $0B,%01000110 + !byte $89,%01100010 + !byte $89,%10000011; + !byte $01,%01100110 + !byte $01,%10000111; + !byte $5B,%00100000 + !byte $87,%11000001 + !byte $AD,%00000110 + !byte $0D,%01000110 + !byte $2F,%00000010 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $89,%01000010 + !byte $25,%11100001 + !byte $2B,%11100001 + !byte $AB,%11100011 + !byte $AD,%00100100 + !byte $81,%00000000 + !byte $85,%01000000 + !byte $AD,%00100110 + !byte $0F,%01000110 + !byte $AD,%01000110 + !byte $5F,%10100001 + !byte $87,%10100001 + !byte $03,%01000110 + !byte $5D,%01000000 + !byte $89,%00100010 + !byte $35,%01000010 + !byte $AD,%00000100 + !byte $AD,%01100110 + !byte $AD,%10000111; + !byte $11,%01000110 + !byte $2D,%11100001 + !byte $33,%00100010 + !byte $89,%00000010 + !byte $61,%11000001 + !byte $87,%01100000 + !byte $87,%10000001; + !byte $13,%01000110 + !byte $31,%00000010 + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $85,%00100000 + !byte $5B,%00000000 + !byte $89,%11100001 + !byte $AD,%10100111 + !byte $09,%00100110 + !byte $83,%00000000 + !byte $07,%00100110 + !byte $29,%11000001 + !byte $AF,%01100100 + !byte $AF,%10000101; + !byte $AF,%10100101 + !byte $AF,%11000101 + !byte $0B,%00100110 + !byte $35,%00100010 + !byte $5D,%00100000 + !byte $AF,%00000110 + !byte $05,%00100110 + !byte $0D,%00100110 + !byte $2F,%11100001 + !byte $87,%01000000 + !byte $89,%11000001 + !byte $AF,%01000100 + !byte $27,%11000001 + !byte $37,%01000010 + !byte $AF,%11100101 + !byte $2B,%11000001 + !byte $8B,%01100010 + !byte $8B,%10000011; + !byte $61,%10100001 + !byte $01,%01000110 + !byte $0F,%00100110 + !byte $8B,%01000010 + !byte $AF,%00100100 + !byte $AF,%00100110 + !byte $33,%00000010 + !byte $5F,%01000000 + !byte $03,%00100110 + !byte $89,%10100001 + !byte $2D,%11000001 + !byte $11,%00100110 + !byte $AF,%01000110 + !byte $31,%11100001 + !byte $5D,%00000000 + !byte $8B,%00100010 + !byte $39,%01000010 + !byte $AF,%01100110 + !byte $AF,%10000111; + !byte $87,%00100000 + !byte $13,%00100110 + !byte $37,%00100010 + !byte $89,%01100000 + !byte $89,%10000001; + !byte $61,%01100000 + !byte $61,%10000001; + !byte $85,%00000000 + !byte $8B,%00000010 + !byte $2F,%11000001 + !byte $09,%00000110 + !byte $0B,%00000110 + !byte $8B,%11100001 + !byte $07,%00000110 + !byte $35,%00000010 + !byte $5F,%00100000 + !byte $AF,%10100111 + !byte $05,%00000110 + !byte $15,%00100110 + !byte $29,%10100001 + !byte $2B,%10100001 + !byte $33,%11100001 + !byte $B1,%01100100 + !byte $B1,%10000101; + !byte $B1,%10100101 + !byte $B1,%11000101 + !byte $B1,%11100101 + !byte $0D,%00000110 + !byte $AF,%00000100 + !byte $B1,%01000100 + !byte $B1,%00000110 + !byte $61,%01000000 + !byte $63,%10100001 + !byte $89,%01000000 + !byte $8B,%11000001 + !byte $0F,%00000110 + !byte $25,%11000001 + !byte $8D,%01100010 + !byte $8D,%10000011; + !byte $31,%11000001 + !byte $B1,%00100110 + !byte $2D,%10100001 + !byte $5F,%00000000 + !byte $27,%10100001 + !byte $8D,%01000010 + !byte $11,%00000110 + !byte $87,%00000000 + !byte $8B,%10100001 + !byte $01,%00100110 + !byte $03,%00000110 + !byte $39,%00100010 + !byte $37,%00000010 + !byte $B1,%00100100 + !byte $13,%00000110 + !byte $8D,%00100010 + !byte $B1,%01000110 + !byte $35,%11100001 + !byte $07,%11100101 + !byte $09,%11100101 + !byte $2F,%10100001 + !byte $61,%00100000 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $8B,%01100000 + !byte $8B,%10000001; + !byte $B1,%01100110 + !byte $B1,%10000111; + !byte $89,%00100000 + !byte $8D,%00000010 + !byte $0B,%11100101 + !byte $33,%11000001 + !byte $0D,%11100101 + !byte $15,%00000110 + !byte $8D,%11100001 + !byte $31,%10100001 + !byte $B3,%10100101 + !byte $B1,%10100111 + !byte $05,%11100101 + !byte $B3,%11000101 + !byte $0F,%11100101 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $63,%01000000 + !byte $65,%10100001 + !byte $8B,%01000000 + !byte $8D,%11000001 + !byte $B3,%01100100 + !byte $B3,%10000101; + !byte $B3,%11100101 + !byte $B1,%11000111 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $39,%00000010 + !byte $11,%11100101 + !byte $61,%00000000 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $37,%11100001 + !byte $B1,%00000100 + !byte $B3,%01000100 + !byte $B3,%00000110 + !byte $03,%11100101 + !byte $8D,%10100001 + !byte $8F,%01100010 + !byte $8F,%10000011; + !byte $35,%11000001 + !byte $B3,%00100110 + !byte $89,%00000000 + !byte $09,%11000101 + !byte $13,%11100101 + !byte $8F,%01000010 + !byte $B3,%01000110 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $8B,%00100000 + !byte $63,%00100000 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $0B,%11000101 + !byte $33,%10100001 + !byte $8D,%01100000 + !byte $8D,%10000001; + !byte $07,%11000101 + !byte $B3,%01100110 + !byte $B3,%10000111; + !byte $8F,%00100010 + !byte $B3,%00100100 + !byte $0D,%11000101 + !byte $15,%11100101 + !byte $3B,%00000010 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $8F,%00000010 + !byte $05,%11000101 + !byte $0F,%11000101 + !byte $37,%11000001 + !byte $8D,%01000000 + !byte $8F,%11100001 + !byte $B3,%10100111 + !byte $39,%11100001 + !byte $11,%11000101 + !byte $35,%10100001 + !byte $63,%00000000 + !byte $65,%01000000 + !byte $B5,%10100101 + !byte $B5,%11000101 + !byte $B5,%11100101 + !byte $2B,%01000000 + !byte $8B,%00000000 + !byte $B5,%01100100 + !byte $B5,%10000101; + !byte $B5,%00000110 + !byte $2D,%01000000 + !byte $8F,%11000001 + !byte $B3,%11000111 + !byte $2F,%01000000 + !byte $8F,%10100001 + !byte $13,%11000101 + !byte $B5,%00100110 + !byte $33,%01100000 + !byte $33,%10000001; + !byte $3B,%11100001 + !byte $91,%01100010 + !byte $91,%10000011; + !byte $B5,%01000100 + !byte $09,%10100101 + !byte $0B,%10100101 + !byte $39,%11000001 + !byte $65,%00100000 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $8D,%00100000 + !byte $03,%11000101 + !byte $07,%10100101 + !byte $8F,%01100000 + !byte $8F,%10000001; + !byte $91,%01000010 + !byte $0D,%10100101 + !byte $15,%11000101 + !byte $31,%01000000 + !byte $B5,%01000110 + !byte $37,%10100001 + !byte $91,%00100010 + !byte $35,%01100000 + !byte $35,%10000001; + !byte $0F,%10100101 + !byte $B5,%01100110 + !byte $B5,%10000111; + !byte $65,%00000000 + !byte $8F,%01000000 + !byte $B5,%10100111 + !byte $05,%10100101 + !byte $17,%11000101 + !byte $91,%11100001 + !byte $11,%10100101 + !byte $91,%00000010 + !byte $67,%01000000 + !byte $39,%10100001 + !byte $8D,%00000000 + !byte $B5,%00100100 + !byte $B7,%10100101 + !byte $B7,%11000101 + !byte $B7,%11100101 + !byte $2D,%00100000 + !byte $33,%01000000 + !byte $3D,%11100001 + !byte $91,%11000001 + !byte $13,%10100101 + !byte $3B,%11000001 + !byte $B5,%11000111 + !byte $09,%01100100 + !byte $09,%10000101; + !byte $2F,%00100000 + !byte $91,%10100001 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $B7,%01100100 + !byte $B7,%10000101; + !byte $B7,%00000110 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $69,%01100000 + !byte $69,%10000001; + !byte $07,%01100100 + !byte $07,%10000101; + !byte $67,%00100000 + !byte $93,%01100010 + !byte $93,%10000011; + !byte $8F,%00100000 + !byte $B5,%11100111 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $B7,%00100110 + !byte $29,%01000000 + !byte $31,%00100000 + !byte $91,%01100000 + !byte $91,%10000001; + !byte $93,%01000010 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $15,%10100101 + !byte $35,%01000000 + !byte $B7,%01000100 + !byte $B7,%01000110 + !byte $2B,%00100000 + !byte $67,%00000000 + !byte $93,%00100010 + !byte $11,%01100100 + !byte $11,%10000101; + !byte $17,%10100101 + !byte $33,%00100000 + !byte $3D,%11000001 + !byte $91,%01000000 + !byte $B7,%01100110 + !byte $B7,%10000111; + !byte $3B,%10100001 + !byte $93,%00000010 + !byte $03,%10100101 + !byte $05,%01100100 + !byte $05,%10000101; + !byte $13,%01100100 + !byte $13,%10000101; + !byte $69,%01000000 + !byte $93,%11100001 + !byte $B7,%10100111 + !byte $39,%01100000 + !byte $39,%10000001; + !byte $37,%01000000 + !byte $8F,%00000000 + !byte $93,%11000001 + !byte $B9,%11000101 + !byte $B9,%11100101 + !byte $0B,%01000100 + !byte $0D,%01000100 + !byte $2F,%00000000 + !byte $93,%10100001 + !byte $09,%01000100 + !byte $35,%00100000 + !byte $69,%00100000 + !byte $B9,%10100101 + !byte $B9,%00000110 + !byte $B7,%11000111 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $31,%00000000 + !byte $B9,%00100110 + !byte $91,%00100000 + !byte $07,%01000100 + !byte $3D,%10100001 + !byte $B9,%01100100 + !byte $B9,%10000101; + !byte $0F,%01000100 + !byte $93,%01100000 + !byte $93,%10000001; + !byte $95,%01100010 + !byte $95,%10000011; + !byte $B7,%11100111 + !byte $3F,%11000001 + !byte $B9,%01000110 + !byte $2D,%00000000 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $17,%01100100 + !byte $17,%10000101; + !byte $11,%01000100 + !byte $33,%00000000 + !byte $95,%01000010 + !byte $39,%01000000 + !byte $69,%00000000 + !byte $95,%00100010 + !byte $93,%01000000 + !byte $B7,%00100100 + !byte $B9,%01100110 + !byte $B9,%10000111; + !byte $37,%00100000 + !byte $6B,%01000000 + !byte $95,%00000010 + !byte $13,%01000100 + !byte $95,%11100001 + !byte $91,%00000000 + !byte $B9,%01000100 + !byte $35,%00000000 + !byte $3F,%10100001 + !byte $0B,%00100100 + !byte $95,%11000001 + !byte $05,%01000100 + !byte $09,%00100100 + !byte $0D,%00100100 + !byte $B9,%10100111 + !byte $BB,%11000101 + !byte $BB,%11100101 + !byte $B9,%11000111 + !byte $15,%01000100 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $6B,%00100000 + !byte $BB,%00000110 + !byte $0F,%00100100 + !byte $07,%00100100 + !byte $95,%10100001 + !byte $3B,%01000000 + !byte $93,%00100000 + !byte $BB,%10100101 + !byte $39,%00100000 + !byte $95,%01100000 + !byte $95,%10000001; + !byte $11,%00100100 + !byte $BB,%00100110 + !byte $B9,%11100111 + !byte $17,%01000100 + !byte $37,%00000000 + !byte $6B,%00000000 + !byte $97,%01100010 + !byte $97,%10000011; + !byte $BB,%01100100 + !byte $BB,%10000101; + !byte $BB,%01000110 + !byte $97,%01000010 + !byte $95,%01000000 + !byte $97,%00100010 + !byte $BB,%01100110 + !byte $BB,%10000111; + !byte $6D,%01000000 + !byte $13,%00100100 + !byte $19,%01000100 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $B9,%00001000 + !byte $0B,%00000100 + !byte $3D,%01000000 + !byte $41,%10100001 + !byte $93,%00000000 + !byte $97,%00000010 + !byte $BB,%10100111 + !byte $09,%00000100 + !byte $0D,%00000100 + !byte $0F,%00000100 + !byte $3B,%00100000 + !byte $15,%00100100 + !byte $97,%11100001 + !byte $6D,%00100000 + !byte $39,%00000000 + !byte $97,%11000001 + !byte $11,%00000100 + !byte $17,%00100100 + !byte $95,%00100000 + !byte $97,%10100001 + !byte $BB,%11000111 + !byte $05,%00100100 + !byte $07,%00000100 + !byte $BD,%11000101 + !byte $BD,%11100101 + !byte $BD,%00000110 + !byte $41,%01100000 + !byte $41,%10000001; + !byte $97,%01100000 + !byte $97,%10000001; + !byte $BD,%10100101 + !byte $BD,%00100110 + !byte $3F,%01000000 + !byte $13,%00000100 + !byte $6D,%00000000 + !byte $BD,%01000110 + !byte $3D,%00100000 + !byte $99,%10100011 + !byte $BB,%11100111 + !byte $BB,%01000100 + !byte $19,%00100100 + !byte $6F,%01000000 + !byte $99,%01000010 + !byte $BB,%00001000 + !byte $99,%01100010 + !byte $99,%10000011; + !byte $BD,%01100110 + !byte $BD,%10000111; + !byte $3B,%00000000 + !byte $15,%00000100 + !byte $0D,%11100011 + !byte $99,%00100010 + !byte $0B,%11100011 + !byte $97,%01000000 + !byte $BD,%01100100 + !byte $BD,%10000101; + !byte $95,%00000000 + !byte $99,%00000010 + !byte $09,%11100011 + !byte $0F,%11100011 + !byte $6F,%00100000 + !byte $99,%11100001 + !byte $BD,%10100111 + !byte $BD,%11000111 + !byte $11,%11100011 + !byte $17,%00000100 + !byte $99,%11000001 + !byte $41,%01000000 + !byte $3D,%00000000 + !byte $3F,%00100000 + !byte $BF,%11100101 + !byte $43,%01100000 + !byte $43,%10000001; + !byte $97,%00100000 + !byte $99,%10100001 + !byte $BF,%00000110 + !byte $13,%11100011 + !byte $BF,%11000101 + !byte $BF,%00100110 + !byte $BD,%11100111 + !byte $19,%00000100 + !byte $99,%01100000 + !byte $99,%10000001; + !byte $07,%11100011 + !byte $15,%11100011 + !byte $6F,%00000000 + !byte $BF,%01000110 + !byte $9B,%01100010 + !byte $9B,%10000011; + !byte $0B,%11000011 + !byte $0D,%11000011 + !byte $9B,%10100011 + !byte $BF,%10100101 + !byte $BF,%01100110 + !byte $BF,%10000111; + !byte $43,%01000000 + !byte $9B,%00100010 + !byte $41,%00100000 + !byte $99,%01000000 + !byte $9B,%01000010 + !byte $BD,%00001000 + !byte $0F,%11000011 + !byte $1B,%00000100 + !byte $97,%00000000 + !byte $9B,%00000010 + !byte $BF,%10100111 + !byte $09,%11000011 + !byte $3F,%00000000 + !byte $11,%11000011 + !byte $17,%11100011 + !byte $9B,%11100001 + !byte $99,%00100000 + !byte $71,%00100000 + !byte $9B,%11000001 + !byte $BD,%00101000 + !byte $13,%11000011 + !byte $19,%11100011 + !byte $9B,%10100001 + !byte $BF,%11000111 + !byte $15,%11000011 + !byte $71,%00000000 + !byte $41,%00000000 + !byte $9B,%01100000 + !byte $9B,%10000001; + !byte $43,%00100000 + !byte $BF,%11100111 + !byte $0D,%10100011 + !byte $0F,%10100011 + !byte $1B,%11100011 + !byte $BF,%01100100 + !byte $BF,%10000101; + !byte $0B,%10100011 + !byte $45,%01000000 + !byte $11,%10100011 + !byte $17,%11000011 + !byte $9D,%10100011 + !byte $BF,%00001000 + !byte $9B,%01000000 + !byte $9D,%01000010 + !byte $07,%11000011 + !byte $9D,%01100010 + !byte $9D,%10000011; + !byte $99,%00000000 + !byte $9D,%00000010 + !byte $13,%10100011 + !byte $9D,%00100010 + !byte $09,%10100011 + !byte $9D,%11100001 + !byte $19,%11000011 + !byte $73,%00100000 + !byte $BF,%00101000 + !byte $9D,%11000001 + !byte $15,%10100011 + !byte $43,%00000000 + !byte $9D,%10100001 + !byte $9B,%00100000 + !byte $45,%00100000 + !byte $73,%00000000 + !byte $BF,%01001000 + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $1B,%11000011 + !byte $9D,%01100000 + !byte $9D,%10000001; + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $11,%01100010 + !byte $11,%10000011; + !byte $17,%10100011 + !byte $9B,%00000000 + !byte $9F,%10100011 + !byte $9D,%01000000 + !byte $13,%01100010 + !byte $13,%10000011; + !byte $75,%00100000 + !byte $9F,%00000010 + !byte $9F,%00100010 + !byte $19,%10100011 + !byte $1D,%11000011 + !byte $45,%00000000 + !byte $9F,%01000010 + !byte $9F,%01100010 + !byte $9F,%10000011; + !byte $9F,%11100001 + !byte $47,%00100000 + !byte $15,%01100010 + !byte $15,%10000011; + !byte $9D,%00100000 + !byte $9F,%11000001 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $1B,%10100011 + !byte $0F,%01000010 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $9F,%10100001 + !byte $11,%01000010 + !byte $75,%00000000 + !byte $0D,%01000010 + !byte $9F,%01100000 + !byte $9F,%10000001; + !byte $13,%01000010 + !byte $0B,%01000010 + !byte $47,%00000000 + !byte $19,%01100010 + !byte $19,%10000011; + !byte $1D,%10100011 + !byte $9F,%01000000 + !byte $15,%01000010 + !byte $A1,%01100010 + !byte $A1,%10000011; + !byte $A1,%10100011 + !byte $9D,%00000000 + !byte $A1,%00100010 + !byte $A1,%01000010 + !byte $A1,%11100001 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $A1,%00000010 + !byte $A1,%11000001 + !byte $17,%01000010 + !byte $9F,%00100000 + !byte $A1,%10100001 + !byte $0F,%00100010 + !byte $11,%00100010 + !byte $0D,%00100010 + !byte $49,%00000000 + !byte $77,%00000000 + !byte $13,%00100010 + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $A1,%01100000 + !byte $A1,%10000001; + !byte $19,%01000010 + !byte $15,%00100010 + !byte $A1,%01000000 + !byte $A3,%01100010 + !byte $A3,%10000011; + !byte $9F,%00000000 + !byte $0B,%00100010 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $A3,%01000010 + !byte $A3,%11100001 + !byte $A3,%00000010 + !byte $A3,%10100011 + !byte $17,%00100010 + !byte $1B,%01000010 + !byte $A3,%00100010 + !byte $0F,%00000010 + !byte $11,%00000010 + !byte $A1,%00100000 + !byte $A3,%11000001 + !byte $13,%00000010 + !byte $19,%00100010 + !byte $1D,%01000010 + !byte $A3,%10100001 + !byte $79,%00000000 + !byte $0D,%00000010 + !byte $15,%00000010 + !byte $A3,%01100000 + !byte $A3,%10000001; + !byte $1B,%00100010 + !byte $1F,%01000010 + !byte $17,%00000010 + !byte $A3,%01000000 + !byte $A1,%00000000 + !byte $A5,%00100010 + !byte $A5,%01000010 + !byte $A5,%11100001 + !byte $A5,%01100010 + !byte $A5,%10000011; + !byte $A5,%00000010 + !byte $A5,%10100011 + !byte $0F,%11100001 + !byte $11,%11100001 + !byte $13,%11100001 + !byte $19,%00000010 + !byte $1D,%00100010 + !byte $A5,%11000001 + !byte $A5,%10100001 + !byte $7B,%00000000 + !byte $A3,%00100000 + !byte $15,%11100001 + !byte $A5,%01100000 + !byte $A5,%10000001; + !byte $1B,%00000010 + !byte $0B,%00000010 + !byte $17,%11100001 + !byte $1F,%00100010 + !byte $A5,%01000000 + !byte $0D,%11100001 + !byte $11,%11000001 + !byte $13,%11000001 + !byte $19,%11100001 + !byte $1D,%00000010 + !byte $21,%00100010 + !byte $A3,%00000000 + !byte $A7,%00100010 + !byte $A7,%01000010 + !byte $A7,%01100010 + !byte $A7,%10000011; + !byte $A7,%00000010 + !byte $A7,%10100011 + !byte $15,%11000001 + !byte $A7,%11000011 + !byte $0F,%11000001 + !byte $A7,%11000001 + !byte $A7,%11100001 + !byte $1B,%11100001 + !byte $1F,%00000010 + !byte $7D,%00000000 + !byte $A7,%10100001 + !byte $17,%11000001 + !byte $A5,%00100000 + !byte $A7,%01100000 + !byte $A7,%10000001; + !byte $19,%11000001 + !byte $1D,%11100001 + !byte $21,%00000010 + !byte $A7,%01000000 + !byte $11,%10100001 + !byte $A9,%00000010 + !byte $A9,%00100010 + !byte $A9,%01000010 + !byte $13,%10100001 + !byte $15,%10100001 + !byte $A9,%01100010 + !byte $A9,%10000011; + !byte $0D,%11000001 + !byte $A9,%10100011 + !byte $1B,%11000001 + !byte $A9,%11000011 + !byte $1F,%11100001 + !byte $A9,%11000001 + !byte $A9,%11100001 + !byte $0F,%10100001 + !byte $17,%10100001 + !byte $A5,%00000000 + !byte $A7,%00100000 + !byte $A9,%10100001 + !byte $A9,%01100000 + !byte $A9,%10000001; + !byte $19,%10100001 + !byte $1D,%11000001 + !byte $21,%11100001 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $1B,%10100001 + !byte $1F,%11000001 + !byte $A9,%01000000 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $23,%11100001 + !byte $AB,%00000010 + !byte $AB,%00100010 + !byte $AB,%01000010 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $11,%01100000 + !byte $11,%10000001; + !byte $AB,%11100001 + !byte $AB,%01100010 + !byte $AB,%10000011; + !byte $AB,%10100011 + !byte $AB,%11000001 + !byte $1D,%10100001 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $21,%11000001 + !byte $AB,%11000011 + !byte $AB,%10100001 + !byte $A9,%00100000 + !byte $AB,%01100000 + !byte $AB,%10000001; + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $1F,%10100001 + !byte $A7,%00000000 + !byte $13,%01000000 + !byte $15,%01000000 + !byte $23,%11000001 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $AB,%01000000 + !byte $AD,%00000010 + !byte $17,%01000000 + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $AD,%00100010 + !byte $AD,%11000001 + !byte $AD,%01000010 + !byte $AD,%01100010 + !byte $AD,%10000011; + !byte $AD,%11100001 + !byte $AD,%10100011 + !byte $19,%01000000 + !byte $21,%10100001 + !byte $AD,%10100001 + !byte $AD,%11100011 + !byte $11,%01000000 + !byte $AD,%11000011 + !byte $1B,%01000000 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $23,%10100001 + !byte $AD,%01100000 + !byte $AD,%10000001; + !byte $AB,%00100000 + !byte $15,%00100000 + !byte $17,%00100000 + !byte $1D,%01000000 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $13,%00100000 + !byte $19,%00100000 + !byte $AF,%00100010 + !byte $25,%10100001 + !byte $AD,%01000000 + !byte $AF,%00000010 + !byte $AF,%01000010 + !byte $AF,%11000001 + !byte $AF,%11100001 + !byte $AF,%01100010 + !byte $AF,%10000011; + !byte $AF,%10100011 + !byte $AF,%11000011 + !byte $1B,%00100000 + !byte $1F,%01000000 + !byte $AF,%11100011 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $AF,%10100001 + !byte $AF,%01100000 + !byte $AF,%10000001; + !byte $1D,%00100000 + !byte $21,%01000000 + !byte $15,%00000000 + !byte $17,%00000000 + !byte $AD,%00100000 + !byte $19,%00000000 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $1F,%00100000 + !byte $1B,%00000000 + !byte $23,%01000000 + !byte $B1,%00000010 + !byte $B1,%00100010 + !byte $AF,%01000000 + !byte $B1,%10100011 + !byte $B1,%01000010 + !byte $11,%00100000 + !byte $B1,%11100001 + !byte $B1,%01100010 + !byte $B1,%10000011; + !byte $13,%00000000 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $01,%00000110 + !byte $B1,%11000011 + !byte $B1,%11000001 + !byte $1D,%00000000 + !byte $21,%00100000 + !byte $B1,%10100001 + !byte $B1,%11100011 + !byte $25,%01000000 + !byte $B1,%01100000 + !byte $B1,%10000001; + !byte $1F,%00000000 + !byte $23,%00100000 + !byte $B3,%00000010 + !byte $B3,%00100010 + !byte $27,%01000000 + !byte $B3,%11100001 + !byte $B3,%01100010 + !byte $B3,%10000011; + !byte $01,%11100101 + !byte $B3,%10100011 + !byte $21,%00000000 + !byte $B3,%01000010 + !byte $AF,%00100000 + !byte $B3,%11000001 + !byte $B1,%01000000 + !byte $B3,%11000011 + !byte $23,%00000000 + !byte $25,%00100000 + !byte $B3,%10100001 + !byte $B3,%11100011 + !byte $B3,%00000100 + !byte $B3,%01100000 + !byte $B3,%10000001; + !byte $27,%00100000 + !byte $B5,%01000010 + !byte $25,%00000000 + !byte $B5,%00000010 + !byte $01,%11000101 + !byte $B5,%00100010 + !byte $B5,%11100001 + !byte $B5,%01100010 + !byte $B5,%10000011; + !byte $B5,%10100011 + !byte $B5,%11000001 + !byte $B5,%11000011 + !byte $B5,%11100011 + !byte $29,%00100000 + !byte $B5,%10100001 + !byte $27,%00000000 + !byte $B3,%01000000 + !byte $B5,%00000100 + !byte $B5,%01100000 + !byte $B5,%10000001; + !byte $01,%10100101 + !byte $29,%00000000 + !byte $B7,%00000010 + !byte $B7,%00100010 + !byte $B7,%01000010 + !byte $B7,%11100001 + !byte $B7,%01100010 + !byte $B7,%10000011; + !byte $B7,%10100011 + !byte $B7,%11000011 + !byte $B7,%11000001 + !byte $B7,%11100011 + !byte $B7,%10100001 + !byte $2B,%00000000 + !byte $B7,%00000100 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $03,%01100100 + !byte $03,%10000101; + !byte $B5,%01000000 + !byte $B9,%00000010 + !byte $B9,%00100010 + !byte $B9,%01000010 + !byte $B7,%01100000 + !byte $B7,%10000001; + !byte $B9,%11100001 + !byte $B9,%01100010 + !byte $B9,%10000011; + !byte $B9,%10100011 + !byte $B9,%11000001 + !byte $B9,%11000011 + !byte $B9,%11100011 + !byte $01,%01000100 + !byte $B9,%00000100 + !byte $B9,%10100001 + !byte $B9,%00100100 + !byte $03,%01000100 + !byte $BB,%01000010 + !byte $BB,%01100010 + !byte $BB,%10000011; + !byte $BB,%00000010 + !byte $BB,%00100010 + !byte $BB,%11100001 + !byte $BB,%10100011 + !byte $B9,%01100000 + !byte $B9,%10000001; + !byte $BB,%11000001 + !byte $BB,%11000011 + !byte $BB,%11100011 + !byte $01,%00100100 + !byte $BB,%00000100 + !byte $03,%00100100 + !byte $BB,%10100001 + !byte $BB,%00100100 + !byte $BD,%00000010 + !byte $BD,%00100010 + !byte $BD,%01000010 + !byte $BD,%01100010 + !byte $BD,%10000011; + !byte $BD,%11100001 + !byte $BD,%10100011 + !byte $01,%00000100 + !byte $BD,%11000011 + !byte $03,%00000100 + !byte $BD,%11000001 + !byte $BD,%11100011 + !byte $05,%00000100 + !byte $BD,%00000100 + !byte $BD,%00100100 + !byte $BB,%01100000 + !byte $BB,%10000001; + !byte $BD,%10100001 + !byte $BD,%01000100 + !byte $BF,%01100010 + !byte $BF,%10000011; + !byte $01,%11100011 + !byte $BF,%00000010 + !byte $BF,%00100010 + !byte $BF,%01000010 + !byte $BF,%10100011 + !byte $03,%11100011 + !byte $BF,%11100001 + !byte $BF,%11000011 + !byte $BF,%11100011 + !byte $BF,%00000100 + !byte $05,%11100011 + !byte $BF,%11000001 + !byte $BF,%00100100 + !byte $01,%11000011 + !byte $BF,%01000100 + !byte $03,%11000011 + !byte $05,%11000011 + !byte $BF,%10100001 + !byte $01,%10100011 + !byte $03,%10100011 + !byte $05,%10100011 + !byte $07,%10100011 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $03,%01100010 + !byte $03,%10000011; + !byte $05,%01100010 + !byte $05,%10000011; + !byte $07,%01100010 + !byte $07,%10000011; + !byte $01,%01000010 + !byte $03,%01000010 + !byte $05,%01000010 + !byte $07,%01000010 + !byte $01,%00100010 + !byte $09,%01000010 + !byte $03,%00100010 + !byte $05,%00100010 + !byte $07,%00100010 + !byte $01,%00000010 + !byte $09,%00100010 + !byte $03,%00000010 + !byte $05,%00000010 + !byte $07,%00000010 + !byte $01,%11100001 + !byte $09,%00000010 + !byte $03,%11100001 + !byte $05,%11100001 + !byte $07,%11100001 + !byte $01,%11000001 + !byte $09,%11100001 + !byte $03,%11000001 + !byte $05,%11000001 + !byte $0B,%11100001 + !byte $07,%11000001 + !byte $01,%10100001 + !byte $03,%10100001 + !byte $09,%11000001 + !byte $0B,%11000001 + !byte $05,%10100001 + !byte $07,%10100001 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $09,%10100001 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $0B,%10100001 + !byte $05,%01100000 + !byte $05,%10000001; + !byte $07,%01100000 + !byte $07,%10000001; + !byte $0D,%10100001 + !byte $01,%01000000 + !byte $09,%01100000 + !byte $09,%10000001; + !byte $03,%01000000 + !byte $05,%01000000 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $07,%01000000 + !byte $01,%00100000 + !byte $03,%00100000 + !byte $09,%01000000 + !byte $05,%00100000 + !byte $0B,%01000000 + !byte $07,%00100000 + !byte $0D,%01000000 + !byte $09,%00100000 + !byte $01,%00000000 + !byte $A9,%00000000 + !byte $03,%00000000 + !byte $0F,%01000000 + !byte $05,%00000000 + !byte $0B,%00100000 + !byte $07,%00000000 + !byte $0D,%00100000 + !byte $09,%00000000 + !byte $0F,%00100000 + !byte $AB,%00000000 + !byte $0B,%00000000 + !byte $0D,%00000000 + !byte $0F,%00000000 + !byte $AD,%00000000 + !byte $11,%00000000 + !byte $AF,%00000000 + !byte $B1,%00100000 + !byte $B1,%00000000 + !byte $B3,%00000000 + !byte $B3,%00100000 + !byte $B5,%00000000 + !byte $B5,%00100000 + !byte $B7,%00000000 + !byte $B7,%01000000 + !byte $B7,%00100000 + !byte $B9,%00100000 + !byte $B9,%01000000 + !byte $B9,%00000000 + !byte $BB,%00100000 + !byte $BB,%00000000 + !byte $BB,%01000000 + !byte $BD,%00000000 + !byte $BD,%00100000 + !byte $BD,%01100000 + !byte $BD,%10000001; + !byte $BD,%01000000 + !byte $BF,%00000000 + !byte $BF,%01000000 + !byte $BF,%00100000 + !byte $BF,%01100000 + !byte $BF,%10000001; diff --git a/src/fx/fx.hgr.wavy.iris.bloom.in.a b/src/fx/fx.hgr.wavy.iris.bloom.in.a new file mode 100644 index 0000000..143bd95 --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.bloom.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/W.IRIS.BLOOM.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.hgr.wavy.iris.data.a b/src/fx/fx.hgr.wavy.iris.data.a new file mode 100644 index 0000000..f3d78e9 --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.data.a @@ -0,0 +1,7683 @@ +!cpu 6502 +!to "build/FX/WAVY.IRIS.DATA",plain +*=$8100 + !byte $5F,%11110011 + !byte $61,%11110011 + !byte $5D,%11110011 + !byte $5F,%11010011 + !byte $61,%11010011 + !byte $5D,%11010011 + !byte $63,%11110011 + !byte $5B,%11110011 + !byte $63,%11010011 + !byte $5F,%10110011 + !byte $5D,%10110011 + !byte $61,%10110011 + !byte $5B,%11010011 + !byte $65,%11110011 + !byte $5B,%10110011 + !byte $59,%11010011 + !byte $5F,%01110010 + !byte $5F,%10010011; + !byte $59,%11110011 + !byte $5D,%01110010 + !byte $5D,%10010011; + !byte $63,%10110011 + !byte $65,%10110011 + !byte $65,%11010011 + !byte $63,%01110010 + !byte $63,%10010011; + !byte $61,%01110010 + !byte $61,%10010011; + !byte $67,%11110011 + !byte $57,%11110011 + !byte $5B,%01110010 + !byte $5B,%10010011; + !byte $5F,%01010010 + !byte $5D,%01010010 + !byte $57,%11010011 + !byte $59,%01110010 + !byte $59,%10010011; + !byte $59,%10110011 + !byte $67,%11010011 + !byte $61,%01010010 + !byte $63,%01010010 + !byte $57,%10110011 + !byte $65,%01110010 + !byte $65,%10010011; + !byte $67,%10110011 + !byte $55,%11110011 + !byte $67,%01110010 + !byte $67,%10010011; + !byte $5B,%01010010 + !byte $5F,%00110010 + !byte $69,%11010011 + !byte $59,%01010010 + !byte $5D,%00110010 + !byte $61,%00110010 + !byte $69,%11110011 + !byte $5B,%00110010 + !byte $55,%10110011 + !byte $65,%01010010 + !byte $63,%00110010 + !byte $65,%00110010 + !byte $55,%11010011 + !byte $57,%01010010 + !byte $61,%00010010 + !byte $53,%11110011 + !byte $5F,%00010010 + !byte $57,%01110010 + !byte $57,%10010011; + !byte $5B,%00010010 + !byte $6B,%11010011 + !byte $67,%01010010 + !byte $69,%01110010 + !byte $69,%10010011; + !byte $57,%00110010 + !byte $5D,%00010010 + !byte $55,%01110010 + !byte $55,%10010011; + !byte $69,%01010010 + !byte $69,%10110011 + !byte $59,%00110010 + !byte $65,%00010010 + !byte $61,%11110001 + !byte $53,%10110011 + !byte $53,%01110010 + !byte $53,%10010011; + !byte $6B,%11110011 + !byte $6B,%10110011 + !byte $5F,%11110001 + !byte $51,%11110011 + !byte $5B,%11110001 + !byte $63,%00010010 + !byte $53,%11010011 + !byte $6D,%11010011 + !byte $57,%00010010 + !byte $55,%00110010 + !byte $6D,%10110011 + !byte $65,%11110001 + !byte $67,%00110010 + !byte $69,%00110010 + !byte $5D,%11110001 + !byte $61,%11010001 + !byte $6B,%01010010 + !byte $55,%00010010 + !byte $67,%00010010 + !byte $59,%00010010 + !byte $55,%01010010 + !byte $6B,%00110010 + !byte $51,%01110010 + !byte $51,%10010011; + !byte $5B,%11010001 + !byte $67,%11110001 + !byte $5F,%11010001 + !byte $4F,%11110011 + !byte $53,%01010010 + !byte $51,%11010011 + !byte $59,%11110001 + !byte $6B,%01110010 + !byte $6B,%10010011; + !byte $51,%01010010 + !byte $6D,%11110011 + !byte $63,%11110001 + !byte $51,%10110011 + !byte $6F,%10110011 + !byte $59,%11010001 + !byte $61,%10110001 + !byte $55,%11110001 + !byte $67,%11010001 + !byte $6F,%11010011 + !byte $65,%11010001 + !byte $5D,%11010001 + !byte $4F,%11010011 + !byte $5B,%10110001 + !byte $5F,%10110001 + !byte $57,%11110001 + !byte $6B,%00010010 + !byte $6D,%00110010 + !byte $6D,%01110010 + !byte $6D,%10010011; + !byte $63,%11010001 + !byte $59,%10110001 + !byte $4F,%01010010 + !byte $4D,%11110011 + !byte $53,%00010010 + !byte $53,%11110001 + !byte $69,%00010010 + !byte $6D,%00010010 + !byte $4F,%01110010 + !byte $4F,%10010011; + !byte $61,%01110000 + !byte $61,%10010001; + !byte $6D,%01010010 + !byte $6F,%01110010 + !byte $6F,%10010011; + !byte $53,%00110010 + !byte $71,%10110011 + !byte $67,%10110001 + !byte $6F,%11110011 + !byte $4D,%11010011 + !byte $63,%10110001 + !byte $53,%11010001 + !byte $55,%11010001 + !byte $69,%11010001 + !byte $69,%11110001 + !byte $59,%01110000 + !byte $59,%10010001; + !byte $51,%00110010 + !byte $5B,%01110000 + !byte $5B,%10010001; + !byte $5F,%01110000 + !byte $5F,%10010001; + !byte $4F,%00110010 + !byte $71,%01110010 + !byte $71,%10010011; + !byte $5D,%10110001 + !byte $69,%10110001 + !byte $71,%11010011 + !byte $4F,%10110011 + !byte $65,%10110001 + !byte $4B,%11110011 + !byte $61,%01010000 + !byte $57,%11010001 + !byte $4D,%01010010 + !byte $6D,%11110001 + !byte $6F,%00010010 + !byte $63,%01110000 + !byte $63,%10010001; + !byte $4D,%00110010 + !byte $6B,%11110001 + !byte $4B,%11010011 + !byte $69,%01110000 + !byte $69,%10010001; + !byte $6F,%11110001 + !byte $67,%01110000 + !byte $67,%10010001; + !byte $73,%10110011 + !byte $6F,%00110010 + !byte $59,%01010000 + !byte $51,%11010001 + !byte $73,%01110010 + !byte $73,%10010011; + !byte $53,%10110001 + !byte $57,%10110001 + !byte $5F,%01010000 + !byte $51,%11110001 + !byte $6F,%01010010 + !byte $4D,%01110010 + !byte $4D,%10010011; + !byte $71,%11110011 + !byte $5B,%01010000 + !byte $51,%00010010 + !byte $51,%10110001 + !byte $63,%01010000 + !byte $61,%00110000 + !byte $5D,%01110000 + !byte $5D,%10010001; + !byte $4D,%10110011 + !byte $57,%01110000 + !byte $57,%10010001; + !byte $49,%11110011 + !byte $55,%10110001 + !byte $73,%11010011 + !byte $4B,%00110010 + !byte $71,%01010010 + !byte $49,%11010011 + !byte $4D,%00010010 + !byte $4F,%00010010 + !byte $57,%01010000 + !byte $59,%00110000 + !byte $69,%01010000 + !byte $6B,%11010001 + !byte $6F,%11010001 + !byte $65,%01110000 + !byte $65,%10010001; + !byte $71,%11110001 + !byte $4B,%01010010 + !byte $75,%01110010 + !byte $75,%10010011; + !byte $5F,%00110000 + !byte $63,%00110000 + !byte $6B,%10110001 + !byte $6D,%11010001 + !byte $6B,%01110000 + !byte $6B,%10010001; + !byte $71,%00010010 + !byte $73,%01010010 + !byte $75,%10110011 + !byte $4B,%00010010 + !byte $51,%01110000 + !byte $51,%10010001; + !byte $71,%11010001 + !byte $67,%01010000 + !byte $4B,%10110011 + !byte $57,%00110000 + !byte $61,%00010000 + !byte $6B,%01010000 + !byte $73,%11110011 + !byte $53,%01110000 + !byte $53,%10010001; + !byte $5B,%00110000 + !byte $5D,%01010000 + !byte $47,%11110011 + !byte $4F,%10110001 + !byte $75,%01010010 + !byte $47,%11010011 + !byte $4F,%01110000 + !byte $4F,%10010001; + !byte $59,%00010000 + !byte $71,%00110010 + !byte $63,%00010000 + !byte $4F,%11010001 + !byte $69,%00110000 + !byte $4B,%01110010 + !byte $4B,%10010011; + !byte $6B,%00110000 + !byte $4F,%11110001 + !byte $49,%00010010 + !byte $57,%00010000 + !byte $49,%00110010 + !byte $5F,%00010000 + !byte $65,%01010000 + !byte $55,%01110000 + !byte $55,%10010001; + !byte $77,%01110010 + !byte $77,%10010011; + !byte $49,%10110011 + !byte $61,%11101111 + !byte $75,%11010011 + !byte $71,%10110001 + !byte $73,%11010001 + !byte $4F,%01010000 + !byte $51,%01010000 + !byte $6F,%10110001 + !byte $77,%01010010 + !byte $73,%11110001 + !byte $77,%10110011 + !byte $63,%11101111 + !byte $4B,%11110001 + !byte $4D,%11110001 + !byte $5D,%00110000 + !byte $73,%10110001 + !byte $6D,%10110001 + !byte $75,%11110011 + !byte $67,%00110000 + !byte $45,%11110011 + !byte $55,%01010000 + !byte $5B,%00010000 + !byte $49,%01010010 + !byte $57,%11101111 + !byte $45,%11010011 + !byte $49,%11110001 + !byte $6B,%00010000 + !byte $59,%11101111 + !byte $73,%00110010 + !byte $65,%00110000 + !byte $47,%10110011 + !byte $5F,%11101111 + !byte $53,%01010000 + !byte $69,%00010000 + !byte $61,%11001111 + !byte $73,%00010010 + !byte $47,%00010010 + !byte $55,%00110000 + !byte $6D,%01010000 + !byte $6D,%01110000 + !byte $6D,%10010001; + !byte $6D,%00110000 + !byte $79,%01110010 + !byte $79,%10010011; + !byte $4D,%01110000 + !byte $4D,%10010001; + !byte $79,%01010010 + !byte $4D,%01010000 + !byte $75,%00110010 + !byte $63,%11001111 + !byte $47,%11110001 + !byte $49,%01110010 + !byte $49,%10010011; + !byte $4F,%00110000 + !byte $6D,%00010000 + !byte $55,%00010000 + !byte $65,%00010000 + !byte $47,%00110010 + !byte $4D,%10110001 + !byte $57,%11001111 + !byte $73,%01110000 + !byte $73,%10010001; + !byte $5D,%00010000 + !byte $4D,%11010001 + !byte $75,%10110001 + !byte $4D,%00110000 + !byte $71,%01110000 + !byte $71,%10010001; + !byte $77,%00110010 + !byte $77,%11010011 + !byte $43,%11010011 + !byte $45,%10110011 + !byte $6B,%11101111 + !byte $75,%11010001 + !byte $77,%11110011 + !byte $51,%00110000 + !byte $43,%11110011 + !byte $59,%11001111 + !byte $5F,%11001111 + !byte $55,%11101111 + !byte $61,%10101111 + !byte $75,%01110000 + !byte $75,%10010001; + !byte $79,%10110011 + !byte $5B,%11101111 + !byte $6D,%11101111 + !byte $6F,%01110000 + !byte $6F,%10010001; + !byte $67,%00010000 + !byte $63,%10101111 + !byte $79,%00110010 + !byte $4B,%11010001 + !byte $65,%11101111 + !byte $45,%11110001 + !byte $49,%11010001 + !byte $7B,%01010010 + !byte $55,%11001111 + !byte $69,%11101111 + !byte $47,%01110010 + !byte $47,%10010011; + !byte $75,%11110001 + !byte $47,%01010010 + !byte $47,%11010001 + !byte $45,%00010010 + !byte $7B,%01110010 + !byte $7B,%10010011; + !byte $53,%00110000 + !byte $57,%10101111 + !byte $4D,%00010000 + !byte $5D,%11101111 + !byte $75,%00010010 + !byte $43,%10110011 + !byte $4F,%00010000 + !byte $6D,%11001111 + !byte $41,%11010011 + !byte $45,%11010001 + !byte $7B,%00110010 + !byte $41,%11110011 + !byte $4B,%00110000 + !byte $61,%01101110 + !byte $61,%10001111; + !byte $65,%11001111 + !byte $6B,%11001111 + !byte $5F,%10101111 + !byte $55,%10101111 + !byte $4B,%01010000 + !byte $63,%01101110 + !byte $63,%10001111; + !byte $75,%01010000 + !byte $77,%01110000 + !byte $77,%10010001; + !byte $79,%11110011 + !byte $59,%10101111 + !byte $6F,%01010000 + !byte $73,%01010000 + !byte $77,%10110001 + !byte $4B,%00010000 + !byte $79,%11010011 + !byte $5B,%11001111 + !byte $45,%00110010 + !byte $4B,%01110000 + !byte $4B,%10010001; + !byte $6F,%00010000 + !byte $6F,%00110000 + !byte $45,%01110010 + !byte $45,%10010011; + !byte $4B,%10110001 + !byte $6F,%11101111 + !byte $53,%00010000 + !byte $77,%01010000 + !byte $77,%00010010 + !byte $51,%00010000 + !byte $71,%01010000 + !byte $7D,%01010010 + !byte $7B,%10110011 + !byte $67,%11101111 + !byte $57,%01101110 + !byte $57,%10001111; + !byte $41,%10110011 + !byte $43,%11110001 + !byte $5D,%11001111 + !byte $65,%10101111 + !byte $6F,%11001111 + !byte $77,%11010001 + !byte $43,%11010001 + !byte $55,%01101110 + !byte $55,%10001111; + !byte $7D,%00110010 + !byte $4D,%11101111 + !byte $4B,%11101111 + !byte $61,%01001110 + !byte $6D,%10101111 + !byte $79,%00010010 + !byte $7D,%01110010 + !byte $7D,%10010011; + !byte $63,%01001110 + !byte $69,%11001111 + !byte $5F,%01101110 + !byte $5F,%10001111; + !byte $53,%11101111 + !byte $3F,%11010011 + !byte $49,%10110001 + !byte $45,%01010010 + !byte $43,%00010010 + !byte $47,%10110001 + !byte $3F,%11110011 + !byte $6F,%10101111 + !byte $45,%10110001 + !byte $7B,%11110011 + !byte $6B,%10101111 + !byte $43,%01110010 + !byte $43,%10010011; + !byte $77,%11110001 + !byte $53,%11001111 + !byte $59,%01101110 + !byte $59,%10001111; + !byte $7B,%00010010 + !byte $4F,%11101111 + !byte $65,%01101110 + !byte $65,%10001111; + !byte $75,%00110000 + !byte $77,%00110000 + !byte $79,%01010000 + !byte $79,%01110000 + !byte $79,%10010001; + !byte $3F,%10110011 + !byte $43,%10110001 + !byte $5B,%10101111 + !byte $55,%01001110 + !byte $57,%01001110 + !byte $67,%11001111 + !byte $49,%00010000 + !byte $7B,%11010011 + !byte $5D,%10101111 + !byte $7F,%01010010 + !byte $53,%10101111 + !byte $7F,%00110010 + !byte $49,%11101111 + !byte $63,%00101110 + !byte $49,%00110000 + !byte $71,%00110000 + !byte $41,%11010001 + !byte $73,%00110000 + !byte $7D,%00010010 + !byte $61,%00101110 + !byte $79,%00110000 + !byte $6D,%01101110 + !byte $6D,%10001111; + !byte $5F,%01001110 + !byte $4B,%11001111 + !byte $6F,%01101110 + !byte $6F,%10001111; + !byte $41,%01110010 + !byte $41,%10010011; + !byte $79,%10110001 + !byte $7D,%10110011 + !byte $3D,%11010011 + !byte $43,%00110010 + !byte $41,%11110001 + !byte $51,%11101111 + !byte $53,%01101110 + !byte $53,%10001111; + !byte $49,%01110000 + !byte $49,%10010001; + !byte $49,%01010000 + !byte $65,%01001110 + !byte $41,%10110001 + !byte $4D,%11001111 + !byte $49,%11001111 + !byte $3D,%11110011 + !byte $71,%00010000 + !byte $79,%11110001 + !byte $7F,%01110010 + !byte $7F,%10010011; + !byte $69,%10101111 + !byte $55,%00101110 + !byte $7F,%00010010 + !byte $7D,%11110011 + !byte $3D,%10110011 + !byte $71,%11001111 + !byte $71,%11101111 + !byte $59,%01001110 + !byte $67,%10101111 + !byte $43,%01010010 + !byte $53,%01001110 + !byte $57,%00101110 + !byte $71,%10101111 + !byte $5D,%01101110 + !byte $5D,%10001111; + !byte $6B,%01101110 + !byte $6B,%10001111; + !byte $79,%11010001 + !byte $63,%00001110 + !byte $47,%01110000 + !byte $47,%10010001; + !byte $61,%00001110 + !byte $79,%00010000 + !byte $81,%00110010 + !byte $65,%00101110 + !byte $77,%00010000 + !byte $5B,%01101110 + !byte $5B,%10001111; + !byte $7B,%00110000 + !byte $3F,%01110010 + !byte $3F,%10010011; + !byte $41,%00010010 + !byte $71,%01101110 + !byte $71,%10001111; + !byte $7B,%01010000 + !byte $45,%01110000 + !byte $45,%10010001; + !byte $6F,%01001110 + !byte $81,%01010010 + !byte $43,%01110000 + !byte $43,%10010001; + !byte $4F,%11001111 + !byte $5F,%00101110 + !byte $51,%11001111 + !byte $7D,%11010011 + !byte $7B,%11110001 + !byte $3F,%11010001 + !byte $3F,%10110001 + !byte $49,%10101111 + !byte $41,%01110000 + !byte $41,%10010001; + !byte $53,%00101110 + !byte $75,%00010000 + !byte $3B,%11010011 + !byte $4B,%10101111 + !byte $6D,%01001110 + !byte $81,%00010010 + !byte $67,%01101110 + !byte $67,%10001111; + !byte $7B,%00010000 + !byte $47,%11101111 + !byte $47,%11001111 + !byte $7B,%01110000 + !byte $7B,%10010001; + !byte $55,%00001110 + !byte $71,%01001110 + !byte $73,%00010000 + !byte $3B,%10110011 + !byte $3B,%11110011 + !byte $47,%00010000 + !byte $7D,%11110001 + !byte $41,%01010010 + !byte $63,%11101101 + !byte $65,%00001110 + !byte $7F,%10110011 + !byte $7F,%11110011 + !byte $3F,%01110000 + !byte $3F,%10010001; + !byte $5D,%01001110 + !byte $3F,%11110001 + !byte $47,%10101111 + !byte $51,%10101111 + !byte $61,%11101101 + !byte $3D,%01110010 + !byte $3D,%10010011; + !byte $53,%00001110 + !byte $4D,%10101111 + !byte $57,%00001110 + !byte $41,%00110010 + !byte $59,%00101110 + !byte $47,%01010000 + !byte $69,%01101110 + !byte $69,%10001111; + !byte $81,%01110010 + !byte $81,%10010011; + !byte $47,%00110000 + !byte $83,%00110010 + !byte $7F,%11110001 + !byte $5B,%01001110 + !byte $6F,%00101110 + !byte $67,%01001110 + !byte $5F,%00001110 + !byte $7B,%10110001 + !byte $71,%00101110 + !byte $51,%01101110 + !byte $51,%10001111; + !byte $83,%00010010 + !byte $7B,%11010001 + !byte $6B,%01001110 + !byte $79,%11101111 + !byte $7D,%00110000 + !byte $7B,%11101111 + !byte $39,%11010011 + !byte $3D,%10110001 + !byte $49,%01101110 + !byte $49,%10001111; + !byte $73,%11101111 + !byte $7D,%00010000 + !byte $83,%01010010 + !byte $55,%11101101 + !byte $65,%11101101 + !byte $47,%01101110 + !byte $47,%10001111; + !byte $81,%11110001 + !byte $63,%11001101 + !byte $7F,%11010011 + !byte $3F,%01010010 + !byte $3D,%01110000 + !byte $3D,%10010001; + !byte $39,%10110011 + !byte $51,%01001110 + !byte $77,%11101111 + !byte $4F,%10101111 + !byte $53,%11101101 + !byte $6D,%00101110 + !byte $3D,%11010001 + !byte $45,%01010000 + !byte $73,%11001111 + !byte $3B,%01110010 + !byte $3B,%10010011; + !byte $3F,%00010010 + !byte $73,%01101110 + !byte $73,%10001111; + !byte $73,%10101111 + !byte $7D,%01010000 + !byte $4B,%01101110 + !byte $4B,%10001111; + !byte $61,%11001101 + !byte $7D,%11101111 + !byte $39,%11110011 + !byte $41,%01010000 + !byte $43,%01010000 + !byte $73,%01001110 + !byte $67,%00101110 + !byte $5D,%00101110 + !byte $75,%11101111 + !byte $3F,%01010000 + !byte $51,%00101110 + !byte $81,%11110011 + !byte $45,%10101111 + !byte $57,%11101101 + !byte $5F,%11101101 + !byte $45,%11001111 + !byte $71,%00001110 + !byte $83,%11110001 + !byte $85,%00010010 + !byte $59,%00001110 + !byte $73,%00101110 + !byte $7D,%11010001 + !byte $85,%00110010 + !byte $81,%10110011 + !byte $65,%11001101 + !byte $69,%01001110 + !byte $6F,%00001110 + !byte $45,%01101110 + !byte $45,%10001111; + !byte $5B,%00101110 + !byte $3D,%01010000 + !byte $45,%11101111 + !byte $51,%00001110 + !byte $7D,%01110000 + !byte $7D,%10010001; + !byte $3F,%00110010 + !byte $53,%11001101 + !byte $83,%01110010 + !byte $83,%10010011; + !byte $3D,%01010010 + !byte $55,%11001101 + !byte $37,%11010011 + !byte $47,%01001110 + !byte $63,%10101101 + !byte $39,%01110010 + !byte $39,%10010011; + !byte $67,%00001110 + !byte $4D,%01101110 + !byte $4D,%10001111; + !byte $37,%10110011 + !byte $3D,%11110001 + !byte $45,%00110000 + !byte $73,%00001110 + !byte $3B,%01110000 + !byte $3B,%10010001; + !byte $45,%00010000 + !byte $7B,%11001111 + !byte $49,%01001110 + !byte $7D,%11001111 + !byte $7F,%00010000 + !byte $7F,%11010001 + !byte $3B,%10110001 + !byte $61,%10101101 + !byte $6B,%00101110 + !byte $85,%01010010 + !byte $4F,%01101110 + !byte $4F,%10001111; + !byte $7F,%11101111 + !byte $85,%11110001 + !byte $45,%01001110 + !byte $51,%11101101 + !byte $5D,%00001110 + !byte $7D,%10110001 + !byte $81,%11010011 + !byte $37,%11110011 + !byte $79,%11001111 + !byte $65,%10101101 + !byte $3B,%01010000 + !byte $5F,%11001101 + !byte $6D,%00001110 + !byte $7F,%00110000 + !byte $71,%11101101 + !byte $75,%11001111 + !byte $83,%11110011 + !byte $67,%11101101 + !byte $7F,%11001111 + !byte $81,%11010001 + !byte $3B,%01010010 + !byte $57,%11001101 + !byte $69,%00101110 + !byte $3B,%11010001 + !byte $51,%11001101 + !byte $73,%11101101 + !byte $77,%11001111 + !byte $87,%00010010 + !byte $53,%10101101 + !byte $43,%00110000 + !byte $63,%01101100 + !byte $63,%10001101; + !byte $3D,%00010010 + !byte $59,%11101101 + !byte $87,%00110010 + !byte $4B,%01001110 + !byte $55,%10101101 + !byte $5B,%00001110 + !byte $37,%01110010 + !byte $37,%10010011; + !byte $4F,%01001110 + !byte $6F,%11101101 + !byte $35,%11010011 + !byte $3D,%00110010 + !byte $3F,%00110000 + !byte $41,%00110000 + !byte $87,%11110001 + !byte $35,%10110011 + !byte $83,%11010001 + !byte $3D,%00110000 + !byte $43,%01101110 + !byte $43,%10001111; + !byte $7F,%01010000 + !byte $75,%10101111 + !byte $83,%10110011 + !byte $61,%01101100 + !byte $61,%10001101; + !byte $45,%00101110 + !byte $47,%00101110 + !byte $5D,%11101101 + !byte $43,%10101111 + !byte $43,%01001110 + !byte $65,%01101100 + !byte $65,%10001101; + !byte $67,%11001101 + !byte $39,%01110000 + !byte $39,%10010001; + !byte $75,%00101110 + !byte $75,%01001110 + !byte $75,%01101110 + !byte $75,%10001111; + !byte $85,%01110010 + !byte $85,%10010011; + !byte $3B,%00110000 + !byte $51,%10101101 + !byte $39,%01010000 + !byte $4F,%00101110 + !byte $75,%00001110 + !byte $5F,%10101101 + !byte $35,%11110011 + !byte $39,%01010010 + !byte $7D,%10101111 + !byte $43,%11001111 + !byte $81,%11101111 + !byte $7F,%10110001 + !byte $85,%11010001 + !byte $4D,%01001110 + !byte $69,%00001110 + !byte $73,%11001101 + !byte $7F,%10101111 + !byte $83,%11010011 + !byte $81,%11001111 + !byte $71,%11001101 + !byte $6B,%00001110 + !byte $7B,%10101111 + !byte $49,%00101110 + !byte $3B,%11110001 + !byte $53,%01101100 + !byte $53,%10001101; + !byte $39,%10110001 + !byte $43,%00101110 + !byte $75,%11101101 + !byte $7F,%01110000 + !byte $7F,%10010001; + !byte $87,%01010010 + !byte $43,%00010000 + !byte $63,%01001100 + !byte $81,%00010000 + !byte $85,%11110011 + !byte $35,%01110010 + !byte $35,%10010011; + !byte $4F,%00001110 + !byte $89,%00010010 + !byte $57,%10101101 + !byte $43,%11101111 + !byte $39,%00110000 + !byte $67,%10101101 + !byte $6D,%11101101 + !byte $89,%11110001 + !byte $55,%01101100 + !byte $55,%10001101; + !byte $81,%10101111 + !byte $5B,%11101101 + !byte $65,%01001100 + !byte $79,%10101111 + !byte $87,%11010001 + !byte $33,%10110011 + !byte $33,%11010011 + !byte $51,%01101100 + !byte $51,%10001101; + !byte $3B,%00110010 + !byte $4F,%11101101 + !byte $61,%01001100 + !byte $89,%00110010 + !byte $59,%11001101 + !byte $75,%11001101 + !byte $5D,%11001101 + !byte $77,%10101111 + !byte $81,%10110001 + !byte $45,%00001110 + !byte $6F,%11001101 + !byte $37,%01010010 + !byte $43,%00001110 + !byte $5F,%01101100 + !byte $5F,%10001101; + !byte $69,%11101101 + !byte $4B,%00101110 + !byte $4F,%11001101 + !byte $81,%00110000 + !byte $39,%11010001 + !byte $37,%01010000 + !byte $41,%00010000 + !byte $73,%10101101 + !byte $85,%10110011 + !byte $3B,%00010010 + !byte $47,%00001110 + !byte $53,%01001100 + !byte $63,%00101100 + !byte $33,%11110011 + !byte $37,%01110000 + !byte $37,%10010001; + !byte $4D,%00101110 + !byte $37,%00110000 + !byte $33,%01110010 + !byte $33,%10010011; + !byte $67,%01101100 + !byte $67,%10001101; + !byte $89,%11010001 + !byte $3D,%00010000 + !byte $3F,%00010000 + !byte $41,%01001110 + !byte $51,%01001100 + !byte $71,%10101101 + !byte $83,%10110001 + !byte $85,%11010011 + !byte $3B,%00010000 + !byte $41,%00101110 + !byte $75,%10101101 + !byte $7F,%01101110 + !byte $7F,%10001111; + !byte $41,%01101110 + !byte $41,%10001111; + !byte $4F,%10101101 + !byte $83,%11001111 + !byte $87,%11110011 + !byte $65,%00101100 + !byte $87,%01110010 + !byte $87,%10010011; + !byte $81,%01101110 + !byte $81,%10001111; + !byte $77,%01101110 + !byte $77,%10001111; + !byte $83,%10101111 + !byte $8B,%11110001 + !byte $39,%00010000 + !byte $6B,%11101101 + !byte $7D,%01101110 + !byte $7D,%10001111; + !byte $8B,%00010010 + !byte $61,%00101100 + !byte $81,%01010000 + !byte $39,%00110010 + !byte $57,%01101100 + !byte $57,%10001101; + !byte $55,%01001100 + !byte $35,%01010010 + !byte $81,%01110000 + !byte $81,%10010001; + !byte $41,%00001110 + !byte $69,%11001101 + !byte $83,%11101111 + !byte $89,%01010010 + !byte $31,%10110011 + !byte $5B,%11001101 + !byte $5D,%10101101 + !byte $85,%10110001 + !byte $31,%11010011 + !byte $41,%10101111 + !byte $49,%00001110 + !byte $59,%10101101 + !byte $77,%01001110 + !byte $37,%10110001 + !byte $4F,%01101100 + !byte $4F,%10001101; + !byte $43,%11101101 + !byte $77,%00001110 + !byte $77,%00101110 + !byte $41,%11101111 + !byte $67,%01001100 + !byte $7B,%01101110 + !byte $7B,%10001111; + !byte $39,%11110001 + !byte $5F,%01001100 + !byte $77,%11101101 + !byte $83,%01101110 + !byte $83,%10001111; + !byte $37,%00010000 + !byte $6D,%11001101 + !byte $8B,%11010001 + !byte $63,%00001100 + !byte $45,%11101101 + !byte $4D,%00001110 + !byte $41,%11001111 + !byte $53,%00101100 + !byte $73,%01101100 + !byte $73,%10001101; + !byte $8B,%00110010 + !byte $51,%00101100 + !byte $77,%11001101 + !byte $75,%01101100 + !byte $75,%10001101; + !byte $87,%10110001 + !byte $79,%01101110 + !byte $79,%10001111; + !byte $83,%00010000 + !byte $31,%01110010 + !byte $31,%10010011; + !byte $35,%00110000 + !byte $41,%11101101 + !byte $65,%00001100 + !byte $35,%01010000 + !byte $6F,%10101101 + !byte $4F,%01001100 + !byte $69,%10101101 + !byte $77,%10101101 + !byte $31,%11110011 + !byte $37,%00110010 + !byte $87,%10110011 + !byte $39,%00010010 + !byte $33,%01010010 + !byte $4B,%00001110 + !byte $89,%10110001 + !byte $87,%11010011 + !byte $61,%00001100 + !byte $47,%11101101 + !byte $67,%00101100 + !byte $8D,%11110001 + !byte $89,%11110011 + !byte $4D,%11101101 + !byte $71,%01101100 + !byte $71,%10001101; + !byte $35,%00010000 + !byte $83,%01110000 + !byte $83,%10010001; + !byte $5D,%01101100 + !byte $5D,%10001101; + !byte $2F,%10110011 + !byte $6B,%11001101 + !byte $81,%01001110 + !byte $8D,%00010010 + !byte $35,%01110000 + !byte $35,%10010001; + !byte $3F,%11101111 + !byte $37,%11010001 + !byte $5B,%10101101 + !byte $77,%01101100 + !byte $77,%10001101; + !byte $85,%10101111 + !byte $2F,%11010011 + !byte $57,%01001100 + !byte $55,%00101100 + !byte $89,%01110010 + !byte $89,%10010011; + !byte $7F,%01001110 + !byte $83,%01001110 + !byte $83,%00110000 + !byte $8D,%11010001 + !byte $4F,%00101100 + !byte $85,%01101110 + !byte $85,%10001111; + !byte $3F,%00101110 + !byte $3F,%00001110 + !byte $5F,%00101100 + !byte $63,%11101011 + !byte $85,%11001111 + !byte $51,%00001100 + !byte $39,%11101111 + !byte $3B,%11101111 + !byte $3D,%11101111 + !byte $43,%11001101 + !byte $4D,%11001101 + !byte $75,%01001100 + !byte $59,%01101100 + !byte $59,%10001101; + !byte $41,%11001101 + !byte $53,%00001100 + !byte $65,%11101011 + !byte $69,%01101100 + !byte $69,%10001101; + !byte $3F,%11101101 + !byte $8B,%10110001 + !byte $3F,%01001110 + !byte $73,%01001100 + !byte $79,%01001110 + !byte $8B,%01010010 + !byte $2F,%01110010 + !byte $2F,%10010011; + !byte $7D,%01001110 + !byte $37,%11101111 + !byte $83,%01010000 + !byte $35,%00110010 + !byte $85,%01110000 + !byte $85,%10010001; + !byte $31,%01010010 + !byte $67,%00001100 + !byte $6D,%10101101 + !byte $85,%01001110 + !byte $49,%11101101 + !byte $33,%00110000 + !byte $4D,%10101101 + !byte $2F,%11110011 + !byte $61,%11101011 + !byte $77,%01001100 + !byte $85,%11101111 + !byte $8D,%00110010 + !byte $3F,%01101110 + !byte $3F,%10001111; + !byte $45,%11001101 + !byte $35,%10110001 + !byte $33,%00010000 + !byte $7B,%01001110 + !byte $35,%11101111 + !byte $4F,%00001100 + !byte $37,%00010010 + !byte $3F,%11001101 + !byte $3F,%11001111 + !byte $37,%11110001 + !byte $6F,%01101100 + !byte $6F,%10001101; + !byte $33,%01010000 + !byte $5D,%01001100 + !byte $8F,%11110001 + !byte $3F,%10101111 + !byte $4D,%01101100 + !byte $4D,%10001101; + !byte $69,%01001100 + !byte $79,%00101110 + !byte $8D,%10110001 + !byte $89,%11010011 + !byte $4B,%11101101 + !byte $6B,%10101101 + !byte $8B,%11110011 + !byte $2D,%10110011 + !byte $8F,%11010001 + !byte $5B,%01101100 + !byte $5B,%10001101; + !byte $87,%01110000 + !byte $87,%10010001; + !byte $89,%10110011 + !byte $63,%11001011 + !byte $5F,%00001100 + !byte $51,%11101011 + !byte $55,%00001100 + !byte $2D,%11010011 + !byte $65,%11001011 + !byte $79,%11001101 + !byte $79,%00001110 + !byte $71,%01001100 + !byte $8F,%00010010 + !byte $79,%10101101 + !byte $79,%11101101 + !byte $83,%00101110 + !byte $67,%11101011 + !byte $75,%00101100 + !byte $57,%00101100 + !byte $33,%00110010 + !byte $87,%01101110 + !byte $87,%10001111; + !byte $85,%00010000 + !byte $2D,%01110010 + !byte $2D,%10010011; + !byte $33,%11101111 + !byte $4D,%01001100 + !byte $53,%11101011 + !byte $41,%10101101 + !byte $77,%00101100 + !byte $2F,%01010010 + !byte $81,%00101110 + !byte $47,%11001101 + !byte $79,%01101100 + !byte $79,%10001101; + !byte $87,%01001110 + !byte $4F,%11101011 + !byte $85,%00101110 + !byte $89,%01110000 + !byte $89,%10010001; + !byte $87,%10101111 + !byte $59,%01001100 + !byte $33,%01110000 + !byte $33,%10010001; + !byte $3F,%10101101 + !byte $43,%10101101 + !byte $8B,%01110010 + !byte $8B,%10010011; + !byte $61,%11001011 + !byte $85,%01010000 + !byte $3D,%11001111 + !byte $8F,%10110001 + !byte $4D,%00101100 + !byte $69,%00101100 + !byte $73,%00101100 + !byte $7F,%00101110 + !byte $79,%01001100 + !byte $3D,%11101101 + !byte $4B,%11001101 + !byte $35,%11010001 + !byte $8D,%01010010 + !byte $31,%00010000 + !byte $3D,%00001110 + !byte $35,%00010010 + !byte $5D,%00101100 + !byte $6B,%01101100 + !byte $6B,%10001101; + !byte $2D,%11110011 + !byte $85,%00110000 + !byte $31,%00110000 + !byte $3D,%11001101 + !byte $8B,%01110000 + !byte $8B,%10010001; + !byte $3B,%11001111 + !byte $63,%10101011 + !byte $6D,%01101100 + !byte $6D,%10001101; + !byte $87,%00101110 + !byte $87,%11001111 + !byte $37,%11001111 + !byte $39,%11001111 + !byte $5B,%01001100 + !byte $65,%10101011 + !byte $7B,%00101110 + !byte $8F,%00110010 + !byte $91,%11010001 + !byte $5F,%11101011 + !byte $2B,%10110011 + !byte $31,%00110010 + !byte $4D,%00001100 + !byte $51,%11001011 + !byte $31,%11101111 + !byte $3D,%00101110 + !byte $91,%11110001 + !byte $35,%11001111 + !byte $67,%11001011 + !byte $49,%11001101 + !byte $79,%00101100 + !byte $7D,%00101110 + !byte $8D,%11110011 + !byte $3D,%10101101 + !byte $8B,%11010011 + !byte $4F,%11001011 + !byte $2B,%11010011 + !byte $2D,%01010010 + !byte $77,%00001100 + !byte $8D,%01110000 + !byte $8D,%10010001; + !byte $45,%10101101 + !byte $35,%11110001 + !byte $55,%11101011 + !byte $6F,%01001100 + !byte $2B,%01110010 + !byte $2B,%10010011; + !byte $33,%11001111 + !byte $69,%00001100 + !byte $75,%00001100 + !byte $8B,%10110011 + !byte $3D,%01001110 + !byte $31,%01010000 + !byte $3D,%10101111 + !byte $53,%11001011 + !byte $4B,%10101101 + !byte $91,%10110001 + !byte $87,%01010000 + !byte $3F,%01101100 + !byte $3F,%10001101; + !byte $33,%10110001 + !byte $91,%00010010 + !byte $57,%00001100 + !byte $61,%10101011 + !byte $41,%01101100 + !byte $41,%10001101; + !byte $4D,%11101011 + !byte $85,%00001110 + !byte $3D,%01101110 + !byte $3D,%10001111; + !byte $6B,%01001100 + !byte $71,%00101100 + !byte $87,%11101111 + !byte $59,%00101100 + !byte $83,%00001110 + !byte $89,%01001110 + !byte $79,%00001100 + !byte $67,%10101011 + !byte $33,%00010010 + !byte $7B,%00001110 + !byte $87,%00001110 + !byte $89,%01101110 + !byte $89,%10001111; + !byte $2F,%00110010 + !byte $3D,%01101100 + !byte $3D,%10001101; + !byte $89,%00101110 + !byte $8F,%01110000 + !byte $8F,%10010001; + !byte $5D,%00001100 + !byte $31,%11001111 + !byte $4B,%01101100 + !byte $4B,%10001101; + !byte $63,%01101010 + !byte $63,%10001011; + !byte $65,%01101010 + !byte $65,%10001011; + !byte $69,%11101011 + !byte $2B,%11110011 + !byte $2F,%00010000 + !byte $51,%10101011 + !byte $5F,%11001011 + !byte $8D,%01110010 + !byte $8D,%10010011; + !byte $4F,%10101011 + !byte $73,%00001100 + !byte $81,%00001110 + !byte $43,%01101100 + !byte $43,%10001101; + !byte $2F,%11101111 + !byte $47,%10101101 + !byte $5B,%00101100 + !byte $89,%01010000 + !byte $29,%10110011 + !byte $7B,%11101101 + !byte $93,%11010001 + !byte $2B,%01010010 + !byte $4D,%11001011 + !byte $6D,%01001100 + !byte $87,%00010000 + !byte $8F,%01010010 + !byte $89,%10101111 + !byte $31,%01110000 + !byte $31,%10010001; + !byte $77,%11101011 + !byte $93,%11110001 + !byte $87,%00110000 + !byte $29,%11010011 + !byte $29,%01110010 + !byte $29,%10010011; + !byte $7B,%01101100 + !byte $7B,%10001101; + !byte $7B,%10101101 + !byte $7B,%11001101 + !byte $3B,%10101111 + !byte $4B,%01001100 + !byte $89,%00001110 + !byte $93,%10110001 + !byte $8F,%11110011 + !byte $8D,%11010011 + !byte $33,%11010001 + !byte $3B,%11001101 + !byte $49,%10101101 + !byte $7B,%01001100 + !byte $2F,%00110000 + !byte $3B,%10101101 + !byte $79,%11101011 + !byte $7F,%00001110 + !byte $3B,%11101101 + !byte $91,%01110000 + !byte $91,%10010001; + !byte $6B,%00101100 + !byte $75,%11101011 + !byte $8B,%01010000 + !byte $2F,%11001111 + !byte $91,%00110010 + !byte $53,%10101011 + !byte $55,%11001011 + !byte $7B,%00101100 + !byte $61,%01101010 + !byte $61,%10001011; + !byte $33,%11110001 + !byte $7D,%00001110 + !byte $67,%01101010 + !byte $67,%10001011; + !byte $3F,%01001100 + !byte $31,%00010010 + !byte $69,%11001011 + !byte $39,%10101111 + !byte $3B,%01101100 + !byte $3B,%10001101; + !byte $4B,%00101100 + !byte $5D,%11101011 + !byte $3D,%01001100 + !byte $2D,%00110010 + !byte $35,%10101111 + !byte $37,%10101111 + !byte $63,%01001010 + !byte $65,%01001010 + !byte $57,%11101011 + !byte $8D,%10110011 + !byte $3B,%00001110 + !byte $4D,%10101011 + !byte $6F,%00101100 + !byte $33,%10101111 + !byte $7B,%00001100 + !byte $89,%11001111 + !byte $45,%01101100 + !byte $45,%10001101; + !byte $4F,%01101010 + !byte $4F,%10001011; + !byte $59,%00001100 + !byte $5F,%10101011 + !byte $87,%11101101 + !byte $8D,%01010000 + !byte $93,%00010010 + !byte $31,%10101111 + !byte $41,%01001100 + !byte $51,%01101010 + !byte $51,%10001011; + !byte $8B,%00101110 + !byte $4B,%00001100 + !byte $85,%11101101 + !byte $3B,%00101110 + !byte $71,%00001100 + !byte $93,%01110000 + !byte $93,%10010001; + !byte $5B,%00001100 + !byte $29,%01010010 + !byte $8B,%01001110 + !byte $29,%11110011 + !byte $3B,%01101110 + !byte $3B,%10001111; + !byte $2F,%01010000 + !byte $27,%10110011 + !byte $2D,%11101111 + !byte $3B,%01001100 + !byte $8B,%00001110 + !byte $6B,%00001100 + !byte $89,%11101101 + !byte $95,%11010001 + !byte $77,%11001011 + !byte $31,%10110001 + !byte $79,%11001011 + !byte $95,%10110001 + !byte $7B,%11101011 + !byte $49,%01101100 + !byte $49,%10001101; + !byte $89,%00110000 + !byte $2D,%00010000 + !byte $83,%11101101 + !byte $27,%01110010 + !byte $27,%10010011; + !byte $2D,%11001111 + !byte $2F,%10101111 + !byte $3B,%01001110 + !byte $67,%01001010 + !byte $6D,%00101100 + !byte $8F,%01010000 + !byte $4B,%11101011 + !byte $69,%10101011 + !byte $73,%11101011 + !byte $4D,%01101010 + !byte $4D,%10001011; + !byte $27,%11010011 + !byte $61,%01001010 + !byte $8F,%01110010 + !byte $8F,%10010011; + !byte $91,%11110011 + !byte $2F,%00010010 + !byte $89,%11101111 + !byte $8F,%11010011 + !byte $2B,%00110010 + !byte $47,%01101100 + !byte $47,%10001101; + !byte $7D,%11101101 + !byte $8B,%01101110 + !byte $8B,%10001111; + !byte $95,%11110001 + !byte $53,%01101010 + !byte $53,%10001011; + !byte $65,%00101010 + !byte $43,%01001100 + !byte $55,%10101011 + !byte $5D,%11001011 + !byte $63,%00101010 + !byte $4B,%11001011 + !byte $8B,%11101101 + !byte $81,%11101101 + !byte $31,%11110001 + !byte $3D,%00101100 + !byte $91,%01010010 + !byte $75,%11001011 + !byte $4F,%01001010 + !byte $7B,%11001011 + !byte $89,%00010000 + !byte $6B,%11101011 + !byte $91,%01010000 + !byte $5F,%01101010 + !byte $5F,%10001011; + !byte $95,%01110000 + !byte $95,%10010001; + !byte $31,%11010001 + !byte $3F,%00101100 + !byte $3B,%00101100 + !byte $2D,%00110000 + !byte $2D,%10101111 + !byte $93,%00110010 + !byte $39,%01101110 + !byte $39,%10001111; + !byte $39,%10101101 + !byte $39,%01101100 + !byte $39,%10001101; + !byte $69,%01101010 + !byte $69,%10001011; + !byte $7F,%11101101 + !byte $49,%01001100 + !byte $27,%01010010 + !byte $51,%01001010 + !byte $57,%11001011 + !byte $59,%11101011 + !byte $7D,%11001101 + !byte $8B,%00110000 + !byte $8F,%10110011 + !byte $5B,%11101011 + !byte $2F,%01110000 + !byte $2F,%10010001; + !byte $4D,%01001010 + !byte $8B,%10101111 + !byte $39,%01001100 + !byte $6F,%00001100 + !byte $39,%11001101 + !byte $4B,%10101011 + !byte $67,%00101010 + !byte $25,%10110011 + !byte $79,%10101011 + !byte $27,%11110011 + !byte $95,%00010010 + !byte $25,%01110010 + !byte $25,%10010011; + !byte $7D,%10101101 + !byte $89,%11001101 + !byte $93,%01010000 + !byte $97,%10110001 + !byte $2D,%00010010 + !byte $29,%00110010 + !byte $37,%01101110 + !byte $37,%10001111; + !byte $7D,%00101100 + !byte $7D,%01001100 + !byte $7D,%01101100 + !byte $7D,%10001101; + !byte $87,%11001101 + !byte $8D,%00001110 + !byte $6D,%00001100 + !byte $77,%10101011 + !byte $97,%11010001 + !byte $2B,%11001111 + !byte $39,%11101101 + !byte $45,%01001100 + !byte $2B,%11101111 + !byte $7D,%00001100 + !byte $8D,%00101110 + !byte $41,%00101100 + !byte $61,%00101010 + !byte $31,%01101110 + !byte $31,%10001111; + !byte $33,%01101110 + !byte $33,%10001111; + !byte $35,%01101110 + !byte $35,%10001111; + !byte $65,%00001010 + !byte $6B,%11001011 + !byte $7B,%10101011 + !byte $8B,%11001101 + !byte $8D,%11101101 + !byte $71,%11101011 + !byte $25,%11010011 + !byte $85,%11001101 + !byte $63,%00001010 + !byte $93,%11110011 + !byte $39,%00101100 + !byte $49,%00101100 + !byte $97,%01110000 + !byte $97,%10010001; + !byte $2F,%01101110 + !byte $2F,%10001111; + !byte $8D,%00110000 + !byte $7D,%11101011 + !byte $4B,%01101010 + !byte $4B,%10001011; + !byte $69,%01001010 + !byte $5D,%10101011 + !byte $2B,%10101111 + !byte $2D,%01010000 + !byte $4F,%00101010 + !byte $91,%11010011 + !byte $2F,%11110001 + !byte $8B,%11001111 + !byte $2B,%00010000 + !byte $47,%01001100 + !byte $8D,%01001110 + !byte $97,%11110001 + !byte $39,%01001110 + !byte $39,%00001110 + !byte $5F,%01001010 + !byte $73,%11001011 + !byte $53,%01001010 + !byte $4D,%00101010 + !byte $95,%01010000 + !byte $3B,%00001100 + !byte $91,%01110010 + !byte $91,%10010011; + !byte $67,%00001010 + !byte $25,%01010010 + !byte $2D,%01101110 + !byte $2D,%10001111; + !byte $3D,%00001100 + !byte $55,%01101010 + !byte $55,%10001011; + !byte $7D,%11001011 + !byte $2F,%10110001 + !byte $51,%00101010 + !byte $49,%00001100 + !byte $83,%11001101 + !byte $8B,%00010000 + !byte $39,%00101110 + !byte $5B,%11001011 + !byte $2B,%00010010 + !byte $8D,%11001101 + !byte $8F,%00110000 + !byte $7F,%11001101 + !byte $75,%10101011 + !byte $39,%00001100 + !byte $4B,%01001010 + !byte $27,%00110010 + !byte $59,%11001011 + !byte $57,%10101011 + !byte $79,%01101010 + !byte $79,%10001011; + !byte $8B,%11101111 + !byte $6D,%11101011 + !byte $93,%01010010 + !byte $43,%00101100 + !byte $6B,%10101011 + !byte $23,%10110011 + !byte $3F,%00001100 + !byte $7B,%01101010 + !byte $7B,%10001011; + !byte $7D,%10101011 + !byte $8D,%01101110 + !byte $8D,%10001111; + !byte $23,%01110010 + !byte $23,%10010011; + !byte $2F,%11010001 + !byte $49,%11101011 + !byte $65,%11101001 + !byte $69,%00101010 + !byte $81,%11001101 + !byte $91,%10110011 + !byte $25,%11110011 + !byte $61,%00001010 + !byte $95,%00110010 + !byte $99,%10110001 + !byte $91,%00110000 + !byte $6F,%11101011 + !byte $2B,%01101110 + !byte $2B,%10001111; + !byte $63,%11101001 + !byte $97,%01010000 + !byte $37,%01001100 + !byte $99,%01110000 + !byte $99,%10010001; + !byte $29,%11001111 + !byte $2B,%00110000 + !byte $99,%11010001 + !byte $37,%01001110 + !byte $37,%01101100 + !byte $37,%10001101; + !byte $23,%11010011 + !byte $77,%01101010 + !byte $77,%10001011; + !byte $4F,%00001010 + !byte $89,%10101101 + !byte $8B,%10101101 + !byte $2D,%11110001 + !byte $29,%10101111 + !byte $37,%00101100 + !byte $4D,%00001010 + !byte $67,%11101001 + !byte $5D,%01101010 + !byte $5D,%10001011; + !byte $2D,%01110000 + !byte $2D,%10010001; + !byte $8F,%11101101 + !byte $97,%00010010 + !byte $4B,%00101010 + !byte $49,%11001011 + !byte $8F,%00001110 + !byte $5F,%00101010 + !byte $37,%10101101 + !byte $47,%00101100 + !byte $95,%11110011 + !byte $7F,%10101101 + !byte $29,%11101111 + !byte $7D,%01101010 + !byte $7D,%10001011; + !byte $93,%00110000 + !byte $6B,%01101010 + !byte $6B,%10001011; + !byte $8D,%10101101 + !byte $23,%01010010 + !byte $29,%00010010 + !byte $87,%10101101 + !byte $45,%00101100 + !byte $71,%11001011 + !byte $8F,%11001101 + !byte $8D,%00010000 + !byte $93,%11010011 + !byte $8D,%10101111 + !byte $25,%00110010 + !byte $3B,%11101011 + !byte $53,%00101010 + !byte $41,%00001100 + !byte $37,%00001100 + !byte $39,%11101011 + !byte $8F,%00101110 + !byte $49,%10101011 + !byte $35,%01001110 + !byte $5B,%10101011 + !byte $29,%01101110 + !byte $29,%10001111; + !byte $51,%00001010 + !byte $6D,%11001011 + !byte $31,%01001110 + !byte $33,%01001110 + !byte $99,%11110001 + !byte $69,%00001010 + !byte $37,%11001101 + !byte $55,%01001010 + !byte $2F,%01001110 + !byte $3D,%11101011 + !byte $65,%11001001 + !byte $73,%10101011 + !byte $7B,%01001010 + !byte $93,%01110010 + !byte $93,%10010011; + !byte $7F,%01101100 + !byte $7F,%10001101; + !byte $99,%01010000 + !byte $85,%10101101 + !byte $4B,%00001010 + !byte $59,%10101011 + !byte $2D,%01001110 + !byte $95,%00110000 + !byte $79,%01001010 + !byte $21,%10110011 + !byte $29,%00010000 + !byte $61,%11101001 + !byte $7F,%01001100 + !byte $21,%01110010 + !byte $21,%10010011; + !byte $37,%00101110 + !byte $49,%01101010 + !byte $49,%10001011; + !byte $7F,%00001100 + !byte $8F,%10101101 + !byte $57,%01101010 + !byte $57,%10001011; + !byte $63,%11001001 + !byte $2D,%10110001 + !byte $6B,%01001010 + !byte $7F,%11101011 + !byte $7F,%00101100 + !byte $2B,%01010000 + !byte $37,%11101101 + !byte $9B,%10110001 + !byte $7D,%01001010 + !byte $2D,%11010001 + !byte $9B,%01110000 + !byte $9B,%10010001; + !byte $2B,%11110001 + !byte $2B,%01001110 + !byte $7F,%11001011 + !byte $8D,%11001111 + !byte $23,%11110011 + !byte $4D,%11101001 + !byte $5D,%01001010 + !byte $67,%11001001 + !byte $93,%10110011 + !byte $47,%00001100 + !byte $75,%01101010 + !byte $75,%10001011; + !byte $37,%11101011 + !byte $8F,%01001110 + !byte $8D,%11101111 + !byte $4F,%11101001 + !byte $81,%10101101 + !byte $8F,%00010000 + !byte $27,%00010010 + !byte $95,%01010010 + !byte $37,%00001110 + !byte $6F,%11001011 + !byte $83,%10101101 + !byte $5F,%00001010 + !byte $7F,%10101011 + !byte $49,%01001010 + !byte $97,%00110000 + !byte $27,%10101111 + !byte $21,%11010011 + !byte $21,%01010010 + !byte $43,%00001100 + !byte $69,%11101001 + !byte $9B,%11010001 + !byte $23,%00110010 + !byte $27,%11001111 + !byte $3F,%11101011 + !byte $97,%00110010 + !byte $6D,%10101011 + !byte $27,%01101110 + !byte $27,%10001111; + !byte $29,%01001110 + !byte $77,%01001010 + !byte $8B,%01101100 + !byte $8B,%10001101; + !byte $8D,%01101100 + !byte $8D,%10001101; + !byte $97,%11110011 + !byte $7F,%01101010 + !byte $7F,%10001011; + !byte $91,%11001101 + !byte $95,%11010011 + !byte $4B,%11101001 + !byte $5B,%01101010 + !byte $5B,%10001011; + !byte $9B,%01010000 + !byte $39,%11001011 + !byte $65,%10101001 + !byte $91,%00010000 + !byte $91,%11101101 + !byte $35,%00101100 + !byte $53,%00001010 + !byte $49,%00101010 + !byte $99,%00010010 + !byte $51,%11101001 + !byte $6B,%00101010 + !byte $89,%01101100 + !byte $89,%10001101; + !byte $27,%11101111 + !byte $35,%00001100 + !byte $3B,%11001011 + !byte $7B,%00101010 + !byte $45,%00001100 + !byte $47,%11101011 + !byte $8F,%01101100 + !byte $8F,%10001101; + !byte $8F,%01101110 + !byte $8F,%10001111; + !byte $29,%00110000 + !byte $35,%01001100 + !byte $61,%11001001 + !byte $71,%10101011 + !byte $91,%10101101 + !byte $35,%00101110 + !byte $37,%11001011 + !byte $63,%10101001 + !byte $7D,%00101010 + !byte $99,%00110000 + !byte $91,%00001110 + !byte $67,%10101001 + !byte $1F,%01110010 + !byte $1F,%10010011; + !byte $59,%01101010 + !byte $59,%10001011; + !byte $2B,%01110000 + !byte $2B,%10010001; + !byte $25,%00010010 + !byte $7F,%01001010 + !byte $29,%11110001 + !byte $1F,%10110011 + !byte $35,%11101011 + !byte $4D,%11001001 + !byte $55,%00101010 + !byte $79,%00101010 + !byte $35,%01101100 + !byte $35,%10001101; + !byte $87,%01101100 + !byte $87,%10001101; + !byte $9B,%11110001 + !byte $27,%01001110 + !byte $5D,%00101010 + !byte $81,%01101100 + !byte $81,%10001101; + !byte $93,%00010000 + !byte $57,%01001010 + !byte $4F,%11001001 + !byte $2B,%11010001 + !byte $69,%11001001 + !byte $9D,%01110000 + !byte $9D,%10010001; + !byte $95,%01110010 + !byte $95,%10010011; + !byte $47,%11001011 + !byte $73,%01101010 + !byte $73,%10001011; + !byte $41,%11101011 + !byte $49,%00001010 + !byte $9D,%10110001 + !byte $21,%11110011 + !byte $6D,%01101010 + !byte $6D,%10001011; + !byte $3D,%11001011 + !byte $8F,%11101111 + !byte $1F,%01010010 + !byte $21,%00110010 + !byte $33,%00101110 + !byte $6F,%10101011 + !byte $91,%01101100 + !byte $91,%10001101; + !byte $95,%10110011 + !byte $4B,%11001001 + !byte $35,%10101101 + !byte $8F,%10101111 + !byte $5F,%11101001 + !byte $6B,%00001010 + !byte $2D,%00101110 + !byte $2F,%00101110 + !byte $31,%00101110 + !byte $91,%00101110 + !byte $9D,%01010000 + !byte $1F,%11010011 + !byte $2B,%10110001 + !byte $25,%10101111 + !byte $25,%01101110 + !byte $25,%10001111; + !byte $65,%01101000 + !byte $65,%10001001; + !byte $75,%01001010 + !byte $85,%01101100 + !byte $85,%10001101; + !byte $95,%00010000 + !byte $9B,%00110000 + !byte $2B,%00101110 + !byte $35,%11001011 + !byte $7F,%00101010 + !byte $99,%11110011 + !byte $5B,%01001010 + !byte $9D,%11010001 + !byte $27,%00010000 + !byte $35,%00001110 + !byte $83,%01101100 + !byte $83,%10001101; + !byte $97,%01010010 + !byte $47,%10101011 + !byte $81,%01001100 + !byte $35,%11001101 + !byte $8F,%11001111 + !byte $67,%01101000 + !byte $67,%10001001; + !byte $27,%11110001 + !byte $25,%11001111 + !byte $29,%00101110 + !byte $61,%10101001 + !byte $63,%01101000 + !byte $63,%10001001; + !byte $7D,%00001010 + !byte $97,%11010011 + !byte $49,%11101001 + !byte $7B,%00001010 + !byte $29,%01010000 + !byte $37,%10101011 + !byte $23,%00010010 + !byte $39,%10101011 + !byte $45,%11101011 + !byte $77,%00101010 + !byte $43,%11101011 + !byte $25,%01001110 + !byte $35,%11101101 + !byte $51,%11001001 + !byte $8D,%01001100 + !byte $8F,%01001100 + !byte $97,%00010000 + !byte $69,%10101001 + !byte $6D,%01001010 + !byte $99,%00110010 + !byte $4D,%10101001 + !byte $93,%11001101 + !byte $53,%11101001 + !byte $93,%10101101 + !byte $47,%01101010 + !byte $47,%10001011; + !byte $81,%00101100 + !byte $1D,%01110010 + !byte $1D,%10010011; + !byte $3F,%11001011 + !byte $8B,%01001100 + !byte $1D,%10110011 + !byte $4B,%10101001 + !byte $81,%10101011 + !byte $81,%11001011 + !byte $81,%11101011 + !byte $91,%01001110 + !byte $91,%11101111 + !byte $27,%00101110 + !byte $59,%01001010 + !byte $81,%00001100 + !byte $5D,%00001010 + !byte $6B,%11101001 + !byte $35,%10101011 + !byte $7F,%00001010 + !byte $3B,%10101011 + !byte $55,%00001010 + !byte $9B,%00010010 + !byte $1F,%00110010 + !byte $71,%01101010 + !byte $71,%10001011; + !byte $81,%01101010 + !byte $81,%10001011; + !byte $91,%01001100 + !byte $93,%11101101 + !byte $9D,%00110000 + !byte $29,%11010001 + !byte $4F,%10101001 + !byte $93,%01101100 + !byte $93,%10001101; + !byte $79,%00001010 + !byte $9F,%01110000 + !byte $9F,%10010001; + !byte $49,%11001001 + !byte $6F,%01101010 + !byte $6F,%10001011; + !byte $47,%01001010 + !byte $5F,%11001001 + !byte $1D,%01010010 + !byte $33,%00001100 + !byte $99,%00010000 + !byte $33,%11101011 + !byte $81,%01001010 + !byte $89,%01001100 + !byte $9F,%10110001 + !byte $57,%00101010 + !byte $9F,%01010000 + !byte $1F,%11110011 + !byte $65,%01001000 + !byte $33,%00101100 + !byte $25,%11101111 + !byte $9D,%11110001 + !byte $29,%01110000 + !byte $29,%10010001; + !byte $97,%01110010 + !byte $97,%10010011; + !byte $33,%00001110 + !byte $33,%11001011 + !byte $97,%10110011 + !byte $1D,%11010011 + !byte $27,%00110000 + !byte $67,%01001000 + !byte $6D,%00101010 + !byte $25,%00101110 + !byte $73,%01001010 + !byte $5B,%00101010 + !byte $45,%11001011 + !byte $47,%00101010 + !byte $93,%11101111 + !byte $21,%00010010 + !byte $25,%11110001 + !byte $93,%00001110 + !byte $69,%01101000 + !byte $69,%10001001; + !byte $23,%01101110 + !byte $23,%10001111; + !byte $61,%01101000 + !byte $61,%10001001; + !byte $7D,%11101001 + !byte $81,%00101010 + !byte $6B,%11001001 + !byte $93,%01001100 + !byte $83,%01001100 + !byte $91,%01101110 + !byte $91,%10001111; + !byte $41,%11001011 + !byte $3D,%10101011 + !byte $9B,%11110011 + !byte $33,%01001100 + !byte $63,%01001000 + !byte $23,%10101111 + !byte $29,%10110001 + !byte $23,%01001110 + !byte $87,%01001100 + !byte $4D,%01101000 + !byte $4D,%10001001; + !byte $9B,%00010000 + !byte $37,%01101010 + !byte $37,%10001011; + !byte $7F,%11101001 + !byte $4B,%01101000 + !byte $4B,%10001001; + !byte $7B,%11101001 + !byte $49,%10101001 + !byte $33,%10101011 + !byte $75,%00101010 + !byte $99,%11010011 + !byte $47,%00001010 + !byte $91,%11001111 + !byte $31,%00001110 + !byte $9F,%00110000 + !byte $35,%01101010 + !byte $35,%10001011; + !byte $9F,%11010001 + !byte $1B,%01110010 + !byte $1B,%10010011; + !byte $85,%01001100 + !byte $1D,%00110010 + !byte $51,%10101001 + !byte $81,%00001010 + !byte $39,%01101010 + !byte $39,%10001011; + !byte $5D,%11101001 + !byte $53,%11001001 + !byte $91,%10101111 + !byte $33,%01101100 + !byte $33,%10001101; + !byte $59,%00101010 + !byte $99,%01010010 + !byte $1B,%10110011 + !byte $27,%11010001 + !byte $2B,%00001110 + !byte $2D,%00001110 + !byte $2F,%00001110 + !byte $77,%00001010 + !byte $8F,%00101100 + !byte $43,%11001011 + !byte $95,%11101111 + !byte $29,%00001110 + !byte $45,%10101011 + !byte $6F,%01001010 + !byte $91,%00101100 + !byte $23,%11001111 + !byte $23,%00101110 + !byte $33,%11101101 + !byte $4F,%01101000 + !byte $4F,%10001001; + !byte $6D,%00001010 + !byte $5F,%10101001 + !byte $1B,%01010010 + !byte $25,%00010000 + !byte $65,%00101000 + !byte $95,%01101100 + !byte $95,%10001101; + !byte $95,%10101101 + !byte $93,%00101110 + !byte $A1,%01110000 + !byte $A1,%10010001; + !byte $55,%11101001 + !byte $8D,%00101100 + !byte $A1,%01010000 + !byte $9B,%00110010 + !byte $27,%00001110 + !byte $47,%11101001 + !byte $9D,%00010000 + !byte $1F,%00010010 + !byte $23,%11110001 + !byte $33,%10101101 + !byte $69,%01001000 + !byte $71,%01001010 + !byte $33,%01101010 + !byte $33,%10001011; + !byte $67,%00101000 + !byte $6B,%10101001 + !byte $83,%00101100 + !byte $27,%01010000 + !byte $49,%01101000 + !byte $49,%10001001; + !byte $93,%00101100 + !byte $57,%00001010 + !byte $95,%11001101 + !byte $5B,%00001010 + !byte $1D,%11110011 + !byte $33,%11001101 + !byte $95,%01001100 + !byte $81,%11101001 + !byte $3F,%10101011 + !byte $3B,%01101010 + !byte $3B,%10001011; + !byte $9D,%00010010 + !byte $63,%00101000 + !byte $79,%11101001 + !byte $97,%11101111 + !byte $25,%00001110 + !byte $A1,%10110001 + !byte $61,%01001000 + !byte $8B,%00101100 + !byte $7D,%11001001 + !byte $7F,%11001001 + !byte $1B,%11010011 + !byte $4B,%01001000 + !byte $4D,%01001000 + !byte $99,%01110010 + !byte $99,%10010011; + !byte $99,%10110011 + !byte $47,%11001001 + !byte $A1,%00110000 + !byte $93,%11001111 + !byte $9F,%11110001 + !byte $21,%01001110 + !byte $83,%00001100 + !byte $45,%01101010 + !byte $45,%10001011; + !byte $21,%01101110 + !byte $21,%10001111; + !byte $31,%11101011 + !byte $31,%11001011 + !byte $9D,%11110011 + !byte $5D,%11001001 + !byte $95,%11101101 + !byte $35,%01001010 + !byte $73,%00101010 + !byte $99,%11101111 + !byte $27,%10110001 + !byte $93,%01001110 + !byte $9F,%00010000 + !byte $6D,%11101001 + !byte $25,%11010001 + !byte $31,%10101011 + !byte $83,%11101011 + !byte $1B,%00110010 + !byte $23,%11101111 + !byte $37,%01001010 + !byte $6F,%00101010 + !byte $95,%00101100 + !byte $19,%01110010 + !byte $19,%10010011; + !byte $27,%01110000 + !byte $27,%10010001; + !byte $83,%01101010 + !byte $83,%10001011; + !byte $83,%11001011 + !byte $89,%00101100 + !byte $23,%00001110 + !byte $83,%10101011 + !byte $21,%00101110 + !byte $69,%00101000 + !byte $6B,%01101000 + !byte $6B,%10001001; + !byte $31,%00001100 + !byte $65,%00001000 + !byte $9B,%11010011 + !byte $25,%00110000 + !byte $83,%01001010 + !byte $31,%11101101 + !byte $7B,%11001001 + !byte $81,%11001001 + !byte $21,%11110001 + !byte $21,%10101111 + !byte $49,%01001000 + !byte $59,%00001010 + !byte $67,%00001000 + !byte $19,%10110011 + !byte $33,%01001010 + !byte $41,%10101011 + !byte $5F,%01101000 + !byte $5F,%10001001; + !byte $47,%10101001 + !byte $51,%01101000 + !byte $51,%10001001; + !byte $83,%00101010 + !byte $85,%00101100 + !byte $43,%10101011 + !byte $45,%01001010 + !byte $1D,%00010010 + !byte $31,%01101010 + !byte $31,%10001011; + !byte $4F,%01001000 + !byte $75,%00001010 + !byte $9B,%11101111 + !byte $19,%01010010 + !byte $53,%10101001 + !byte $A1,%11010001 + !byte $87,%00101100 + !byte $93,%01101110 + !byte $93,%10001111; + !byte $A3,%01010000 + !byte $3D,%01101010 + !byte $3D,%10001011; + !byte $9B,%01010010 + !byte $31,%00101100 + !byte $83,%00001010 + !byte $39,%01001010 + !byte $93,%10101111 + !byte $A3,%01110000 + !byte $A3,%10010001; + !byte $5B,%11101001 + !byte $91,%00001100 + !byte $57,%11101001 + !byte $77,%11101001 + !byte $93,%00001100 + !byte $97,%01101100 + !byte $97,%10001101; + !byte $95,%00001110 + !byte $61,%00101000 + !byte $95,%11001111 + !byte $55,%11001001 + !byte $63,%00001000 + !byte $97,%01001100 + !byte $1B,%11110011 + !byte $8F,%00001100 + !byte $2F,%11101101 + !byte $4B,%00101000 + !byte $6D,%11001001 + !byte $71,%00101010 + !byte $7F,%10101001 + !byte $45,%00101010 + !byte $A1,%00010000 + !byte $A3,%00110000 + !byte $21,%00001110 + !byte $47,%01101000 + !byte $47,%10001001; + !byte $6B,%01001000 + !byte $83,%11101001 + !byte $4D,%00101000 + !byte $31,%01001010 + !byte $19,%11010011 + !byte $31,%01001100 + !byte $97,%10101101 + !byte $7D,%10101001 + !byte $2D,%11101101 + !byte $95,%00001100 + !byte $9D,%00110010 + !byte $21,%11001111 + !byte $6F,%00001010 + !byte $9D,%11101111 + !byte $5D,%10101001 + !byte $29,%11101101 + !byte $2B,%11101101 + !byte $27,%11101101 + !byte $31,%11001101 + !byte $A3,%10110001 + !byte $81,%10101001 + !byte $97,%00101100 + !byte $23,%11010001 + !byte $23,%00010000 + !byte $69,%00001000 + !byte $19,%00110010 + !byte $45,%00001010 + !byte $79,%11001001 + !byte $8D,%00001100 + !byte $49,%00101000 + !byte $1F,%11110001 + !byte $1F,%01001110 + !byte $25,%11101101 + !byte $65,%11100111 + !byte $31,%01101100 + !byte $31,%10001101; + !byte $9B,%10110011 + !byte $25,%01010000 + !byte $1F,%00101110 + !byte $9F,%11110011 + !byte $1B,%00010010 + !byte $25,%10110001 + !byte $35,%00101010 + !byte $67,%11100111 + !byte $83,%11001001 + !byte $9F,%00010010 + !byte $85,%00001100 + !byte $17,%01110010 + !byte $17,%10010011; + !byte $33,%00101010 + !byte $43,%01101010 + !byte $43,%10001011; + !byte $95,%00101110 + !byte $97,%11001111 + !byte $31,%10101101 + !byte $5F,%01001000 + !byte $9B,%01110010 + !byte $9B,%10010011; + !byte $3B,%01001010 + !byte $3F,%01101010 + !byte $3F,%10001011; + !byte $97,%11001101 + !byte $47,%01001000 + !byte $1F,%01101110 + !byte $1F,%10001111; + !byte $6D,%10101001 + !byte $9D,%11010011 + !byte $23,%11101101 + !byte $59,%11101001 + !byte $9F,%11101111 + !byte $45,%11101001 + !byte $73,%00001010 + !byte $51,%01001000 + !byte $8B,%00001100 + !byte $A1,%11110001 + !byte $17,%10110011 + !byte $17,%01010010 + !byte $A3,%00010000 + !byte $37,%00101010 + !byte $4F,%00101000 + !byte $7B,%10101001 + !byte $97,%00001100 + !byte $1F,%00001110 + !byte $6B,%00101000 + !byte $25,%01110000 + !byte $25,%10010001; + !byte $5B,%11001001 + !byte $63,%11100111 + !byte $31,%00101010 + !byte $61,%00001000 + !byte $2F,%10101011 + !byte $4B,%00001000 + !byte $A5,%01010000 + !byte $2F,%01101010 + !byte $2F,%10001011; + !byte $41,%01101010 + !byte $41,%10001011; + !byte $95,%10101111 + !byte $2F,%11001011 + !byte $A5,%01110000 + !byte $A5,%10010001; + !byte $45,%11001001 + !byte $6F,%11101001 + !byte $7F,%01101000 + !byte $7F,%10001001; + !byte $83,%10101001 + !byte $21,%11010001 + !byte $21,%11101101 + !byte $53,%01101000 + !byte $53,%10001001; + !byte $99,%11001111 + !byte $A5,%00110000 + !byte $49,%00001000 + !byte $81,%01101000 + !byte $81,%10001001; + !byte $87,%00001100 + !byte $A3,%11010001 + !byte $71,%00001010 + !byte $85,%11101011 + !byte $89,%00001100 + !byte $19,%11110011 + !byte $21,%11101111 + !byte $1D,%11110001 + !byte $55,%10101001 + !byte $69,%11100111 + !byte $1F,%10101111 + !byte $4D,%00001000 + !byte $95,%01001110 + !byte $A1,%11101111 + !byte $75,%11101001 + !byte $2F,%11101011 + !byte $93,%11101011 + !byte $2F,%01001010 + !byte $47,%00101000 + !byte $97,%11101101 + !byte $2F,%11001101 + !byte $43,%01001010 + !byte $5D,%01101000 + !byte $5D,%10001001; + !byte $17,%00110010 + !byte $57,%11001001 + !byte $95,%11101011 + !byte $9D,%01010010 + !byte $65,%11000111 + !byte $6D,%01101000 + !byte $6D,%10001001; + !byte $3D,%01001010 + !byte $7D,%01101000 + !byte $7D,%10001001; + !byte $91,%11101011 + !byte $99,%01001100 + !byte $45,%10101001 + !byte $67,%11000111 + !byte $23,%00110000 + !byte $39,%00101010 + !byte $17,%11010011 + !byte $85,%11001011 + !byte $99,%00101100 + !byte $95,%01101110 + !byte $95,%10001111; + !byte $9B,%11001111 + !byte $19,%00010010 + !byte $2F,%00001100 + !byte $77,%11001001 + !byte $23,%10110001 + !byte $5F,%00101000 + !byte $85,%10101011 + !byte $85,%01001010 + !byte $99,%01101100 + !byte $99,%10001101; + !byte $A5,%00010000 + !byte $15,%01110010 + !byte $15,%10010011; + !byte $1D,%00101110 + !byte $1F,%11101101 + !byte $2F,%00101010 + !byte $33,%00001010 + !byte $85,%00101010 + !byte $97,%11101011 + !byte $9F,%00110010 + !byte $6B,%00001000 + !byte $85,%01101010 + !byte $85,%10001011; + !byte $9D,%10110011 + !byte $85,%00001010 + !byte $A5,%10110001 + !byte $79,%10101001 + !byte $8F,%11101011 + !byte $A1,%11110011 + !byte $83,%01101000 + !byte $83,%10001001; + !byte $1D,%01001110 + !byte $99,%00001100 + !byte $15,%01010010 + !byte $35,%00001010 + !byte $59,%11001001 + !byte $85,%11101001 + !byte $1D,%00001110 + !byte $2D,%11001101 + !byte $31,%00001010 + !byte $6F,%11001001 + !byte $43,%00101010 + !byte $45,%01101000 + !byte $45,%10001001; + !byte $15,%10110011 + !byte $2F,%00101100 + !byte $A3,%11101111 + !byte $1B,%11110001 + !byte $63,%11000111 + !byte $9D,%11001111 + !byte $9D,%01110010 + !byte $9D,%10010011; + !byte $1F,%11010001 + !byte $4B,%11100111 + !byte $97,%10101111 + !byte $1F,%11001111 + !byte $9F,%11010011 + !byte $99,%10101101 + !byte $A1,%00010010 + !byte $4F,%00001000 + !byte $85,%11001001 + !byte $2F,%10101101 + !byte $47,%00001000 + !byte $97,%00001110 + !byte $5B,%10101001 + !byte $49,%11100111 + !byte $23,%01010000 + !byte $27,%11001101 + !byte $2B,%11001101 + !byte $51,%00101000 + !byte $61,%11100111 + !byte $69,%11000111 + !byte $6D,%01001000 + !byte $25,%11001101 + !byte $29,%11001101 + !byte $3F,%01001010 + !byte $81,%01001000 + !byte $8D,%11101011 + !byte $A7,%00110000 + !byte $A7,%01010000 + !byte $7B,%01101000 + !byte $7B,%10001001; + !byte $1D,%01101110 + !byte $1D,%10001111; + !byte $73,%11101001 + !byte $71,%11101001 + !byte $23,%11001101 + !byte $3B,%00101010 + !byte $41,%01001010 + !byte $7F,%01001000 + !byte $21,%00010000 + !byte $2F,%01001100 + !byte $87,%11101011 + !byte $23,%01110000 + !byte $23,%10010001; + !byte $53,%01001000 + !byte $45,%01001000 + !byte $15,%00110010 + !byte $99,%11101011 + !byte $2F,%01101100 + !byte $2F,%10001101; + !byte $4D,%11100111 + !byte $85,%10101001 + !byte $17,%00010010 + !byte $65,%10100111 + !byte $67,%10100111 + !byte $2F,%00001010 + !byte $37,%00001010 + !byte $A3,%11110001 + !byte $9F,%11001111 + !byte $5D,%01001000 + !byte $1D,%11101101 + !byte $A7,%01110000 + !byte $A7,%10010001; + !byte $21,%11001101 + !byte $43,%00001010 + !byte $6B,%11100111 + !byte $83,%01001000 + !byte $17,%11110011 + !byte $57,%10101001 + !byte $99,%11001101 + !byte $A7,%00010000 + !byte $5F,%00001000 + !byte $15,%11010011 + !byte $21,%10110001 + !byte $8B,%11101011 + !byte $97,%00101110 + !byte $55,%01101000 + !byte $55,%10001001; + !byte $6F,%10101001 + !byte $A5,%11101111 + !byte $2D,%01101010 + !byte $2D,%10001011; + !byte $99,%10101111 + !byte $2D,%01001010 + !byte $A5,%11010001 + !byte $47,%11100111 + !byte $89,%11101011 + !byte $95,%11001011 + !byte $85,%01101000 + !byte $85,%10001001; + !byte $2D,%10101011 + !byte $75,%11001001 + !byte $13,%01110010 + !byte $13,%10010011; + !byte $1D,%11010001 + !byte $1F,%11001101 + !byte $7D,%01001000 + !byte $97,%01101110 + !byte $97,%10001111; + !byte $9B,%00101100 + !byte $9F,%01010010 + !byte $45,%00101000 + !byte $93,%11001011 + !byte $97,%11001011 + !byte $A3,%11110011 + !byte $6D,%00101000 + !byte $2D,%00101010 + !byte $43,%11101001 + !byte $63,%10100111 + !byte $69,%10100111 + !byte $9B,%00001100 + !byte $A1,%11001111 + !byte $13,%01010010 + !byte $31,%11101001 + !byte $1D,%10101111 + !byte $59,%10101001 + !byte $9B,%01001100 + !byte $9F,%10110011 + !byte $19,%11110001 + !byte $5B,%01101000 + !byte $5B,%10001001; + !byte $1B,%00101110 + !byte $33,%11101001 + !byte $49,%11000111 + !byte $1F,%11101111 + !byte $1B,%00001110 + !byte $4B,%11000111 + !byte $97,%01001110 + !byte $2D,%11001011 + !byte $87,%11001011 + !byte $2D,%10101101 + !byte $3D,%00101010 + !byte $61,%11000111 + !byte $13,%10110011 + !byte $77,%10101001 + !byte $A1,%11010011 + !byte $71,%11001001 + !byte $A7,%10110001 + !byte $2F,%11101001 + !byte $39,%00001010 + !byte $21,%00110000 + !byte $91,%11001011 + !byte $99,%11001011 + !byte $81,%00101000 + !byte $41,%00101010 + !byte $1B,%01001110 + !byte $9B,%11101011 + !byte $9B,%10101111 + !byte $43,%11001001 + !byte $45,%00001000 + !byte $67,%01100110 + !byte $67,%10000111; + !byte $6B,%11000111 + !byte $A9,%00110000 + !byte $2D,%00001010 + !byte $51,%00001000 + !byte $85,%01001000 + !byte $15,%00010010 + !byte $1B,%11101101 + !byte $79,%01101000 + !byte $79,%10001001; + !byte $99,%11101101 + !byte $65,%01100110 + !byte $65,%10000111; + !byte $A7,%11101111 + !byte $1D,%11001101 + !byte $4F,%11100111 + !byte $6F,%01101000 + !byte $6F,%10001001; + !byte $83,%00101000 + !byte $A1,%00110010 + !byte $35,%11101001 + !byte $A9,%01010000 + !byte $9F,%01110010 + !byte $9F,%10010011; + !byte $13,%00110010 + !byte $47,%11000111 + !byte $9B,%01101100 + !byte $9B,%10001101; + !byte $A3,%11001111 + !byte $2D,%11101011 + !byte $7F,%00101000 + !byte $5D,%00101000 + !byte $A9,%00010000 + !byte $87,%10101011 + !byte $4D,%11000111 + !byte $6D,%00001000 + !byte $73,%11001001 + !byte $53,%00101000 + !byte $21,%01110000 + !byte $21,%10010001; + !byte $8F,%11001011 + !byte $3F,%00101010 + !byte $43,%10101001 + !byte $5F,%11100111 + !byte $A3,%00010010 + !byte $1F,%10110001 + !byte $21,%01010000 + !byte $2B,%10101101 + !byte $7B,%01001000 + !byte $1B,%11010001 + !byte $15,%11110011 + !byte $13,%11010011 + !byte $17,%11110001 + !byte $2D,%00001100 + !byte $87,%01101010 + !byte $87,%10001011; + !byte $69,%01100110 + !byte $69,%10000111; + !byte $9D,%10101111 + !byte $57,%01101000 + !byte $57,%10001001; + !byte $A9,%01110000 + !byte $A9,%10010001; + !byte $2D,%11101001 + !byte $2D,%01101100 + !byte $2D,%10001101; + !byte $9B,%11001011 + !byte $99,%01101110 + !byte $99,%10001111; + !byte $1B,%01101110 + !byte $1B,%10001111; + !byte $63,%01100110 + !byte $63,%10000111; + !byte $1D,%11001111 + !byte $87,%00001010 + !byte $87,%00101010 + !byte $29,%10101101 + !byte $45,%11100111 + !byte $55,%01001000 + !byte $87,%11101001 + !byte $87,%01001010 + !byte $11,%01110010 + !byte $11,%10010011; + !byte $25,%10101101 + !byte $27,%10101101 + !byte $3B,%00001010 + !byte $49,%10100111 + !byte $87,%11001001 + !byte $89,%11001011 + !byte $A5,%11001111 + !byte $A5,%11110001 + !byte $23,%10101101 + !byte $85,%00101000 + !byte $9B,%10101101 + !byte $1B,%11001101 + !byte $8D,%11001011 + !byte $41,%00001010 + !byte $21,%10101101 + !byte $43,%01101000 + !byte $43,%10001001; + !byte $11,%01010010 + !byte $37,%11101001 + !byte $4B,%10100111 + !byte $59,%01101000 + !byte $59,%10001001; + !byte $61,%10100111 + !byte $99,%00001110 + !byte $1F,%00010000 + !byte $2D,%00101100 + !byte $87,%10101001 + !byte $31,%11001001 + !byte $5B,%01001000 + !byte $6B,%10100111 + !byte $A5,%11110011 + !byte $2D,%01001100 + !byte $2F,%11001001 + !byte $97,%10101011 + !byte $71,%10101001 + !byte $75,%10101001 + !byte $A7,%11010001 + !byte $19,%00001110 + !byte $67,%01000110 + !byte $6D,%11100111 + !byte $7D,%00101000 + !byte $8B,%11001011 + !byte $9F,%10101111 + !byte $A9,%11101111 + !byte $1F,%10101101 + !byte $95,%10101011 + !byte $6F,%01001000 + !byte $11,%10110011 + !byte $13,%00010010 + !byte $87,%01101000 + !byte $87,%10001001; + !byte $9D,%00001100 + !byte $A1,%01010010 + !byte $A1,%10110011 + !byte $47,%10100111 + !byte $83,%00001000 + !byte $99,%10101011 + !byte $33,%11001001 + !byte $65,%01000110 + !byte $81,%00001000 + !byte $19,%00101110 + !byte $5D,%00001000 + !byte $9D,%11101011 + !byte $9D,%00101100 + !byte $19,%11101101 + !byte $2B,%01001010 + !byte $2B,%00101010 + !byte $43,%01001000 + !byte $A3,%11010011 + !byte $4F,%11000111 + !byte $AB,%00110000 + !byte $11,%00110010 + !byte $1D,%10110001 + !byte $1D,%10101101 + !byte $99,%00101110 + !byte $99,%01001110 + !byte $A7,%11001111 + !byte $93,%10101011 + !byte $2D,%11001001 + !byte $2B,%01101010 + !byte $2B,%10001011; + !byte $2B,%00001010 + !byte $AB,%00010000 + !byte $45,%11000111 + !byte $77,%01101000 + !byte $77,%10001001; + !byte $19,%11010001 + !byte $87,%01001000 + !byte $A1,%10101111 + !byte $AB,%01010000 + !byte $5F,%11000111 + !byte $69,%01000110 + !byte $4D,%10100111 + !byte $9B,%10101011 + !byte $1F,%01110000 + !byte $1F,%10010001; + !byte $3D,%00001010 + !byte $43,%00101000 + !byte $85,%00001000 + !byte $9B,%11001101 + !byte $A9,%10110001 + !byte $9D,%11001011 + !byte $1B,%10101111 + !byte $19,%11001101 + !byte $41,%11101001 + !byte $9B,%01101110 + !byte $9B,%10001111; + !byte $A1,%01110010 + !byte $A1,%10010011; + !byte $15,%11110001 + !byte $7F,%00001000 + !byte $9D,%01001100 + !byte $51,%11100111 + !byte $73,%10101001 + !byte $2B,%11101001 + !byte $A3,%00110010 + !byte $2B,%01101100 + !byte $2B,%10001101; + !byte $6F,%00101000 + !byte $3F,%00001010 + !byte $1D,%11101111 + !byte $19,%01001110 + !byte $2B,%10101011 + !byte $39,%11101001 + !byte $49,%01100110 + !byte $49,%10000111; + !byte $35,%11001001 + !byte $1F,%00110000 + !byte $6B,%01100110 + !byte $6B,%10000111; + !byte $89,%10101011 + !byte $79,%01001000 + !byte $13,%11110011 + !byte $1B,%10101101 + !byte $63,%01000110 + !byte $91,%10101011 + !byte $5B,%00101000 + !byte $53,%00001000 + !byte $57,%01001000 + !byte $6D,%11000111 + !byte $71,%01101000 + !byte $71,%10001001; + !byte $61,%01100110 + !byte $61,%10000111; + !byte $A3,%10101111 + !byte $87,%00101000 + !byte $4B,%01100110 + !byte $4B,%10000111; + !byte $11,%11010011 + !byte $59,%01001000 + !byte $AB,%11101111 + !byte $47,%01100110 + !byte $47,%10000111; + !byte $0F,%01010010 + !byte $1F,%01010000 + !byte $55,%00101000 + !byte $67,%00100110 + !byte $AB,%01110000 + !byte $AB,%10010001; + !byte $0F,%01110010 + !byte $0F,%10010011; + !byte $43,%00001000 + !byte $45,%10100111 + !byte $A9,%11001111 + !byte $7B,%00101000 + !byte $2B,%11001011 + !byte $2F,%10101001 + !byte $65,%00100110 + !byte $11,%00010010 + !byte $9D,%10101011 + !byte $2B,%11001001 + !byte $41,%11001001 + !byte $9D,%01101100 + !byte $9D,%10001101; + !byte $A5,%00010010 + !byte $83,%11100111 + !byte $1B,%10110001 + !byte $9B,%11101101 + !byte $A7,%11110011 + !byte $5D,%11100111 + !byte $8F,%10101011 + !byte $29,%01101100 + !byte $29,%10001101; + !byte $31,%10101001 + !byte $2D,%10101001 + !byte $9D,%01101110 + !byte $9D,%10001111; + !byte $A7,%11110001 + !byte $17,%11101101 + !byte $81,%11100111 + !byte $0F,%10110011 + !byte $85,%11100111 + !byte $89,%01101010 + !byte $89,%10001011; + !byte $17,%11010001 + !byte $A3,%10110011 + !byte $69,%00100110 + !byte $A5,%10101111 + !byte $13,%11110001 + !byte $17,%00001110 + !byte $A5,%11010011 + !byte $87,%00001000 + !byte $8B,%10101011 + !byte $0F,%00110010 + !byte $43,%11100111 + !byte $7D,%00001000 + !byte $6F,%00001000 + !byte $2B,%11101011 + !byte $19,%01101110 + !byte $19,%10001111; + !byte $19,%10101101 + !byte $99,%01101010 + !byte $99,%10001011; + !byte $2B,%01001100 + !byte $75,%01101000 + !byte $75,%10001001; + !byte $5F,%10100111 + !byte $27,%01101100 + !byte $27,%10001101; + !byte $6B,%01000110 + !byte $AD,%00010000 + !byte $AD,%00110000 + !byte $8D,%10101011 + !byte $97,%01101010 + !byte $97,%10001011; + !byte $A9,%11010001 + !byte $3B,%11101001 + !byte $6D,%10100111 + !byte $9F,%11101011 + !byte $1B,%11001111 + !byte $17,%11001101 + !byte $37,%11001001 + !byte $9B,%01001110 + !byte $9B,%01101010 + !byte $9B,%10001011; + !byte $41,%10101001 + !byte $A3,%01010010 + !byte $1D,%01110000 + !byte $1D,%10010001; + !byte $21,%01101100 + !byte $21,%10001101; + !byte $23,%01101100 + !byte $23,%10001101; + !byte $25,%01101100 + !byte $25,%10001101; + !byte $71,%01001000 + !byte $9F,%11001011 + !byte $1D,%00010000 + !byte $33,%10101001 + !byte $9F,%00001100 + !byte $89,%01001010 + !byte $17,%00101110 + !byte $1F,%01101100 + !byte $1F,%10001101; + !byte $2B,%00001100 + !byte $95,%01101010 + !byte $95,%10001011; + !byte $45,%01100110 + !byte $45,%10000111; + !byte $49,%01000110 + !byte $4F,%10100111 + !byte $63,%00100110 + !byte $73,%01101000 + !byte $73,%10001001; + !byte $9B,%00001110 + !byte $3F,%11101001 + !byte $2B,%00101100 + !byte $4D,%01100110 + !byte $4D,%10000111; + !byte $51,%11000111 + !byte $9F,%01101110 + !byte $9F,%10001111; + !byte $AB,%11001111 + !byte $AD,%01010000 + !byte $47,%01000110 + !byte $1D,%01101100 + !byte $1D,%10001101; + !byte $A7,%10101111 + !byte $AB,%10110001 + !byte $2B,%10101001 + !byte $89,%00101010 + !byte $61,%01000110 + !byte $9D,%10101101 + !byte $AD,%11101111 + !byte $43,%11000111 + !byte $67,%00000110 + !byte $89,%11101001 + !byte $89,%00001010 + !byte $A3,%01110010 + !byte $A3,%10010011; + !byte $11,%11110011 + !byte $89,%11001001 + !byte $89,%10101001 + !byte $5B,%00001000 + !byte $29,%00001010 + !byte $29,%11101001 + !byte $3D,%11101001 + !byte $59,%00101000 + !byte $9B,%00101110 + !byte $29,%00101010 + !byte $7F,%11100111 + !byte $41,%01101000 + !byte $41,%10001001; + !byte $77,%01001000 + !byte $9D,%01101010 + !byte $9D,%10001011; + !byte $9F,%10101011 + !byte $9F,%00101100 + !byte $89,%01101000 + !byte $89,%10001001; + !byte $57,%00101000 + !byte $87,%11100111 + !byte $65,%00000110 + !byte $0F,%11010011 + !byte $15,%11010001 + !byte $4B,%01000110 + !byte $19,%10110001 + !byte $0D,%01010010 + !byte $1B,%01101100 + !byte $1B,%10001101; + !byte $53,%11100111 + !byte $89,%01001000 + !byte $0D,%01110010 + !byte $0D,%10010011; + !byte $17,%10101101 + !byte $6F,%11100111 + !byte $93,%01101010 + !byte $93,%10001011; + !byte $6D,%01100110 + !byte $6D,%10000111; + !byte $0F,%00010010 + !byte $29,%01001010 + !byte $69,%00000110 + !byte $83,%11000111 + !byte $85,%11000111 + !byte $29,%11001001 + !byte $55,%00001000 + !byte $5D,%11000111 + !byte $89,%00101000 + !byte $A1,%01101110 + !byte $A1,%10001111; + !byte $11,%11110001 + !byte $2D,%01101000 + !byte $2D,%10001001; + !byte $6B,%00100110 + !byte $A5,%00110010 + !byte $1D,%00110000 + !byte $17,%01001110 + !byte $0D,%00110010 + !byte $2F,%01101000 + !byte $2F,%10001001; + !byte $79,%00101000 + !byte $A9,%10101111 + !byte $1D,%01010000 + !byte $29,%01001100 + !byte $41,%01001000 + !byte $19,%10101111 + !byte $35,%10101001 + !byte $43,%10100111 + !byte $8B,%01101010 + !byte $8B,%10001011; + !byte $9F,%01001100 + !byte $0D,%10110011 + !byte $19,%01101100 + !byte $19,%10001101; + !byte $AD,%01110000 + !byte $AD,%10010001; + !byte $39,%11001001 + !byte $45,%01000110 + !byte $A9,%11110011 + !byte $1B,%11101111 + !byte $7B,%00001000 + !byte $29,%01101010 + !byte $29,%10001011; + !byte $3F,%11001001 + !byte $5F,%01100110 + !byte $5F,%10000111; + !byte $71,%00101000 + !byte $9D,%01001110 + !byte $15,%11101101 + !byte $9F,%01101010 + !byte $9F,%10001011; + !byte $A7,%00010010 + !byte $9D,%11001101 + !byte $1B,%01110000 + !byte $1B,%10010001; + !byte $2B,%01101000 + !byte $2B,%10001001; + !byte $15,%11001101 + !byte $81,%11000111 + !byte $91,%01101010 + !byte $91,%10001011; + !byte $AF,%00010000 + !byte $29,%10101001 + !byte $AD,%11001111 + !byte $31,%01101000 + !byte $31,%10001001; + !byte $87,%11000111 + !byte $89,%00001000 + !byte $A3,%01101110 + !byte $A3,%10001111; + !byte $A7,%11010011 + !byte $49,%00100110 + !byte $63,%00000110 + !byte $47,%00100110 + !byte $AF,%00110000 + !byte $A5,%10110011 + !byte $73,%01001000 + !byte $75,%01001000 + !byte $41,%00101000 + !byte $15,%00001110 + !byte $67,%11100101 + !byte $6F,%11000111 + !byte $29,%10101011 + !byte $4D,%01000110 + !byte $4F,%01100110 + !byte $4F,%10000111; + !byte $99,%01001010 + !byte $9B,%01001010 + !byte $AF,%11101111 + !byte $A9,%11110001 + !byte $8F,%01101010 + !byte $8F,%10001011; + !byte $A1,%11001011 + !byte $43,%01100110 + !byte $43,%10000111; + !byte $17,%10110001 + !byte $17,%01101100 + !byte $17,%10001101; + !byte $6D,%01000110 + !byte $7D,%11100111 + !byte $8D,%01101010 + !byte $8D,%10001011; + !byte $61,%00100110 + !byte $51,%10100111 + !byte $5B,%11100111 + !byte $9D,%01001010 + !byte $15,%10101101 + !byte $65,%11100101 + !byte $AB,%10101111 + !byte $13,%11010001 + !byte $A1,%11101011 + !byte $41,%00001000 + !byte $27,%01001100 + !byte $0D,%00010010 + !byte $59,%00001000 + !byte $89,%11100111 + !byte $A5,%01101110 + !byte $A5,%10001111; + !byte $A5,%01010010 + !byte $0F,%11110011 + !byte $3B,%11001001 + !byte $69,%11100101 + !byte $A1,%10101011 + !byte $6B,%00000110 + !byte $97,%01001010 + !byte $9D,%11101101 + !byte $37,%10101001 + !byte $45,%00100110 + !byte $4B,%00100110 + !byte $0B,%01010010 + !byte $29,%00101100 + !byte $8B,%01001010 + !byte $AF,%01010000 + !byte $AB,%11010001 + !byte $57,%00001000 + !byte $17,%01101110 + !byte $17,%10001111; + !byte $29,%01101000 + !byte $29,%10001001; + !byte $3D,%11001001 + !byte $9F,%01101100 + !byte $9F,%10001101; + !byte $A5,%01110010 + !byte $A5,%10010011; + !byte $3F,%10101001 + !byte $0B,%01110010 + !byte $0B,%10010011; + !byte $29,%11001011 + !byte $15,%00101110 + !byte $9D,%00101110 + !byte $33,%01101000 + !byte $33,%10001001; + !byte $7F,%11000111 + !byte $85,%10100111 + !byte $A1,%00001100 + !byte $0F,%11110001 + !byte $5D,%10100111 + !byte $25,%01001100 + !byte $71,%00001000 + !byte $77,%00101000 + !byte $9F,%01001110 + !byte $0D,%11010011 + !byte $53,%11000111 + !byte $83,%10100111 + !byte $19,%11001111 + !byte $1B,%00010000 + !byte $41,%11100111 + !byte $0B,%00110010 + !byte $6F,%10100111 + !byte $AD,%10110001 + !byte $9F,%01001010 + !byte $A1,%01101010 + !byte $A1,%10001011; + !byte $AF,%11001111 + !byte $1D,%01001100 + !byte $1F,%01001100 + !byte $21,%01001100 + !byte $23,%01001100 + !byte $87,%10100111 + !byte $9D,%00001110 + !byte $29,%11101011 + !byte $2D,%01001000 + !byte $55,%11100111 + !byte $5F,%01000110 + !byte $1B,%01010000 + !byte $29,%00001100 + !byte $95,%01001010 + !byte $2B,%01001000 + !byte $A7,%01101110 + !byte $A7,%10001111; + !byte $19,%01110000 + !byte $19,%10010001; + !byte $43,%01000110 + !byte $89,%11000111 + !byte $1B,%01001100 + !byte $27,%11101001 + !byte $AD,%10101111 + !byte $27,%11001001 + !byte $47,%00000110 + !byte $6D,%00100110 + !byte $8B,%00101010 + !byte $0B,%10110011 + !byte $15,%01101100 + !byte $15,%10001101; + !byte $AB,%11110011 + !byte $2F,%01001000 + !byte $27,%00001010 + !byte $A7,%00110010 + !byte $11,%11010001 + !byte $41,%11000111 + !byte $49,%00000110 + !byte $63,%11100101 + !byte $13,%11001101 + !byte $67,%11000101 + !byte $B1,%00010000 + !byte $A1,%00101100 + !byte $9F,%10101101 + !byte $1B,%00110000 + !byte $19,%01001100 + !byte $73,%00101000 + !byte $79,%00001000 + !byte $15,%10110001 + !byte $27,%10101001 + !byte $6B,%11100101 + !byte $13,%11101101 + !byte $3F,%01101000 + !byte $3F,%10001001; + !byte $93,%01001010 + !byte $B1,%11101111 + !byte $A7,%10110011 + !byte $81,%10100111 + !byte $A1,%01001110 + !byte $45,%00000110 + !byte $65,%11000101 + !byte $5B,%11000111 + !byte $69,%11000101 + !byte $8B,%00001010 + !byte $AF,%01110000 + !byte $AF,%10010001; + !byte $61,%00000110 + !byte $A9,%11010011 + !byte $29,%01001000 + !byte $35,%01101000 + !byte $35,%10001001; + !byte $A9,%01101110 + !byte $A9,%10001111; + !byte $B1,%00110000 + !byte $13,%10101101 + !byte $27,%00101010 + !byte $A1,%01001010 + !byte $39,%10101001 + !byte $4D,%00100110 + !byte $15,%01001110 + !byte $75,%00101000 + !byte $8B,%01101000 + !byte $8B,%10001001; + !byte $8B,%11101001 + !byte $A9,%00010010 + !byte $8D,%01001010 + !byte $4F,%01000110 + !byte $71,%11100111 + !byte $7B,%11100111 + !byte $17,%01001100 + !byte $31,%01001000 + !byte $89,%10100111 + !byte $8B,%01001000 + !byte $0B,%00010010 + !byte $27,%00101100 + !byte $8B,%10101001 + !byte $8B,%11001001 + !byte $59,%11100111 + !byte $0D,%11110001 + !byte $43,%00100110 + !byte $8B,%00101000 + !byte $27,%01101000 + !byte $27,%10001001; + !byte $6F,%01100110 + !byte $6F,%10000111; + !byte $17,%10101111 + !byte $09,%01010010 + !byte $41,%10100111 + !byte $9D,%00101010 + !byte $27,%01001010 + !byte $19,%11101111 + !byte $13,%00001110 + !byte $91,%01001010 + !byte $3D,%10101001 + !byte $85,%01100110 + !byte $85,%10000111; + !byte $8B,%00001000 + !byte $9B,%00101010 + !byte $B1,%11001111 + !byte $4B,%00000110 + !byte $7D,%11000111 + !byte $57,%11100111 + !byte $9F,%00101110 + !byte $5D,%01100110 + !byte $5D,%10000111; + !byte $09,%01110010 + !byte $09,%10010011; + !byte $87,%01100110 + !byte $87,%10000111; + !byte $A3,%10101011 + !byte $3F,%01001000 + !byte $AF,%10101111 + !byte $AB,%11110001 + !byte $13,%01101100 + !byte $13,%10001101; + !byte $8F,%01001010 + !byte $9F,%00101010 + !byte $A3,%01001110 + !byte $17,%01110000 + !byte $17,%10010001; + !byte $51,%01100110 + !byte $51,%10000111; + !byte $6D,%00000110 + !byte $A3,%01101010 + !byte $A3,%10001011; + !byte $A3,%11001011 + !byte $0D,%11110011 + !byte $09,%00110010 + !byte $A7,%01010010 + !byte $5F,%00100110 + !byte $B1,%01010000 + !byte $3B,%10101001 + !byte $AB,%01101110 + !byte $AB,%10001111; + !byte $83,%01100110 + !byte $83,%10000111; + !byte $A1,%01001100 + !byte $9F,%11001101 + !byte $0B,%11010011 + !byte $99,%00101010 + !byte $A7,%01110010 + !byte $A7,%10010011; + !byte $15,%01001100 + !byte $47,%11100101 + !byte $8B,%11100111 + !byte $53,%10100111 + !byte $AD,%11010001 + !byte $13,%10110001 + !byte $2B,%00101000 + !byte $19,%01010000 + !byte $27,%01101010 + !byte $27,%10001011; + !byte $27,%01001000 + !byte $41,%01100110 + !byte $41,%10000111; + !byte $63,%11000101 + !byte $A3,%11101011 + !byte $55,%11000111 + !byte $67,%10100101 + !byte $77,%00001000 + !byte $49,%11100101 + !byte $6B,%11000101 + !byte $71,%11000111 + !byte $73,%00001000 + !byte $0F,%11010001 + !byte $2D,%00101000 + !byte $25,%00101100 + !byte $7F,%10100111 + !byte $3F,%00101000 + !byte $09,%10110011 + !byte $45,%11100101 + !byte $89,%01100110 + !byte $89,%10000111; + !byte $8B,%11000111 + !byte $97,%00101010 + !byte $29,%00101000 + !byte $43,%00000110 + !byte $A1,%00101010 + !byte $13,%00101110 + !byte $33,%01001000 + !byte $A3,%01001010 + !byte $A5,%01001110 + !byte $27,%00001100 + !byte $9F,%11101101 + !byte $37,%01101000 + !byte $37,%10001001; + !byte $69,%10100101 + !byte $9F,%00001110 + !byte $AD,%11110011 + !byte $61,%11100101 + !byte $6F,%01000110 + !byte $B3,%00010000 + !byte $27,%10101011 + !byte $5B,%10100111 + !byte $65,%10100101 + !byte $B3,%11101111 + !byte $AF,%10110001 + !byte $8D,%00101010 + !byte $15,%01101110 + !byte $15,%10001111; + !byte $41,%01000110 + !byte $A9,%10110011 + !byte $19,%00010000 + !byte $AD,%01101110 + !byte $AD,%10001111; + !byte $AB,%11010011 + !byte $11,%11001101 + !byte $11,%10101101 + !byte $09,%00010010 + !byte $23,%00101100 + !byte $2F,%00101000 + !byte $A3,%00001100 + !byte $19,%00110000 + !byte $B1,%10101111 + !byte $0B,%11110001 + !byte $3F,%00001000 + !byte $3D,%01101000 + !byte $3D,%10001001; + !byte $A1,%01101100 + !byte $A1,%10001101; + !byte $A9,%00110010 + !byte $17,%11001111 + !byte $13,%01001100 + !byte $27,%11001011 + !byte $8B,%10100111 + !byte $95,%00101010 + !byte $21,%00101100 + !byte $27,%11101011 + !byte $79,%11100111 + !byte $A1,%00101110 + !byte $B3,%11001111 + !byte $59,%11000111 + !byte $6D,%11100101 + !byte $81,%01100110 + !byte $81,%10000111; + !byte $1B,%00101100 + !byte $1F,%00101100 + !byte $75,%00001000 + !byte $A7,%01001110 + !byte $11,%11101101 + !byte $1D,%00101100 + !byte $27,%00101000 + !byte $B3,%00110000 + !byte $B1,%01110000 + !byte $B1,%10010001; + !byte $25,%11001001 + !byte $25,%10101001 + !byte $4F,%00100110 + !byte $15,%01110000 + !byte $15,%10010001; + !byte $11,%01101100 + !byte $11,%10001101; + !byte $19,%00101100 + !byte $4D,%00000110 + !byte $5D,%01000110 + !byte $85,%01000110 + !byte $07,%01010010 + !byte $87,%01000110 + !byte $25,%11101001 + !byte $4B,%11100101 + !byte $A3,%00101010 + !byte $11,%10110001 + !byte $07,%01110010 + !byte $07,%10010011; + !byte $07,%00110010 + !byte $25,%01101000 + !byte $25,%10001001; + !byte $43,%11100101 + !byte $57,%11000111 + !byte $41,%00100110 + !byte $5F,%00000110 + !byte $71,%10100111 + !byte $47,%11000101 + !byte $73,%11100111 + !byte $17,%00101100 + !byte $39,%01101000 + !byte $39,%10001001; + !byte $3F,%11100111 + !byte $8D,%00001010 + !byte $6F,%00100110 + !byte $7B,%11000111 + !byte $0D,%11010001 + !byte $67,%01100100 + !byte $67,%10000101; + !byte $6B,%10100101 + !byte $AF,%01101110 + !byte $AF,%10001111; + !byte $0B,%11110011 + !byte $09,%11010011 + !byte $63,%10100101 + !byte $89,%01000110 + !byte $51,%01000110 + !byte $93,%00101010 + !byte $9D,%00001010 + !byte $9F,%00001010 + !byte $25,%01001000 + !byte $45,%11000101 + !byte $AB,%00010010 + !byte $8F,%00101010 + !byte $A3,%00101100 + !byte $A9,%01001110 + !byte $17,%01010000 + !byte $69,%01100100 + !byte $69,%10000101; + !byte $8B,%01100110 + !byte $8B,%10000111; + !byte $A5,%01101010 + !byte $A5,%10001011; + !byte $A1,%10101101 + !byte $25,%00001010 + !byte $31,%00101000 + !byte $35,%01001000 + !byte $3B,%01101000 + !byte $3B,%10001001; + !byte $13,%01001110 + !byte $A5,%10101011 + !byte $2B,%00001000 + !byte $83,%01000110 + !byte $A9,%01110010 + !byte $A9,%10010011; + !byte $49,%11000101 + !byte $AD,%11110001 + !byte $29,%00001000 + !byte $53,%01100110 + !byte $53,%10000111; + !byte $61,%11000101 + !byte $A1,%00001010 + !byte $B3,%10101111 + !byte $A9,%01010010 + !byte $11,%00001110 + !byte $11,%01001100 + !byte $15,%00101100 + !byte $9B,%00001010 + !byte $A5,%01001010 + !byte $3D,%01001000 + !byte $3F,%11000111 + !byte $65,%01100100 + !byte $65,%10000101; + !byte $B3,%01010000 + !byte $25,%00001100 + !byte $6D,%11000101 + !byte $91,%00101010 + !byte $7D,%10100111 + !byte $55,%10100111 + !byte $8D,%11101001 + !byte $07,%10110011 + !byte $17,%11101111 + !byte $A3,%00101110 + !byte $09,%11110001 + !byte $07,%00010010 + !byte $15,%10101111 + !byte $25,%00101010 + !byte $B5,%11101111 + !byte $A5,%11001011 + !byte $A1,%00001110 + !byte $41,%00000110 + !byte $5B,%01100110 + !byte $5B,%10000111; + !byte $25,%00101000 + !byte $8D,%11001001 + !byte $AB,%01001110 + !byte $27,%00001000 + !byte $2D,%00001000 + !byte $71,%01100110 + !byte $71,%10000111; + !byte $7F,%01100110 + !byte $7F,%10000111; + !byte $B5,%00010000 + !byte $AF,%11110011 + !byte $77,%11100111 + !byte $43,%11000101 + !byte $6F,%00000110 + !byte $99,%00001010 + !byte $59,%10100111 + !byte $13,%01110000 + !byte $13,%10010001; + !byte $13,%00101100 + !byte $A3,%00001010 + !byte $B1,%01101110 + !byte $B1,%10001111; + !byte $AF,%11010001 + !byte $8D,%00001000 + !byte $8D,%00101000 + !byte $8D,%01001000 + !byte $8D,%01101000 + !byte $8D,%10001001; + !byte $8D,%10101001 + !byte $0F,%10110001 + !byte $3F,%10100111 + !byte $B5,%11001111 + !byte $AD,%11010011 + !byte $A5,%00101010 + !byte $0F,%10101101 + !byte $87,%00100110 + !byte $8B,%01000110 + !byte $8D,%11100111 + !byte $A1,%11001101 + !byte $AB,%10110011 + !byte $75,%11100111 + !byte $0B,%11010001 + !byte $17,%00110000 + !byte $0F,%01101100 + !byte $0F,%10001101; + !byte $5D,%00100110 + !byte $25,%01001010 + !byte $B1,%10110001 + !byte $0F,%11001101 + !byte $6B,%01100100 + !byte $6B,%10000101; + !byte $73,%11000111 + !byte $5F,%11100101 + !byte $A1,%11101101 + !byte $05,%01010010 + !byte $37,%01001000 + !byte $89,%00100110 + !byte $17,%00010000 + !byte $23,%00001100 + !byte $3F,%01100110 + !byte $3F,%10000111; + !byte $67,%01000100 + !byte $85,%00100110 + !byte $8D,%11000111 + !byte $A3,%01001100 + !byte $A5,%00101110 + !byte $B5,%00110000 + !byte $47,%10100101 + !byte $3D,%00101000 + !byte $45,%10100101 + !byte $4D,%11100101 + !byte $A5,%11101011 + !byte $11,%00101110 + !byte $41,%11100101 + !byte $AD,%01001110 + !byte $25,%11101011 + !byte $81,%01000110 + !byte $AB,%00110010 + !byte $2F,%00001000 + !byte $33,%00101000 + !byte $97,%00001010 + !byte $69,%01000100 + !byte $05,%00110010 + !byte $57,%10100111 + !byte $05,%01110010 + !byte $05,%10010011; + !byte $4B,%11000101 + !byte $13,%01101110 + !byte $13,%10001111; + !byte $25,%01101010 + !byte $25,%10001011; + !byte $25,%00001000 + !byte $63,%01100100 + !byte $63,%10000101; + !byte $8F,%00001010 + !byte $6D,%10100101 + !byte $B5,%10101111 + !byte $4F,%00000110 + !byte $8D,%10100111 + !byte $0F,%11101101 + !byte $0F,%01001100 + !byte $79,%11000111 + !byte $09,%11110011 + !byte $15,%01010000 + !byte $11,%00101100 + !byte $65,%01000100 + !byte $3B,%01001000 + !byte $61,%10100101 + !byte $A5,%00001010 + !byte $15,%11001111 + !byte $B3,%01110000 + !byte $B3,%10010001; + !byte $49,%10100101 + !byte $6F,%11100101 + !byte $21,%00001100 + !byte $71,%01000110 + !byte $07,%11010011 + !byte $B3,%01101110 + !byte $B3,%10001111; + !byte $07,%11110001 + !byte $3F,%01000110 + !byte $25,%11001011 + !byte $25,%10101011 + !byte $23,%01101000 + !byte $23,%10001001; + !byte $29,%11100111 + !byte $39,%01001000 + !byte $51,%00100110 + !byte $1B,%00001100 + !byte $1F,%00001100 + !byte $23,%10101001 + !byte $23,%01001000 + !byte $27,%11100111 + !byte $43,%10100101 + !byte $8D,%01100110 + !byte $8D,%10000111; + !byte $05,%00010010 + !byte $19,%00001100 + !byte $5B,%01000110 + !byte $8B,%00100110 + !byte $95,%00001010 + !byte $9F,%11101001 + !byte $A7,%00101110 + !byte $0D,%10110001 + !byte $1D,%00001100 + !byte $83,%00100110 + !byte $A1,%11101001 + !byte $A5,%00001100 + !byte $AF,%01001110 + !byte $AB,%01110010 + !byte $AB,%10010011; + !byte $17,%00001100 + !byte $3D,%00001000 + !byte $53,%01000110 + !byte $05,%10110011 + !byte $11,%01110000 + !byte $11,%10010001; + !byte $2B,%11100111 + !byte $6B,%01000100 + !byte $A7,%01001010 + !byte $A7,%01101010 + !byte $A7,%10001011; + !byte $A3,%00001110 + !byte $AD,%00010010 + !byte $23,%11001001 + !byte $55,%01100110 + !byte $55,%10000111; + !byte $A3,%01101100 + !byte $A3,%10001101; + !byte $B1,%11110011 + !byte $7B,%10100111 + !byte $9D,%11101001 + !byte $73,%10100111 + !byte $AB,%01010010 + !byte $09,%11010001 + !byte $91,%00001010 + !byte $A3,%11101001 + !byte $B7,%11101111 + !byte $15,%00001100 + !byte $B7,%11001111 + !byte $B5,%01010000 + !byte $41,%11000101 + !byte $59,%01100110 + !byte $59,%10000111; + !byte $93,%00001010 + !byte $23,%00101000 + !byte $75,%11000111 + !byte $A7,%00101010 + !byte $31,%00001000 + !byte $35,%00101000 + !byte $A7,%10101011 + !byte $7D,%01100110 + !byte $7D,%10000111; + !byte $5D,%00000110 + !byte $87,%00000110 + !byte $89,%00000110 + !byte $8D,%01000110 + !byte $B7,%00010000 + !byte $3F,%00100110 + !byte $67,%00100100 + !byte $77,%11000111 + !byte $8F,%11101001 + !byte $5F,%11000101 + !byte $0F,%00101100 + !byte $13,%00001100 + !byte $23,%11101001 + !byte $25,%11100111 + !byte $45,%01100100 + !byte $45,%10000101; + !byte $47,%01100100 + !byte $47,%10000101; + !byte $9B,%11101001 + !byte $AF,%11110001 + !byte $0D,%10101101 + !byte $0D,%01101100 + !byte $0D,%10001101; + !byte $69,%00100100 + !byte $0F,%00001110 + !byte $2D,%11100111 + !byte $6D,%01100100 + !byte $6D,%10000101; + !byte $A9,%00101110 + !byte $AF,%11010011 + !byte $03,%01010010 + !byte $11,%01001110 + !byte $23,%11101011 + !byte $63,%01000100 + !byte $71,%00100110 + !byte $AD,%10110011 + !byte $B1,%01001110 + !byte $15,%00110000 + !byte $23,%00001000 + !byte $3D,%11100111 + !byte $6F,%11000101 + !byte $A5,%11101001 + !byte $15,%11101111 + !byte $A7,%00001010 + !byte $B5,%01101110 + !byte $B5,%10001111; + !byte $03,%00110010 + !byte $4D,%11000101 + !byte $B1,%11010001 + !byte $85,%00000110 + !byte $A3,%10101101 + !byte $B7,%10101111 + !byte $3B,%00101000 + !byte $4B,%10100101 + !byte $57,%01100110 + !byte $57,%10000111; + !byte $03,%01110010 + !byte $03,%10010011; + !byte $13,%01010000 + !byte $0D,%01001100 + !byte $43,%01100100 + !byte $43,%10000101; + !byte $13,%10101111 + !byte $7F,%01000110 + !byte $8B,%00000110 + !byte $61,%01100100 + !byte $61,%10000101; + !byte $65,%00100100 + !byte $A7,%11001011 + !byte $A3,%11101101 + !byte $23,%00001010 + !byte $A5,%00101100 + !byte $3F,%00000110 + !byte $8F,%11001001 + !byte $B7,%00110000 + !byte $0B,%10110001 + !byte $0D,%11001101 + !byte $A5,%00001110 + !byte $11,%00001100 + !byte $99,%11101001 + !byte $41,%10100101 + !byte $81,%00100110 + !byte $8D,%00100110 + !byte $4F,%11100101 + !byte $07,%11110011 + !byte $0F,%01110000 + !byte $0F,%10010001; + !byte $AB,%00101110 + !byte $5B,%00100110 + !byte $15,%00010000 + !byte $3D,%11000111 + !byte $A3,%11001101 + !byte $05,%11110001 + !byte $73,%01100110 + !byte $73,%10000111; + !byte $B3,%10110001 + !byte $6B,%00100100 + !byte $05,%11010011 + !byte $AD,%00110010 + !byte $37,%00101000 + !byte $03,%00010010 + !byte $49,%01100100 + !byte $49,%10000101; + !byte $27,%11000111 + !byte $79,%10100111 + !byte $07,%11010001 + !byte $23,%00101010 + !byte $23,%11100111 + !byte $51,%00000110 + !byte $8F,%10101001 + !byte $B5,%01110000 + !byte $B5,%10010001; + !byte $29,%11000111 + !byte $33,%00001000 + !byte $71,%00000110 + !byte $B3,%01001110 + !byte $0D,%00101100 + !byte $3F,%11100101 + !byte $59,%01000110 + !byte $2F,%11100111 + !byte $39,%00101000 + !byte $A7,%11101001 + !byte $21,%11101011 + !byte $3D,%10100111 + !byte $55,%01000110 + !byte $6F,%10100101 + !byte $97,%11101001 + !byte $AD,%01110010 + !byte $AD,%10010011; + !byte $0F,%00001100 + !byte $23,%11001011 + !byte $25,%11000111 + !byte $75,%10100111 + !byte $8F,%01101000 + !byte $8F,%10001001; + !byte $0F,%00101110 + !byte $AD,%00101110 + !byte $B3,%11110011 + !byte $45,%01000100 + !byte $67,%00000100 + !byte $89,%11100101 + !byte $8F,%00001000 + !byte $8F,%00101000 + !byte $8F,%01001000 + !byte $B9,%11101111 + !byte $03,%10110011 + !byte $0D,%11101101 + !byte $53,%00100110 + !byte $8F,%11100111 + !byte $91,%11101001 + !byte $B7,%01101110 + !byte $B7,%10001111; + !byte $B9,%11001111 + !byte $69,%00000100 + !byte $6D,%01000100 + !byte $5F,%10100101 + !byte $23,%01001010 + !byte $5D,%11100101 + !byte $8F,%11000111 + !byte $A1,%11001001 + !byte $A3,%11001001 + !byte $A7,%11101011 + !byte $2B,%11000111 + !byte $3B,%00001000 + !byte $83,%00000110 + !byte $AD,%01010010 + !byte $41,%01100100 + !byte $41,%10000101; + !byte $8F,%10100111 + !byte $11,%01101110 + !byte $11,%10001111; + !byte $87,%11100101 + !byte $8D,%00000110 + !byte $A5,%01001100 + !byte $63,%00100100 + !byte $9F,%11001001 + !byte $A9,%01001010 + !byte $47,%01000100 + !byte $7B,%01100110 + !byte $7B,%10000111; + !byte $8B,%11100101 + !byte $A9,%00101010 + !byte $13,%11001111 + !byte $43,%01000100 + !byte $11,%01010000 + !byte $A5,%11001001 + !byte $B9,%10101111 + !byte $1F,%11101011 + !byte $21,%01001000 + !byte $73,%01000110 + !byte $23,%10101011 + !byte $A7,%00001110 + !byte $B9,%00010000 + !byte $B7,%01010000 + !byte $AF,%00010010 + !byte $0D,%01110000 + !byte $0D,%10010001; + !byte $01,%01010010 + !byte $23,%01101010 + !byte $23,%10001011; + !byte $21,%00101000 + !byte $65,%00000100 + !byte $77,%10100111 + !byte $95,%11101001 + !byte $AF,%00101110 + !byte $3D,%01100110 + !byte $3D,%10000111; + !byte $8F,%01100110 + !byte $8F,%10000111; + !byte $01,%00110010 + !byte $21,%01101000 + !byte $21,%10001001; + !byte $A9,%00001010 + !byte $AF,%10110011 + !byte $09,%10110001 + !byte $0B,%01101100 + !byte $0B,%10001101; + !byte $93,%11101001 + !byte $13,%00110000 + !byte $23,%11000111 + !byte $3F,%11000101 + !byte $A9,%01101010 + !byte $A9,%10001011; + !byte $0B,%01001100 + !byte $17,%11101011 + !byte $19,%11101011 + !byte $1D,%11101011 + !byte $21,%00001000 + !byte $71,%11100101 + !byte $1B,%11101011 + !byte $57,%01000110 + !byte $7D,%01000110 + !byte $B5,%01001110 + !byte $B1,%11010011 + !byte $A5,%11101101 + !byte $0D,%00001100 + !byte $15,%11101011 + !byte $6B,%00000100 + !byte $01,%01110010 + !byte $01,%10010011; + !byte $03,%11110001 + !byte $21,%10101001 + !byte $4B,%01100100 + !byte $4B,%10000101; + !byte $9D,%11001001 + !byte $0B,%10101101 + !byte $8F,%01000110 + !byte $61,%01000100 + !byte $B1,%11110001 + !byte $31,%11100111 + !byte $A7,%00001100 + !byte $A5,%01101100 + !byte $A5,%10001101; + !byte $13,%11101011 + !byte $35,%00001000 + !byte $3D,%01000110 + !byte $5B,%00000110 + !byte $05,%11010001 + !byte $85,%11100101 + !byte $6D,%00100100 + !byte $A9,%11101001 + !byte $B3,%11010001 + !byte $2D,%11000111 + !byte $49,%01000100 + !byte $6F,%01100100 + !byte $6F,%10000101; + !byte $A9,%10101011 + !byte $05,%11110011 + !byte $4D,%10100101 + !byte $8D,%11100101 + !byte $A7,%11001001 + !byte $01,%00010010 + !byte $0D,%00001110 + !byte $21,%11001001 + !byte $21,%11100111 + !byte $4F,%11000101 + !byte $0B,%00101100 + !byte $A9,%00001110 + !byte $03,%11010011 + !byte $91,%11001001 + !byte $7F,%00100110 + !byte $3B,%11100111 + !byte $8F,%00100110 + !byte $9B,%11001001 + !byte $B1,%00101110 + !byte $75,%01100110 + !byte $75,%10000111; + !byte $13,%11101111 + !byte $11,%11101011 + !byte $41,%01000100 + !byte $5D,%11000101 + !byte $3F,%10100101 + !byte $13,%00010000 + !byte $21,%11001011 + !byte $67,%11100011 + !byte $27,%10100111 + !byte $0F,%01001110 + !byte $69,%11100011 + !byte $B9,%01101110 + !byte $B9,%10001111; + !byte $25,%10100111 + !byte $45,%00100100 + !byte $59,%00100110 + !byte $39,%00001000 + !byte $0B,%11001101 + !byte $3D,%00100110 + !byte $B9,%00110000 + !byte $A5,%11001101 + !byte $B7,%01001110 + !byte $5F,%01100100 + !byte $5F,%10000101; + !byte $89,%11000101 + !byte $A5,%10101101 + !byte $B5,%10110001 + !byte $55,%00100110 + !byte $51,%11100101 + !byte $8B,%11000101 + !byte $BB,%11001111 + !byte $01,%10110011 + !byte $37,%00001000 + !byte $43,%00100100 + !byte $79,%01100110 + !byte $79,%10000111; + !byte $AF,%00110010 + !byte $47,%00100100 + !byte $81,%00000110 + !byte $0F,%01010000 + !byte $11,%10101111 + !byte $0F,%11101011 + !byte $29,%10100111 + !byte $73,%00100110 + !byte $AF,%01110010 + !byte $AF,%10010011; + !byte $B5,%11110011 + !byte $21,%11000111 + !byte $53,%00000110 + !byte $8F,%00000110 + !byte $23,%10100111 + !byte $71,%11000101 + !byte $B3,%00101110 + !byte $BB,%11101111 + !byte $0B,%01110000 + !byte $0B,%10010001; + !byte $21,%11101001 + !byte $65,%11100011 + !byte $0B,%00001100 + !byte $63,%00000100 + !byte $87,%11000101 + !byte $A9,%11001001 + !byte $A7,%00101100 + !byte $07,%10110001 + !byte $99,%11001001 + !byte $AB,%00001110 + !byte $BB,%10101111 + !byte $3D,%00000110 + !byte $3F,%01100100 + !byte $3F,%10000101; + !byte $6B,%11100011 + !byte $A9,%11001011 + !byte $91,%10101001 + !byte $11,%00110000 + !byte $A3,%10101001 + !byte $33,%11100111 + !byte $6F,%01000100 + !byte $A7,%11101101 + !byte $B7,%01110000 + !byte $B7,%10010001; + !byte $B3,%11010011 + !byte $01,%11110001 + !byte $3B,%11000111 + !byte $77,%01100110 + !byte $77,%10000111; + !byte $A5,%10101001 + !byte $2F,%11000111 + !byte $6D,%00000100 + !byte $8D,%11000101 + !byte $83,%11100101 + !byte $AF,%01010010 + !byte $03,%11010001 + !byte $21,%00001010 + !byte $93,%11001001 + !byte $BB,%00010000 + !byte $57,%00100110 + !byte $61,%00100100 + !byte $AB,%00001010 + !byte $AB,%00101010 + !byte $1F,%11001011 + !byte $A1,%10101001 + !byte $09,%01001100 + !byte $0D,%11101011 + !byte $2B,%10100111 + !byte $7B,%01000110 + !byte $21,%10101011 + !byte $41,%00100100 + !byte $0B,%11101101 + !byte $09,%01101100 + !byte $09,%10001101; + !byte $4B,%01000100 + !byte $B1,%00010010 + !byte $97,%11001001 + !byte $B1,%10110011 + !byte $A7,%10101001 + !byte $5B,%11100101 + !byte $AB,%01001010 + !byte $BB,%01101110 + !byte $BB,%10001111; + !byte $B9,%01010000 + !byte $3D,%11100101 + !byte $73,%00000110 + !byte $B9,%01001110 + !byte $09,%00101100 + !byte $AB,%11101001 + !byte $AD,%00001110 + !byte $75,%01000110 + !byte $8F,%11100101 + !byte $0D,%00101110 + !byte $49,%00100100 + !byte $69,%11000011 + !byte $95,%11001001 + !byte $11,%11001111 + !byte $91,%01101000 + !byte $91,%10001001; + !byte $21,%10100111 + !byte $21,%00101010 + !byte $67,%11000011 + !byte $9F,%10101001 + !byte $B5,%00101110 + !byte $5D,%10100101 + !byte $3B,%10100111 + !byte $7D,%00100110 + !byte $01,%11010011 + !byte $1F,%00101000 + !byte $0D,%01010000 + !byte $1F,%00001000 + !byte $39,%11100111 + !byte $45,%00000100 + !byte $4D,%01100100 + !byte $4D,%10000101; + !byte $85,%11000101 + !byte $3F,%01000100 + !byte $43,%00000100 + !byte $59,%00000110 + !byte $A7,%01001100 + !byte $09,%01110000 + !byte $09,%10010001; + !byte $A9,%11101011 + !byte $B3,%11110001 + !byte $1D,%11001011 + !byte $0F,%01101110 + !byte $0F,%10001111; + !byte $21,%01101010 + !byte $21,%10001011; + !byte $21,%01001010 + !byte $71,%10100101 + !byte $05,%10110001 + !byte $09,%10101101 + !byte $1F,%01001000 + !byte $25,%01100110 + !byte $25,%10000111; + !byte $8B,%10100101 + !byte $91,%01001000 + !byte $1F,%11100111 + !byte $5F,%01000100 + !byte $4F,%10100101 + !byte $03,%11110011 + !byte $11,%00010000 + !byte $6F,%00100100 + !byte $91,%00101000 + !byte $AB,%11001001 + !byte $09,%00001100 + !byte $89,%10100101 + !byte $91,%11000111 + !byte $AB,%01101010 + !byte $AB,%10001011; + !byte $3D,%11000101 + !byte $A9,%10101001 + !byte $0B,%11101011 + !byte $1B,%11001011 + !byte $91,%00001000 + !byte $23,%01100110 + !byte $23,%10000111; + !byte $27,%01100110 + !byte $27,%10000111; + !byte $35,%11100111 + !byte $91,%01100110 + !byte $91,%10000111; + !byte $91,%10100111 + !byte $91,%11100111 + !byte $A9,%11101101 + !byte $AF,%00001110 + !byte $6B,%11000011 + !byte $63,%11100011 + !byte $13,%11001011 + !byte $15,%11001011 + !byte $19,%11001011 + !byte $1F,%01101000 + !byte $1F,%10001001; + !byte $7F,%00000110 + !byte $9D,%10101001 + !byte $17,%11001011 + !byte $2D,%10100111 + !byte $65,%11000011 + !byte $BD,%11001111 + !byte $BB,%00110000 + !byte $55,%00000110 + !byte $6D,%11100011 + !byte $8F,%11000101 + !byte $A7,%11001101 + !byte $11,%11101111 + !byte $8D,%10100101 + !byte $11,%11001011 + !byte $BD,%10101111 + !byte $1F,%11000111 + !byte $47,%00000100 + !byte $91,%01000110 + !byte $41,%00000100 + !byte $51,%11000101 + !byte $31,%11000111 + !byte $3B,%01100110 + !byte $3B,%10000111; + !byte $37,%11100111 + !byte $B7,%00101110 + !byte $A7,%01101100 + !byte $A7,%10001101; + !byte $79,%01000110 + !byte $BD,%11101111 + !byte $B7,%11110011 + !byte $91,%00100110 + !byte $B5,%11010001 + !byte $0F,%00110000 + !byte $53,%11100101 + !byte $61,%00000100 + !byte $93,%10101001 + !byte $87,%10100101 + !byte $B7,%10110001 + !byte $01,%11010001 + !byte $B1,%00110010 + !byte $73,%11100101 + !byte $BB,%01001110 + !byte $B1,%01110010 + !byte $B1,%10010011; + !byte $0B,%00001110 + !byte $3D,%10100101 + !byte $0F,%11001011 + !byte $5B,%11000101 + !byte $77,%01000110 + !byte $1F,%10101001 + !byte $A7,%10101101 + !byte $21,%01100110 + !byte $21,%10000111; + !byte $29,%01100110 + !byte $29,%10000111; + !byte $81,%11100101 + !byte $B1,%00001110 + !byte $9B,%10101001 + !byte $1F,%10101011 + !byte $3F,%00100100 + !byte $71,%01100100 + !byte $71,%10000101; + !byte $AB,%10101011 + !byte $57,%00000110 + !byte $75,%00100110 + !byte $09,%11001101 + !byte $A9,%00001100 + !byte $69,%10100011 + !byte $1F,%10100111 + !byte $91,%00000110 + !byte $B5,%11010011 + !byte $BD,%01101110 + !byte $BD,%10001111; + !byte $AB,%10101001 + !byte $B3,%10110011 + !byte $0D,%11001011 + !byte $39,%11000111 + !byte $67,%10100011 + !byte $0D,%01001110 + !byte $3B,%01000110 + !byte $0F,%10101111 + !byte $A5,%01101000 + !byte $A5,%10001001; + !byte $B1,%01010010 + !byte $03,%10110001 + !byte $6F,%00000100 + !byte $B9,%01110000 + !byte $B9,%10010001; + !byte $07,%01110000 + !byte $07,%10010001; + !byte $07,%01001100 + !byte $07,%00101100 + !byte $09,%11101011 + !byte $0B,%01010000 + !byte $43,%11100011 + !byte $45,%11100011 + !byte $A7,%01101000 + !byte $A7,%10001001; + !byte $B9,%00101110 + !byte $83,%11000101 + !byte $AB,%11101101 + !byte $1F,%11001001 + !byte $5D,%01100100 + !byte $5D,%10000101; + !byte $A3,%01101000 + !byte $A3,%10001001; + !byte $AD,%00001010 + !byte $B3,%00001110 + !byte $3D,%01100100 + !byte $3D,%10000101; + !byte $8F,%10100101 + !byte $AD,%11101001 + !byte $BD,%00010000 + !byte $91,%11100101 + !byte $99,%10101001 + !byte $5F,%00100100 + !byte $59,%11100101 + !byte $7B,%00100110 + !byte $6B,%10100011 + !byte $AD,%00101010 + !byte $07,%01101100 + !byte $07,%10001101; + !byte $07,%00001100 + !byte $49,%00000100 + !byte $8B,%01100100 + !byte $8B,%10000101; + !byte $95,%10101001 + !byte $4B,%00100100 + !byte $2B,%01100110 + !byte $2B,%10000111; + !byte $4D,%01000100 + !byte $8D,%01100100 + !byte $8D,%10000101; + !byte $A1,%01101000 + !byte $A1,%10001001; + !byte $B3,%00010010 + !byte $0B,%11001011 + !byte $2F,%10100111 + !byte $33,%11000111 + !byte $63,%11000011 + !byte $3B,%00100110 + !byte $6D,%11000011 + !byte $A9,%01101000 + !byte $A9,%10001001; + !byte $AD,%11001001 + !byte $BB,%01010000 + !byte $1F,%01100110 + !byte $1F,%10000111; + !byte $23,%01000110 + !byte $41,%11100011 + !byte $65,%10100011 + !byte $3F,%00000100 + !byte $93,%01101000 + !byte $93,%10001001; + !byte $01,%11110011 + !byte $1F,%11101001 + !byte $25,%01000110 + !byte $73,%11000101 + !byte $85,%10100101 + !byte $89,%01100100 + !byte $89,%10000101; + !byte $97,%10101001 + !byte $A9,%00101100 + !byte $BD,%01001110 + !byte $4F,%01100100 + !byte $4F,%10000101; + !byte $A9,%11001101 + !byte $47,%11100011 + !byte $0D,%00110000 + !byte $1F,%01101010 + !byte $1F,%10001011; + !byte $AB,%11001011 + !byte $0F,%00010000 + !byte $1D,%10101011 + !byte $71,%01000100 + !byte $7D,%00000110 + !byte $3B,%00000110 + !byte $75,%00000110 + !byte $91,%11000101 + !byte $BF,%11001111 + !byte $BF,%10101111 + !byte $21,%01000110 + !byte $3D,%01000100 + !byte $09,%11101101 + !byte $61,%11100011 + !byte $B5,%00001110 + !byte $0F,%11001111 + !byte $55,%11100101 + !byte $AD,%11101101 + !byte $0B,%00101110 + !byte $AD,%01001010 + !byte $77,%00100110 + !byte $AD,%10101001 + !byte $1F,%00001010 + !byte $39,%10100111 + !byte $BB,%00101110 + !byte $37,%11000111 + !byte $B5,%11110001 + !byte $07,%10101101 + !byte $1D,%00001000 + !byte $1D,%11100111 + !byte $35,%11000111 + !byte $5B,%10100101 + !byte $27,%01000110 + !byte $51,%10100101 + !byte $69,%01100010 + !byte $69,%10000011; + !byte $8F,%01100100 + !byte $8F,%10000101; + !byte $AB,%01101000 + !byte $AB,%10001001; + !byte $07,%11101011 + !byte $9F,%01101000 + !byte $9F,%10001001; + !byte $B9,%11110011 + !byte $1D,%11000111 + !byte $79,%00100110 + !byte $BF,%01101110 + !byte $BF,%10001111; + !byte $09,%01010000 + !byte $0D,%01101110 + !byte $0D,%10001111; + !byte $09,%11001011 + !byte $B3,%01110010 + !byte $B3,%10010011; + !byte $6F,%11100011 + !byte $BF,%11101111 + !byte $05,%01110000 + !byte $05,%10010001; + !byte $1B,%10101011 + !byte $1F,%01001010 + !byte $1D,%00101000 + !byte $57,%11100101 + !byte $93,%01001000 + !byte $0F,%11101111 + !byte $53,%11000101 + !byte $01,%10110001 + !byte $67,%01100010 + !byte $67,%10000011; + !byte $7F,%11100101 + !byte $BD,%00110000 + !byte $1F,%00101010 + !byte $43,%11000011 + !byte $3B,%11100101 + !byte $A9,%01001100 + !byte $3F,%11100011 + !byte $B7,%11010001 + !byte $B7,%00001110 + !byte $5D,%01000100 + !byte $73,%10100101 + !byte $1D,%10100111 + !byte $87,%01100100 + !byte $87,%10000101; + !byte $3D,%00100100 + !byte $6D,%10100011 + !byte $9D,%01101000 + !byte $9D,%10001001; + !byte $AB,%11101011 + !byte $B3,%00110010 + !byte $1F,%01000110 + !byte $6B,%01100010 + !byte $6B,%10000011; + !byte $AD,%01101010 + !byte $AD,%10001011; + !byte $A9,%10101101 + !byte $AF,%11101101 + !byte $45,%11000011 + !byte $91,%10100101 + !byte $2D,%01100110 + !byte $2D,%10000111; + !byte $B7,%11010011 + !byte $19,%10101011 + !byte $93,%00101000 + !byte $1D,%01001000 + !byte $31,%10100111 + !byte $5F,%00000100 + !byte $41,%11000011 + !byte $71,%00100100 + !byte $B5,%10110011 + !byte $05,%00101100 + !byte $11,%10101011 + !byte $15,%10101011 + !byte $17,%10101011 + !byte $13,%10101011 + !byte $59,%11000101 + !byte $81,%11000101 + !byte $63,%10100011 + !byte $0F,%10101011 + !byte $A9,%01101100 + !byte $A9,%10001101; + !byte $AB,%11001101 + !byte $B3,%01010010 + !byte $29,%01000110 + !byte $39,%01100110 + !byte $39,%10000111; + !byte $8D,%01000100 + !byte $95,%01101000 + !byte $95,%10001001; + !byte $AD,%01101000 + !byte $AD,%10001001; + !byte $05,%00001100 + !byte $8B,%01000100 + !byte $A7,%01001000 + !byte $07,%11001101 + !byte $B9,%10110001 + !byte $05,%01001100 + !byte $3B,%11000101 + !byte $0B,%00110000 + !byte $0D,%10101011 + !byte $49,%11100011 + !byte $A9,%01001000 + !byte $BF,%00010000 + !byte $4B,%00000100 + !byte $75,%11100101 + !byte $93,%00001000 + !byte $BF,%01001110 + !byte $1D,%01100110 + !byte $1D,%10000111; + !byte $65,%01100010 + !byte $65,%10000011; + !byte $BD,%00101110 + !byte $BB,%01110000 + !byte $BB,%10010001; + !byte $1D,%01101010 + !byte $1D,%10001011; + !byte $07,%11001011 + !byte $93,%11100111 + !byte $A5,%01001000 + !byte $1D,%01101000 + !byte $1D,%10001001; + !byte $93,%01000110 + !byte $93,%01100110 + !byte $93,%10000111; + !byte $93,%10100111 + !byte $93,%11000111 + !byte $AF,%11101001 + !byte $B1,%11101101 + !byte $B9,%00001110 + !byte $83,%10100101 + !byte $8F,%01000100 + !byte $7B,%00000110 + !byte $23,%00100110 + !byte $4D,%00100100 + !byte $93,%00100110 + !byte $9B,%01101000 + !byte $9B,%10001001; + !byte $AF,%11001001 + !byte $09,%00001110 + !byte $61,%11000011 + !byte $21,%00100110 + !byte $0D,%00010000 + !byte $AF,%00001010 + !byte $05,%11101011 + !byte $47,%11000011 + !byte $91,%01100100 + !byte $91,%10000101; + !byte $0B,%01001110 + !byte $05,%01101100 + !byte $05,%10001101; + !byte $0B,%10101011 + !byte $73,%01100100 + !byte $73,%10000101; + !byte $93,%00000110 + !byte $03,%01110000 + !byte $03,%10010001; + !byte $37,%10100111 + !byte $6F,%11000011 + !byte $77,%00000110 + !byte $89,%01000100 + !byte $AB,%01001000 + !byte $07,%01010000 + !byte $3B,%10100101 + !byte $0D,%10101111 + !byte $25,%00100110 + !byte $4F,%01000100 + !byte $69,%01000010 + !byte $A3,%01001000 + !byte $3D,%00000100 + !byte $B5,%00010010 + !byte $55,%11000101 + !byte $AF,%10101001 + !byte $33,%10100111 + !byte $93,%11100101 + !byte $99,%01101000 + !byte $99,%10001001; + !byte $AB,%00001100 + !byte $39,%01000110 + !byte $3F,%11000011 + !byte $67,%01000010 + !byte $97,%01101000 + !byte $97,%10001001; + !byte $AD,%10101011 + !byte $5B,%01100100 + !byte $5B,%10000101; + !byte $1D,%10101001 + !byte $6D,%01100010 + !byte $6D,%10000011; + !byte $1D,%01000110 + !byte $85,%01100100 + !byte $85,%10000101; + !byte $B3,%11101101 + !byte $1F,%00100110 + !byte $71,%00000100 + !byte $2B,%01000110 + !byte $43,%10100011 + !byte $BD,%01010000 + !byte $AF,%00101010 + !byte $09,%10101011 + !byte $57,%11000101 + !byte $2F,%01100110 + !byte $2F,%10000111; + !byte $6B,%01000010 + !byte $AD,%11001101 + !byte $7D,%11100101 + !byte $BB,%11110011 + !byte $35,%10100111 + !byte $51,%01100100 + !byte $51,%10000101; + !byte $79,%00000110 + !byte $41,%10100011 + !byte $93,%11000101 + !byte $A1,%01001000 + !byte $5D,%00100100 + !byte $BB,%00001110 + !byte $3B,%01100100 + !byte $3B,%10000101; + !byte $53,%10100101 + !byte $AF,%01101000 + !byte $AF,%10001001; + !byte $AD,%01001000 + !byte $B7,%11110001 + !byte $0D,%11101111 + !byte $0D,%11001111 + !byte $75,%11000101 + !byte $95,%01001000 + !byte $BF,%00101110 + !byte $B5,%01110010 + !byte $B5,%10010011; + !byte $45,%10100011 + !byte $AB,%10101101 + !byte $05,%11001011 + !byte $27,%00100110 + !byte $59,%10100101 + !byte $5F,%11100011 + !byte $91,%01000100 + !byte $1D,%11001001 + !byte $07,%11101101 + !byte $3D,%11100011 + !byte $1B,%01101010 + !byte $1B,%10001011; + !byte $1D,%01001010 + !byte $BF,%00110000 + !byte $39,%00100110 + !byte $8D,%00100100 + !byte $93,%10100101 + !byte $B7,%10110011 + !byte $05,%10101101 + !byte $65,%01000010 + !byte $01,%01110000 + !byte $01,%10010001; + !byte $6F,%10100011 + !byte $B5,%11101101 + !byte $7F,%11000101 + !byte $AD,%11001011 + !byte $B9,%11010011 + !byte $63,%01100010 + !byte $63,%10000011; + !byte $87,%01000100 + !byte $AB,%00101100 + !byte $03,%00001100 + !byte $07,%10101011 + !byte $05,%01010000 + !byte $09,%00110000 + !byte $1B,%11000111 + !byte $1B,%10100111 + !byte $73,%01000100 + !byte $3B,%01000100 + !byte $8B,%00100100 + !byte $8F,%00100100 + !byte $B5,%00110010 + !byte $0B,%01101110 + !byte $0B,%10001111; + !byte $03,%00101100 + !byte $3F,%10100011 + !byte $9F,%01001000 + !byte $1B,%11100111 + !byte $AF,%01001010 + !byte $1D,%11101001 + !byte $1D,%00100110 + !byte $37,%01100110 + !byte $37,%10000111; + !byte $1D,%00101010 + !byte $B5,%01010010 + !byte $61,%10100011 + !byte $09,%00101110 + !byte $49,%11000011 + !byte $B9,%11010001 + !byte $1B,%01100110 + !byte $1B,%10000111; + !byte $AF,%11001101 + !byte $0B,%00010000 + !byte $1D,%00001010 + !byte $4B,%11100011 + !byte $69,%00100010 + !byte $1B,%00001000 + !byte $71,%11100011 + !byte $03,%11101011 + !byte $19,%01101010 + !byte $19,%10001011; + !byte $77,%11100101 + !byte $21,%00000110 + !byte $39,%00000110 + !byte $81,%10100101 + !byte $AB,%01001100 + !byte $AB,%01101100 + !byte $AB,%10001101; + !byte $B7,%11101101 + !byte $2D,%01000110 + !byte $47,%10100011 + !byte $67,%00100010 + !byte $AF,%01001000 + !byte $BD,%00001110 + !byte $93,%01100100 + !byte $93,%10000101; + !byte $A9,%00101000 + !byte $31,%01100110 + !byte $31,%10000111; + !byte $3D,%11000011 + !byte $4D,%00000100 + !byte $6D,%01000010 + !byte $95,%00101000 + !byte $3B,%00100100 + !byte $AB,%00101000 + !byte $BB,%10110001 + !byte $1F,%00000110 + !byte $23,%00000110 + !byte $A7,%00101000 + !byte $03,%01001100 + !byte $6B,%00100010 + !byte $5B,%01000100 + !byte $7B,%11100101 + !byte $91,%00100100 + !byte $17,%01101010 + !byte $17,%10001011; + !byte $43,%01100010 + !byte $43,%10000011; + !byte $75,%10100101 + !byte $89,%00100100 + !byte $9D,%01001000 + !byte $B1,%11001001 + !byte $1B,%00101000 + !byte $29,%00100110 + !byte $41,%01100010 + !byte $41,%10000011; + !byte $1B,%01000110 + !byte $97,%01001000 + !byte $B1,%10101001 + !byte $0F,%01101010 + !byte $0F,%10001011; + !byte $11,%01101010 + !byte $11,%10001011; + !byte $15,%01101010 + !byte $15,%10001011; + !byte $55,%10100101 + !byte $83,%01100100 + !byte $83,%10000101; + !byte $05,%10101011 + !byte $13,%01101010 + !byte $13,%10001011; + !byte $AF,%01101010 + !byte $AF,%10001011; + !byte $0D,%01101010 + !byte $0D,%10001011; + !byte $39,%11100101 + !byte $B1,%11101001 + !byte $4F,%00100100 + !byte $57,%10100101 + !byte $03,%11001011 + !byte $6F,%01100010 + !byte $6F,%10000011; + !byte $BD,%01110000 + !byte $BD,%10010001; + !byte $5D,%00000100 + !byte $A5,%00101000 + !byte $AD,%00101000 + !byte $25,%00000110 + !byte $B1,%01101000 + !byte $B1,%10001001; + !byte $AD,%10101101 + !byte $05,%11001101 + !byte $95,%00001000 + !byte $B1,%11001101 + !byte $0B,%01101010 + !byte $0B,%10001011; + !byte $73,%00100100 + !byte $93,%01000100 + !byte $AD,%11101011 + !byte $B9,%11101101 + !byte $07,%00110000 + !byte $1B,%01001010 + !byte $79,%11100101 + !byte $9B,%01001000 + !byte $3B,%00000100 + !byte $B7,%00010010 + !byte $1D,%00000110 + !byte $45,%01100010 + !byte $45,%10000011; + !byte $35,%01100110 + !byte $35,%10000111; + !byte $53,%01100100 + !byte $53,%10000101; + !byte $85,%01000100 + !byte $BD,%11110011 + !byte $0B,%10101111 + !byte $03,%01101100 + !byte $03,%10001101; + !byte $1B,%01001000 + !byte $33,%01100110 + !byte $33,%10000111; + !byte $99,%01001000 + !byte $59,%01100100 + !byte $59,%10000101; + !byte $07,%00001110 + !byte $65,%00100010 + !byte $B1,%00001010 + !byte $B7,%01110010 + !byte $B7,%10010011; + !byte $8F,%00000100 + !byte $37,%01000110 + !byte $3F,%01100010 + !byte $3F,%10000011; + !byte $51,%01000100 + !byte $63,%01000010 + !byte $71,%11000011 + !byte $8D,%00000100 + !byte $BF,%00001110 + !byte $BF,%01010000 + !byte $A3,%00101000 + !byte $BB,%11010011 + !byte $0B,%11101111 + !byte $1B,%00100110 + !byte $7D,%11000101 + !byte $03,%01010000 + !byte $09,%01101010 + !byte $09,%10001011; + !byte $5F,%11000011 + !byte $95,%11100111 + !byte $39,%11000101 + !byte $09,%01001110 + !byte $3D,%10100011 + !byte $69,%00000010 + !byte $B1,%01001000 + !byte $AF,%00101000 + !byte $6D,%00100010 + !byte $77,%11000101 + !byte $95,%11000111 + !byte $B9,%10110011 + !byte $0B,%11001111 + !byte $2B,%00100110 + !byte $95,%00100110 + !byte $95,%01000110 + !byte $95,%01100110 + !byte $95,%10000111; + !byte $95,%10100111 + !byte $B9,%11110001 + !byte $2F,%01000110 + !byte $8B,%00000100 + !byte $B3,%11001101 + !byte $95,%00000110 + !byte $67,%00000010 + !byte $01,%00001100 + !byte $1B,%01101000 + !byte $1B,%10001001; + !byte $AD,%00001100 + !byte $BB,%11101101 + !byte $09,%00010000 + !byte $07,%01101010 + !byte $07,%10001011; + !byte $95,%11100101 + !byte $AF,%10101011 + !byte $01,%11101011 + !byte $27,%00000110 + !byte $49,%10100011 + !byte $61,%01100010 + !byte $61,%10000011; + !byte $6B,%00000010 + !byte $75,%01100100 + !byte $75,%10000101; + !byte $91,%00000100 + !byte $03,%10101011 + !byte $87,%00100100 + !byte $41,%01000010 + !byte $93,%00100100 + !byte $3B,%11100011 + !byte $6F,%01000010 + !byte $95,%11000101 + !byte $B1,%00101010 + !byte $01,%00101100 + !byte $43,%01000010 + !byte $73,%00000100 + !byte $1F,%11100101 + !byte $97,%00101000 + !byte $B7,%00110010 + !byte $39,%10100101 + !byte $4B,%11000011 + !byte $A1,%00101000 + !byte $7F,%10100101 + !byte $21,%11100101 + !byte $5B,%00100100 + !byte $B7,%01010010 + !byte $19,%01001010 + !byte $1B,%00101010 + !byte $1B,%10101001 + !byte $1B,%00000110 + !byte $95,%10100101 + !byte $AD,%01101100 + !byte $AD,%10001101; + !byte $37,%00100110 + !byte $AF,%10101101 + !byte $01,%11001011 + !byte $71,%10100011 + !byte $47,%01100010 + !byte $47,%10000011; + !byte $01,%01010000 + !byte $4D,%11100011 + !byte $BB,%11010001 + !byte $05,%00110000 + !byte $03,%10101101 + !byte $55,%01100100 + !byte $55,%10000101; + !byte $1D,%11100101 + !byte $3F,%01000010 + !byte $19,%01100110 + !byte $19,%10000111; + !byte $3D,%01100010 + !byte $3D,%10000011; + !byte $B5,%11001101 + !byte $05,%01101010 + !byte $05,%10001011; + !byte $19,%10100111 + !byte $57,%01100100 + !byte $57,%10000101; + !byte $5D,%11100011 + !byte $AD,%00101100 + !byte $05,%11101101 + !byte $B1,%00101000 + !byte $39,%01100100 + !byte $39,%10000101; + !byte $59,%01000100 + !byte $89,%00000100 + !byte $A9,%00001000 + !byte $AB,%00001000 + !byte $19,%11000111 + !byte $19,%01000110 + !byte $23,%11100101 + !byte $31,%01000110 + !byte $81,%01100100 + !byte $81,%10000101; + !byte $BD,%11101101 + !byte $1B,%00001010 + !byte $1B,%11001001 + !byte $35,%01000110 + !byte $9F,%00101000 + !byte $AD,%01001100 + !byte $01,%01001100 + !byte $45,%01000010 + !byte $4F,%00000100 + !byte $95,%01100100 + !byte $95,%10000101; + !byte $63,%00100010 + !byte $7B,%11000101 + !byte $AD,%00001000 + !byte $07,%00101110 + !byte $09,%01101110 + !byte $09,%10001111; + !byte $65,%00000010 + !byte $6D,%00000010 + !byte $79,%11000101 + !byte $3B,%11000011 + !byte $75,%01000100 + !byte $B3,%10101001 + !byte $B1,%01001010 + !byte $B3,%01101000 + !byte $B3,%10001001; + !byte $BD,%10110001 + !byte $1B,%11101001 + !byte $8F,%11100011 + !byte $93,%00000100 + !byte $A7,%00001000 + !byte $19,%11100111 + !byte $5F,%10100011 + !byte $B3,%11001001 + !byte $77,%10100101 + !byte $17,%01001010 + !byte $69,%11100001 + !byte $AF,%11001011 + !byte $2D,%00100110 + !byte $8D,%11100011 + !byte $19,%00100110 + !byte $53,%01000100 + !byte $B7,%11001101 + !byte $83,%01000100 + !byte $BF,%11110011 + !byte $37,%00000110 + !byte $95,%01000100 + !byte $39,%01000100 + !byte $01,%10101011 + !byte $29,%00000110 + !byte $91,%11100011 + !byte $99,%00101000 + !byte $AF,%00001000 + !byte $33,%01000110 + !byte $6B,%11100001 + !byte $B3,%01001000 + !byte $BF,%01110000 + !byte $BF,%10010001; + !byte $07,%00010000 + !byte $51,%00100100 + !byte $73,%11100011 + !byte $09,%11101111 + !byte $97,%00001000 + !byte $9D,%00101000 + !byte $67,%11100001 + !byte $1B,%11100101 + !byte $B1,%10101101 + !byte $BF,%11101101 + !byte $B9,%00010010 + !byte $B9,%01110010 + !byte $B9,%10010011; + !byte $BD,%11010011 + !byte $B3,%11101001 + !byte $03,%01101010 + !byte $03,%10001011; + !byte $15,%01001010 + !byte $19,%00001000 + !byte $25,%11100101 + !byte $71,%01100010 + !byte $71,%10000011; + !byte $5B,%00000100 + !byte $61,%01000010 + !byte $85,%00100100 + !byte $0D,%01001010 + !byte $0F,%01001010 + !byte $11,%01001010 + !byte $41,%00100010 + !byte $A5,%00001000 + !byte $13,%01001010 + !byte $9B,%00101000 + !byte $3B,%10100011 + !byte $6F,%00100010 + !byte $03,%11001101 + !byte $0B,%01001010 + !byte $8B,%11100011 + !byte $09,%10101111 + !byte $19,%00000110 + !byte $7D,%10100101 + !byte $BB,%10110011 + !byte $3D,%01000010 + !byte $49,%01100010 + !byte $49,%10000011; + !byte $39,%00100100 + !byte $43,%00100010 + !byte $09,%01001010 + !byte $03,%00110000 + !byte $09,%11001111 + !byte $19,%00101010 + !byte $19,%00101000 + !byte $95,%00100100 + !byte $B3,%00101000 + !byte $B1,%01101010 + !byte $B1,%10001011; + !byte $B1,%00001000 + !byte $3F,%00100010 + !byte $AF,%01101100 + !byte $AF,%10001101; + !byte $B9,%11001101 + !byte $01,%01101100 + !byte $01,%10001101; + !byte $05,%00001110 + !byte $93,%11100011 + !byte $B3,%00001010 + !byte $37,%11100101 + !byte $1F,%11000101 + !byte $75,%00100100 + !byte $AF,%11101011 + !byte $1D,%11000101 + !byte $07,%01001010 + !byte $4B,%10100011 + !byte $97,%11100111 + !byte $35,%00100110 + !byte $21,%11000101 + !byte $47,%01000010 + !byte $57,%01000100 + !byte $A3,%00001000 + !byte $B9,%00110010 + !byte $5D,%11000011 + !byte $BB,%11110001 + !byte $B9,%01010010 + !byte $87,%00000100 + !byte $07,%01001110 + !byte $6D,%11100001 + !byte $B3,%10101101 + !byte $2F,%00100110 + !byte $55,%01000100 + !byte $27,%11100101 + !byte $63,%00000010 + !byte $77,%01100100 + !byte $77,%10000101; + !byte $59,%00100100 + !byte $65,%11100001 + !byte $39,%00000100 + !byte $2B,%00000110 + !byte $79,%10100101 + !byte $BB,%11001101 + !byte $01,%01101010 + !byte $01,%10001011; + !byte $73,%11000011 + !byte $45,%00100010 + !byte $19,%01001000 + !byte $69,%11000001 + !byte $19,%11100101 + !byte $4D,%11000011 + !byte $7F,%01100100 + !byte $7F,%10000101; + !byte $95,%00000100 + !byte $05,%01001010 + !byte $3B,%01100010 + !byte $3B,%10000011; + !byte $7B,%10100101 + !byte $8F,%11000011 + !byte $1B,%11000101 + !byte $91,%11000011 + !byte $5F,%01100010 + !byte $5F,%10000011; + !byte $71,%01000010 + !byte $6B,%11000001 + !byte $6F,%00000010 + !byte $97,%11000111 + !byte $4F,%11100011 + !byte $67,%11000001 + !byte $AD,%11100111 + !byte $AF,%00001100 + !byte $BD,%11010001 + !byte $37,%11000101 + !byte $3D,%00100010 + !byte $AF,%01001100 + !byte $89,%11100011 + !byte $99,%00001000 + !byte $A1,%00001000 + !byte $8D,%11000011 + !byte $AB,%11100111 + !byte $B3,%00001000 + !byte $23,%11000101 + !byte $39,%11100011 + !byte $B3,%00101010 + !byte $97,%10100111 + !byte $B5,%01101000 + !byte $B5,%10001001; + !byte $07,%11101111 + !byte $17,%00101010 + !byte $19,%00001010 + !byte $53,%00100100 + !byte $05,%00010000 + !byte $31,%00100110 + !byte $61,%00100010 + !byte $AF,%11100111 + !byte $01,%10101101 + !byte $51,%00000100 + !byte $17,%01000110 + !byte $33,%00100110 + !byte $41,%00000010 + !byte $97,%11100101 + !byte $97,%01100110 + !byte $97,%10000111; + !byte $81,%01000100 + !byte $97,%00000110 + !byte $BD,%11001101 + !byte $19,%01101000 + !byte $19,%10001001; + !byte $B5,%10101001 + !byte $AF,%00101100 + !byte $B5,%01001000 + !byte $03,%01001010 + !byte $17,%01100110 + !byte $17,%10000111; + !byte $17,%00100110 + !byte $75,%00000100 + !byte $97,%11000101 + !byte $97,%00100110 + !byte $97,%01000110 + !byte $B5,%10101101 + !byte $A9,%11100111 + !byte $B1,%10101011 + !byte $01,%00110000 + !byte $5B,%11100011 + !byte $93,%11000011 + !byte $BB,%01110010 + !byte $BB,%10010011; + !byte $97,%10100101 + !byte $3F,%00000010 + !byte $BF,%10110001 + !byte $03,%11101101 + !byte $B1,%01101100 + !byte $B1,%10001101; + !byte $BF,%11010011 + !byte $17,%10100111 + !byte $35,%00000110 + !byte $73,%10100011 + !byte $43,%00000010 + !byte $95,%11100011 + !byte $07,%01101110 + !byte $07,%10001111; + !byte $19,%11000101 + !byte $37,%10100101 + !byte $3B,%01000010 + !byte $B1,%11100111 + !byte $19,%11101001 + !byte $19,%10101001 + !byte $17,%00000110 + !byte $39,%11000011 + !byte $83,%00100100 + !byte $B5,%00101000 + !byte $9F,%00001000 + !byte $97,%01100100 + !byte $97,%10000101; + !byte $05,%00101110 + !byte $71,%00100010 + !byte $9B,%00001000 + !byte $2D,%00000110 + !byte $6D,%11000001 + !byte $B5,%11001001 + !byte $29,%11100101 + !byte $17,%11000111 + !byte $77,%01000100 + !byte $19,%11001001 + !byte $25,%11000101 + !byte $15,%00101010 + !byte $49,%01000010 + !byte $63,%11100001 + !byte $8B,%11000011 + !byte $A7,%11100111 + !byte $BB,%00010010 + !byte $BD,%10110011 + !byte $1D,%10100101 + !byte $65,%11000001 + !byte $9D,%00001000 + !byte $6F,%11100001 + !byte $97,%01000100 + !byte $5D,%10100011 + !byte $85,%00000100 + !byte $01,%01001010 + !byte $1F,%10100101 + !byte $37,%01100100 + !byte $37,%10000101; + !byte $47,%00100010 + !byte $57,%00100100 + !byte $69,%10100001 + !byte $B3,%01001010 + !byte $B7,%10101101 + !byte $07,%11001111 + !byte $7D,%01100100 + !byte $7D,%10000101; + !byte $BF,%11001101 + !byte $17,%11100101 + !byte $4B,%01100010 + !byte $4B,%10000011; + !byte $07,%10101111 + !byte $1B,%10100101 + !byte $79,%01100100 + !byte $79,%10000101; + !byte $3D,%00000010 + !byte $59,%00000100 + !byte $99,%11100111 + !byte $17,%11100111 + !byte $55,%00100100 + !byte $B1,%11001011 + !byte $6B,%10100001 + !byte $B3,%11100111 + !byte $5F,%01000010 + !byte $97,%00100100 + !byte $13,%00101010 + !byte $8F,%10100011 + !byte $91,%10100011 + !byte $B5,%00001000 + !byte $B5,%11101001 + !byte $03,%00010000 + !byte $39,%10100011 + !byte $45,%00000010 + !byte $95,%11000011 + !byte $A5,%11100111 + !byte $67,%10100001 + !byte $01,%11001101 + !byte $BB,%01010010 + !byte $09,%00101010 + !byte $0B,%00101010 + !byte $0D,%00101010 + !byte $3B,%00100010 + !byte $BB,%00110010 + !byte $11,%00101010 + !byte $21,%10100101 + !byte $37,%01000100 + !byte $75,%11100011 + !byte $0F,%00101010 + !byte $35,%11100101 + !byte $4D,%10100011 + !byte $73,%01100010 + !byte $73,%10000011; + !byte $93,%10100011 + !byte $B9,%10101101 + !byte $BD,%11110001 + !byte $61,%00000010 + !byte $7B,%01100100 + !byte $7B,%10000101; + !byte $87,%11100011 + !byte $B3,%01101100 + !byte $B3,%10001101; + !byte $05,%11101111 + !byte $07,%00101010 + !byte $41,%11100001 + !byte $97,%00000100 + !byte $B1,%01001100 + !byte $19,%10100101 + !byte $17,%00001010 + !byte $17,%11000101 + !byte $33,%00000110 + !byte $3F,%11100001 + !byte $17,%00001000 + !byte $2F,%00000110 + !byte $77,%00100100 + !byte $05,%00101010 + !byte $7F,%01000100 + !byte $5B,%11000011 + !byte $8D,%10100011 + !byte $71,%00000010 + !byte $43,%11100001 + !byte $53,%00000100 + !byte $A3,%11100111 + !byte $05,%01001110 + !byte $27,%11000101 + !byte $37,%00100100 + !byte $4F,%11000011 + !byte $89,%11000011 + !byte $51,%11100011 + !byte $99,%11000111 + !byte $AD,%11000111 + !byte $AF,%11000111 + !byte $03,%00001110 + !byte $6D,%10100001 + !byte $B1,%11101011 + !byte $39,%01100010 + !byte $39,%10000011; + !byte $2B,%11100101 + !byte $B5,%11100111 + !byte $B1,%11000111 + !byte $B5,%00001010 + !byte $23,%10100101 + !byte $03,%00101010 + !byte $31,%00000110 + !byte $65,%10100001 + !byte $B7,%01001000 + !byte $6F,%11000001 + !byte $B3,%01101010 + !byte $B3,%10001011; + !byte $BB,%10101101 + !byte $BF,%11010001 + !byte $BD,%01110010 + !byte $BD,%10010011; + !byte $AB,%11000111 + !byte $B7,%01101000 + !byte $B7,%10001001; + !byte $97,%11100011 + !byte $B7,%00101000 + !byte $17,%00101000 + !byte $3D,%11100001 + !byte $BF,%10110011 + !byte $9B,%11100111 + !byte $57,%00000100 + !byte $69,%01100000 + !byte $69,%10000001; + !byte $79,%01000100 + !byte $B1,%00001100 + !byte $B1,%00101100 + !byte $3B,%00000010 + !byte $5D,%01100010 + !byte $5D,%10000011; + !byte $95,%10100011 + !byte $75,%11000011 + !byte $81,%00100100 + !byte $37,%00000100 + !byte $35,%11000101 + !byte $6B,%01100000 + !byte $6B,%10000001; + !byte $73,%01000010 + !byte $63,%11000001 + !byte $A1,%11100111 + !byte $17,%11101001 + !byte $1B,%01100100 + !byte $1B,%10000101; + !byte $39,%01000010 + !byte $49,%00100010 + !byte $59,%11100011 + !byte $B7,%10101001 + !byte $B5,%01101100 + !byte $B5,%10001101; + !byte $B7,%00001000 + !byte $15,%00100110 + !byte $17,%10100101 + !byte $1D,%01100100 + !byte $1D,%10000101; + !byte $91,%01100010 + !byte $91,%10000011; + !byte $15,%00001010 + !byte $67,%01100000 + !byte $67,%10000001; + !byte $99,%10100111 + !byte $A9,%11000111 + !byte $B3,%11000111 + !byte $5F,%00100010 + !byte $01,%00010000 + !byte $01,%00101010 + !byte $15,%01000110 + !byte $15,%00000110 + !byte $55,%00000100 + !byte $05,%11001111 + !byte $05,%01101110 + !byte $05,%10001111; + !byte $8B,%10100011 + !byte $17,%01001000 + !byte $47,%00000010 + !byte $77,%00000100 + !byte $93,%01100010 + !byte $93,%10000011; + !byte $9F,%11100111 + !byte $BD,%00010010 + !byte $83,%00000100 + !byte $9D,%11100111 + !byte $BD,%10101101 + !byte $45,%11100001 + !byte $1F,%01100100 + !byte $1F,%10000101; + !byte $15,%11100101 + !byte $37,%11100011 + !byte $3F,%11000001 + !byte $7D,%01000100 + !byte $4B,%01000010 + !byte $61,%11100001 + !byte $8F,%01100010 + !byte $8F,%10000011; + !byte $97,%11000011 + !byte $01,%11101101 + !byte $19,%01100100 + !byte $19,%10000101; + !byte $41,%11000001 + !byte $15,%01100110 + !byte $15,%10000111; + !byte $99,%01100110 + !byte $99,%10000111; + !byte $B5,%00101010 + !byte $03,%11101111 + !byte $17,%11001001 + !byte $17,%01101000 + !byte $17,%10001001; + !byte $29,%11000101 + !byte $2D,%11100101 + !byte $33,%11100101 + !byte $71,%11100001 + !byte $85,%11100011 + !byte $B7,%11001001 + !byte $B3,%10101011 + !byte $B3,%01001100 + !byte $BD,%01010010 + !byte $05,%10101111 + !byte $03,%00101110 + !byte $35,%10100101 + !byte $6D,%01100000 + !byte $6D,%10000001; + !byte $7B,%01000100 + !byte $25,%10100101 + !byte $99,%01000110 + !byte $B5,%11000111 + !byte $A7,%11000111 + !byte $B7,%11100111 + !byte $17,%10101001 + !byte $15,%10100111 + !byte $5B,%10100011 + !byte $6F,%10100001 + !byte $75,%10100011 + !byte $3D,%11000001 + !byte $4D,%01100010 + !byte $4D,%10000011; + !byte $73,%00100010 + !byte $99,%01100100 + !byte $99,%10000101; + !byte $BF,%10101101 + !byte $BD,%00110010 + !byte $15,%11000101 + !byte $99,%10100101 + !byte $99,%11000101 + !byte $99,%11100101 + !byte $99,%00000110 + !byte $99,%00100110 + !byte $13,%00001010 + !byte $B7,%01101100 + !byte $B7,%10001101; + !byte $3B,%11100001 + !byte $95,%01100010 + !byte $95,%10000011; + !byte $39,%00100010 + !byte $43,%11000001 + !byte $99,%01000100 + !byte $BF,%11110001 + !byte $21,%01100100 + !byte $21,%10000101; + !byte $5D,%01000010 + !byte $8D,%01100010 + !byte $8D,%10000011; + !byte $97,%10100011 + !byte $9B,%11000111 + !byte $37,%11000011 + !byte $53,%11100011 + !byte $69,%01000000 + !byte $17,%01100100 + !byte $17,%10000101; + !byte $99,%00100100 + !byte $15,%11000111 + !byte $87,%11000011 + !byte $A5,%11000111 + !byte $4F,%10100011 + !byte $65,%01100000 + !byte $65,%10000001; + !byte $6B,%01000000 + !byte $79,%00100100 + !byte $2F,%11100101 + !byte $11,%00001010 + !byte $35,%01100100 + !byte $35,%10000101; + !byte $63,%10100001 + !byte $7F,%00100100 + !byte $B3,%11001011 + !byte $BF,%01110010 + !byte $BF,%10010011; + !byte $51,%11000011 + !byte $0F,%00001010 + !byte $31,%11100101 + !byte $57,%11100011 + !byte $B7,%11101001 + !byte $15,%10100101 + !byte $59,%11000011 + !byte $B1,%10100111 + !byte $89,%10100011 + !byte $AF,%10100111 + !byte $B5,%01001010 + !byte $B9,%01101100 + !byte $B9,%10001101; + !byte $0B,%00001010 + !byte $0D,%00001010 + !byte $77,%11100011 + !byte $07,%00001010 + !byte $09,%00001010 + !byte $5F,%00000010 + !byte $71,%11000001 + !byte $99,%00000100 + !byte $37,%10100011 + !byte $B9,%00101000 + !byte $B3,%00101100 + !byte $39,%00000010 + !byte $B7,%11000111 + !byte $05,%00001010 + !byte $15,%11101001 + !byte $67,%01000000 + !byte $B3,%10100111 + !byte $1B,%01000100 + !byte $91,%01000010 + !byte $AD,%10100111 + !byte $B9,%01001000 + !byte $33,%11000101 + !byte $93,%01000010 + !byte $03,%01001110 + !byte $03,%11001111 + !byte $19,%01000100 + !byte $3F,%10100001 + !byte $49,%00000010 + !byte $6F,%01100000 + !byte $6F,%10000001; + !byte $B9,%00001000 + !byte $2B,%11000101 + !byte $81,%00000100 + !byte $99,%11100011 + !byte $B5,%01001100 + !byte $03,%00001010 + !byte $15,%11100111 + !byte $3B,%11000001 + !byte $61,%11000001 + !byte $75,%01100010 + !byte $75,%10000011; + !byte $23,%01100100 + !byte $23,%10000101; + !byte $55,%11100011 + !byte $97,%01100010 + !byte $97,%10000011; + !byte $47,%11100001 + !byte $73,%00000010 + !byte $1D,%01000100 + !byte $27,%10100101 + !byte $41,%10100001 + !byte $6D,%01000000 + !byte $35,%01000100 + !byte $01,%00001110 + !byte $B3,%11101011 + !byte $A3,%11000111 + !byte $01,%11101111 + !byte $95,%01000010 + !byte $B9,%11100111 + !byte $B3,%00001100 + !byte $8F,%01000010 + !byte $B5,%10100111 + !byte $01,%00001010 + !byte $37,%01100010 + !byte $37,%10000011; + !byte $3D,%10100001 + !byte $9D,%11000111 + !byte $B9,%01101000 + !byte $B9,%10001001; + !byte $BB,%01101100 + !byte $BB,%10001101; + !byte $AB,%10100111 + !byte $BF,%00010010 + !byte $45,%11000001 + !byte $7D,%00100100 + !byte $9B,%10100111 + !byte $8B,%01100010 + !byte $8B,%10000011; + !byte $7B,%00100100 + !byte $99,%11000011 + !byte $15,%01100100 + !byte $15,%10000101; + !byte $17,%01000100 + !byte $4B,%00100010 + !byte $15,%00001000 + !byte $79,%00000100 + !byte $A1,%11000111 + !byte $5D,%00100010 + !byte $5B,%01100010 + !byte $5B,%10000011; + !byte $B7,%00001010 + !byte $03,%01101110 + !byte $03,%10001111; + !byte $1F,%01000100 + !byte $69,%00100000 + !byte $71,%10100001 + !byte $B9,%10101001 + !byte $B5,%01101010 + !byte $B5,%10001011; + !byte $83,%11100011 + !byte $BF,%01010010 + !byte $03,%10101111 + !byte $9F,%11000111 + !byte $15,%11001001 + !byte $13,%00000110 + !byte $35,%00100100 + !byte $6B,%00100000 + !byte $13,%11100101 + !byte $77,%11000011 + !byte $65,%01000000 + !byte $37,%01000010 + !byte $43,%10100001 + !byte $13,%00100110 + !byte $39,%11100001 + !byte $13,%11101001 + !byte $63,%01100000 + !byte $63,%10000001; + !byte $B7,%10100111 + !byte $BD,%01101100 + !byte $BD,%10001101; + !byte $13,%11000101 + !byte $4D,%01000010 + !byte $A9,%10100111 + !byte $15,%00101000 + !byte $75,%01000010 + !byte $85,%11000011 + !byte $BF,%00110010 + !byte $2D,%11000101 + !byte $B9,%11000111 + !byte $B7,%01001100 + !byte $33,%10100101 + !byte $53,%11000011 + !byte $57,%11000011 + !byte $73,%11100001 + !byte $9B,%01100110 + !byte $9B,%10000111; + !byte $13,%01000110 + !byte $31,%11000101 + !byte $3B,%10100001 + !byte $59,%10100011 + !byte $5F,%11100001 + !byte $67,%00100000 + !byte $97,%01000010 + !byte $99,%10100011 + !byte $8D,%01000010 + !byte $15,%10101001 + !byte $15,%01001000 + !byte $29,%10100101 + !byte $4F,%01100010 + !byte $4F,%10000011; + !byte $6D,%00100000 + !byte $6F,%01000000 + !byte $93,%00100010 + !byte $01,%00101110 + !byte $25,%01100100 + !byte $25,%10000101; + !byte $13,%10100101 + !byte $15,%01000100 + !byte $35,%00000100 + !byte $3F,%01100000 + !byte $3F,%10000001; + !byte $B5,%00101100 + !byte $51,%10100011 + !byte $7F,%00000100 + !byte $21,%01000100 + !byte $61,%10100001 + !byte $2F,%11000101 + !byte $A7,%10100111 + !byte $15,%01101000 + !byte $15,%10001001; + !byte $91,%00100010 + !byte $B9,%11001001 + !byte $B5,%10101011 + !byte $39,%11000001 + !byte $19,%00100100 + !byte $87,%10100011 + !byte $11,%11101001 + !byte $37,%00100010 + !byte $3D,%01100000 + !byte $3D,%10000001; + !byte $B7,%00101010 + !byte $13,%01100110 + !byte $13,%10000111; + !byte $95,%00100010 + !byte $9B,%01000110 + !byte $1B,%00100100 + !byte $41,%01100000 + !byte $41,%10000001; + !byte $55,%11000011 + !byte $5B,%01000010 + !byte $77,%10100011 + !byte $B3,%01100110 + !byte $B3,%10000111; + !byte $BF,%01101100 + !byte $BF,%10001101; + !byte $B1,%01100110 + !byte $B1,%10000111; + !byte $35,%11100011 + !byte $9D,%10100111 + !byte $01,%11001111 + !byte $17,%00100100 + !byte $99,%01100010 + !byte $99,%10000011; + !byte $47,%11000001 + !byte $7B,%00000100 + !byte $BB,%00001000 + !byte $B9,%10100111 + !byte $13,%01100100 + !byte $13,%10000101; + !byte $49,%11100001 + !byte $89,%01100010 + !byte $89,%10000011; + !byte $9B,%00100110 + !byte $AF,%01100110 + !byte $AF,%10000111; + !byte $75,%00100010 + !byte $BB,%11100111 + !byte $BB,%00101000 + !byte $5D,%00000010 + !byte $79,%11100011 + !byte $B5,%01100110 + !byte $B5,%10000111; + !byte $0F,%11101001 + !byte $13,%10100111 + !byte $71,%01100000 + !byte $71,%10000001; + !byte $69,%00000000 + !byte $45,%10100001 + !byte $B9,%01001100 + !byte $1D,%00100100 + !byte $33,%01100100 + !byte $33,%10000101; + !byte $6B,%00000000 + !byte $9B,%00000110 + !byte $37,%00000010 + !byte $73,%11000001 + !byte $8F,%00100010 + !byte $A5,%10100111 + !byte $81,%11100011 + !byte $9B,%11100101 + !byte $BB,%01001000 + !byte $65,%00100000 + !byte $7D,%00000100 + !byte $97,%00100010 + !byte $9B,%01000100 + !byte $9B,%01100100 + !byte $9B,%10000101; + !byte $9B,%10100101 + !byte $9B,%11000101 + !byte $B5,%11001011 + !byte $0D,%11101001 + !byte $AD,%01100110 + !byte $AD,%10000111; + !byte $9B,%00100100 + !byte $B5,%00001100 + !byte $13,%11001001 + !byte $01,%01001110 + !byte $63,%01000000 + !byte $0B,%11101001 + !byte $3B,%01100000 + !byte $3B,%10000001; + !byte $4B,%00000010 + !byte $9B,%00000100 + !byte $B9,%11101001 + !byte $03,%11101001 + !byte $05,%11101001 + !byte $07,%11101001 + !byte $09,%11101001 + !byte $2B,%10100101 + !byte $35,%11000011 + !byte $B7,%01100110 + !byte $B7,%10000111; + !byte $BB,%11000111 + !byte $6F,%00100000 + !byte $B5,%11101011 + !byte $13,%11000111 + !byte $15,%00100100 + !byte $43,%01100000 + !byte $43,%10000001; + !byte $67,%00000000 + !byte $99,%01000010 + !byte $23,%01000100 + !byte $B7,%01001010 + !byte $01,%11101001 + !byte $31,%10100101 + !byte $9F,%10100111 + !byte $8B,%01000010 + !byte $A3,%10100111 + !byte $13,%01000100 + !byte $6D,%00000000 + !byte $39,%10100001 + !byte $9B,%11100011 + !byte $01,%10101111 + !byte $27,%01100100 + !byte $27,%10000101; + !byte $57,%10100011 + !byte $5F,%11000001 + !byte $83,%11000011 + !byte $33,%01000100 + !byte $1F,%00100100 + !byte $53,%10100011 + !byte $59,%01100010 + !byte $59,%10000011; + !byte $77,%01100010 + !byte $77,%10000011; + !byte $BB,%01101000 + !byte $BB,%10001001; + !byte $BB,%01001100 + !byte $35,%10100011 + !byte $B7,%00101100 + !byte $01,%01101110 + !byte $01,%10001111; + !byte $9D,%01100110 + !byte $9D,%10000111; + !byte $3F,%01000000 + !byte $4D,%00100010 + !byte $A1,%10100111 + !byte $AB,%01100110 + !byte $AB,%10000111; + !byte $61,%01100000 + !byte $61,%10000001; + !byte $93,%00000010 + !byte $9B,%11000011 + !byte $3D,%01000000 + !byte $95,%00000010 + !byte $4F,%01000010 + !byte $37,%11100001 + !byte $B9,%01100110 + !byte $B9,%10000111; + !byte $75,%00000010 + !byte $79,%11000011 + !byte $51,%01100010 + !byte $51,%10000011; + !byte $13,%11100111 + !byte $71,%01000000 + !byte $BB,%10100111 + !byte $2D,%10100101 + !byte $5B,%00100010 + !byte $11,%11000101 + !byte $41,%01000000 + !byte $91,%00000010 + !byte $13,%10101001 + !byte $2F,%10100101 + !byte $35,%01100010 + !byte $35,%10000011; + !byte $9B,%10100011 + !byte $11,%11100101 + !byte $8D,%00100010 + !byte $73,%10100001 + !byte $11,%10100101 + !byte $97,%00000010 + !byte $19,%00000100 + !byte $55,%10100011 + !byte $85,%10100011 + !byte $13,%00100100 + !byte $99,%00100010 + !byte $11,%11001001 + !byte $7F,%11100011 + !byte $3B,%01000000 + !byte $7B,%11100011 + !byte $11,%00000110 + !byte $17,%00000100 + !byte $13,%00001000 + !byte $33,%00100100 + !byte $39,%01100000 + !byte $39,%10000001; + !byte $5D,%11100001 + !byte $A9,%01100110 + !byte $A9,%10000111; + !byte $B9,%00001010 + !byte $B7,%01101010 + !byte $B7,%10001011; + !byte $65,%00000000 + !byte $87,%01100010 + !byte $87,%10000011; + !byte $11,%01100100 + !byte $11,%10000101; + !byte $9B,%01100010 + !byte $9B,%10000011; + !byte $1B,%00000100 + !byte $BB,%10101001 + !byte $25,%01000100 + !byte $BD,%01001100 + !byte $37,%11000001 + !byte $29,%01100100 + !byte $29,%10000101; + !byte $63,%00100000 + !byte $B3,%01000110 + !byte $11,%00100110 + !byte $47,%10100001 + !byte $13,%01101000 + !byte $13,%10001001; + !byte $15,%00000100 + !byte $45,%01100000 + !byte $45,%10000001; + !byte $77,%01000010 + !byte $9D,%01000110 + !byte $49,%11000001 + !byte $6F,%00000000 + !byte $B5,%01000110 + !byte $31,%01100100 + !byte $31,%10000101; + !byte $35,%01000010 + !byte $B9,%00101100 + !byte $13,%00101000 + !byte $21,%00100100 + !byte $B1,%01000110 + !byte $7D,%11100011 + !byte $BD,%11100111 + !byte $BD,%00001000 + !byte $13,%01001000 + !byte $59,%01000010 + !byte $B7,%01000110 + !byte $BB,%01100110 + !byte $BB,%10000111; + !byte $B7,%00001100 + !byte $A7,%01100110 + !byte $A7,%10000111; + !byte $BD,%11000111 + !byte $11,%01000110 + !byte $5F,%10100001 + !byte $8F,%00000010 + !byte $75,%11100001 + !byte $0F,%11001001 + !byte $89,%01000010 + !byte $11,%01000100 + !byte $BF,%01001100 + !byte $3D,%00100000 + !byte $43,%01000000 + !byte $79,%10100011 + !byte $9F,%01100110 + !byte $9F,%10000111; + !byte $B7,%10101011 + !byte $33,%00000100 + !byte $71,%00100000 + !byte $3F,%00100000 + !byte $BD,%00101000 + !byte $BB,%11001001 + !byte $1D,%00000100 + !byte $4B,%11100001 + !byte $57,%01100010 + !byte $57,%10000011; + !byte $61,%01000000 + !byte $99,%00000010 + !byte $9B,%01000010 + !byte $95,%11100001 + !byte $AF,%01000110 + !byte $53,%01100010 + !byte $53,%10000011; + !byte $73,%01100000 + !byte $73,%10000001; + !byte $81,%11000011 + !byte $13,%00000100 + !byte $35,%00100010 + !byte $93,%11100001 + !byte $9D,%00100110 + !byte $4D,%00000010 + !byte $B9,%01000110 + !byte $39,%01000000 + !byte $B7,%11101011 + !byte $37,%10100001 + !byte $BD,%10100111 + !byte $B9,%00101010 + !byte $2B,%01100100 + !byte $2B,%10000101; + !byte $A5,%01100110 + !byte $A5,%10000111; + !byte $11,%01100110 + !byte $11,%10000111; + !byte $3B,%00100000 + !byte $B7,%11001011 + !byte $0D,%11001001 + !byte $97,%11100001 + !byte $BD,%01001000 + !byte $11,%00100100 + !byte $8B,%00100010 + !byte $7B,%11000011 + !byte $AD,%01000110 + !byte $5B,%00000010 + !byte $41,%00100000 + !byte $33,%11100011 + !byte $51,%01000010 + !byte $23,%00100100 + !byte $77,%00100010 + !byte $0B,%11001001 + !byte $11,%10101001 + !byte $35,%00000010 + !byte $4F,%00100010 + !byte $A1,%01100110 + !byte $A1,%10000111; + !byte $83,%10100011 + !byte $03,%11001001 + !byte $05,%11001001 + !byte $27,%01000100 + !byte $9D,%00000110 + !byte $A3,%01100110 + !byte $A3,%10000111; + !byte $2F,%01100100 + !byte $2F,%10000101; + !byte $9B,%00100010 + !byte $31,%01000100 + !byte $5D,%11000001 + !byte $01,%11001001 + !byte $07,%11001001 + !byte $09,%11001001 + !byte $17,%11100011 + !byte $55,%01100010 + !byte $55,%10000011; + !byte $BB,%00101100 + !byte $91,%11100001 + !byte $63,%00000000 + !byte $75,%11000001 + !byte $1F,%00000100 + !byte $BB,%01000110 + !byte $2D,%01100100 + !byte $2D,%10000101; + !byte $11,%10100111 + !byte $15,%11100011 + !byte $9D,%11100101 + !byte $BD,%01100110 + !byte $BD,%10000111; + !byte $19,%11100011 + !byte $37,%01100000 + !byte $37,%10000001; + !byte $85,%01100010 + !byte $85,%10000011; + !byte $9D,%11000101 + !byte $BB,%11101001 + !byte $33,%11000011 + !byte $7F,%11000011 + !byte $8D,%00000010 + !byte $9D,%00100100 + !byte $99,%11100001 + !byte $9D,%01000100 + !byte $9D,%01100100 + !byte $9D,%10000101; + !byte $9D,%10100101 + !byte $9D,%11100011 + !byte $AB,%01000110 + !byte $73,%01000000 + !byte $9D,%00000100 + !byte $BD,%01101000 + !byte $BD,%10001001; + !byte $35,%11100001 + !byte $B9,%01001010 + !byte $11,%00000100 + !byte $47,%01100000 + !byte $47,%10000001; + !byte $9F,%01000110 + !byte $5F,%01100000 + !byte $5F,%10000001; + !byte $79,%01100010 + !byte $79,%10000011; + !byte $B9,%00001100 + !byte $59,%00100010 + !byte $11,%11000111 + !byte $3D,%00000000 + !byte $49,%10100001 + !byte $7D,%11000011 + !byte $9D,%11000011 + !byte $45,%01000000 + !byte $71,%00000000 + !byte $0F,%10100101 + !byte $3F,%00000000 + !byte $9B,%00000010 + !byte $0F,%01100100 + !byte $0F,%10000101; + !byte $13,%11100011 + !byte $1B,%11100011 + !byte $57,%01000010 + !byte $39,%00100000 + !byte $0F,%11000101 + !byte $43,%00100000 + !byte $9D,%10100011 + !byte $11,%01101000 + !byte $11,%10001001; + !byte $B5,%00100110 + !byte $B7,%00100110 + !byte $33,%10100011 + !byte $0F,%10101001 + !byte $87,%01000010 + !byte $95,%11000001 + !byte $B3,%00100110 + !byte $BD,%00101100 + !byte $3B,%00000000 + !byte $77,%00000010 + !byte $0F,%11100101 + !byte $31,%00100100 + !byte $97,%11000001 + !byte $BF,%11000111 + !byte $0F,%01000100 + !byte $BF,%11100111 + !byte $21,%00000100 + !byte $29,%01000100 + !byte $75,%10100001 + !byte $8F,%11100001 + !byte $B9,%00100110 + !byte $BD,%01000110 + !byte $9D,%01100010 + !byte $9D,%10000011; + !byte $A9,%01000110 + !byte $61,%00100000 + !byte $53,%01000010 + !byte $11,%11100111 + !byte $7B,%10100011 + !byte $25,%00100100 + !byte $93,%11000001 + !byte $BF,%10100111 + !byte $0F,%00000110 + !byte $81,%10100011 + !byte $BF,%00001000 + !byte $4B,%11000001 + !byte $2F,%01000100 + !byte $35,%11000001 + !byte $37,%01000000 + !byte $B1,%00100110 + !byte $B9,%01101010 + !byte $B9,%10001011; + !byte $5B,%11100001 + !byte $11,%01001000 + !byte $1D,%11100011 + !byte $33,%01100010 + !byte $33,%10000011; + !byte $4D,%11100001 + !byte $73,%00100000 + !byte $41,%00000000 + !byte $BD,%10101001 + !byte $89,%00100010 + !byte $9D,%01000010 + !byte $B9,%11101011 + !byte $11,%00001000 + !byte $0F,%00100100 + !byte $BB,%00100110 + !byte $BB,%00001010 + !byte $5D,%10100001 + !byte $A1,%01000110 + !byte $55,%01000010 + !byte $11,%00101000 + !byte $11,%11100011 + !byte $8B,%00000010 + !byte $99,%11000001 + !byte $9B,%11100001 + !byte $9F,%00100110 + !byte $79,%01000010 + !byte $A7,%01000110 + !byte $BF,%01100110 + !byte $BF,%10000111; + !byte $0F,%00100110 + !byte $39,%00000000 + !byte $BF,%00101000 + !byte $0D,%10101001 + !byte $15,%11000011 + !byte $31,%00000100 + !byte $4F,%00000010 + !byte $B9,%10101011 + !byte $BF,%00101100 + !byte $51,%00100010 + !byte $BB,%00001100 + !byte $17,%11000011 + !byte $35,%10100001 + !byte $9D,%00100010 + !byte $AF,%00100110 + !byte $2B,%01000100 + !byte $77,%11100001 + !byte $B9,%11001011 + !byte $2D,%01000100 + !byte $33,%01000010 + !byte $91,%11000001 + !byte $0F,%00000100 + !byte $13,%11000011 + !byte $A3,%01000110 + !byte $5F,%01000000 + !byte $75,%01100000 + !byte $75,%10000001; + !byte $A5,%01000110 + !byte $19,%11000011 + !byte $37,%00100000 + !byte $83,%01100010 + !byte $83,%10000011; + !byte $0F,%01000110 + !byte $59,%00000010 + !byte $7F,%10100011 + !byte $0B,%10101001 + !byte $7D,%10100011 + !byte $BD,%00100110 + !byte $BD,%11001001 + !byte $8D,%11100001 + !byte $47,%01000000 + !byte $45,%00100000 + !byte $57,%00100010 + !byte $BF,%01000110 + !byte $0F,%01101000 + !byte $0F,%10001001; + !byte $1F,%11100011 + !byte $9F,%00000110 + !byte $BF,%01001000 + !byte $27,%00100100 + !byte $23,%00000100 + !byte $BB,%00101010 + !byte $97,%10100001 + !byte $95,%10100001 + !byte $9B,%11000001 + !byte $AD,%00100110 + !byte $09,%10101001 + !byte $31,%11100011 + !byte $33,%00100010 + !byte $43,%00000000 + !byte $9D,%00000010 + !byte $61,%00000000 + !byte $7B,%01100010 + !byte $7B,%10000011; + !byte $01,%10101001 + !byte $03,%10101001 + !byte $05,%10101001 + !byte $07,%10101001 + !byte $11,%11000011 + !byte $35,%01100000 + !byte $35,%10000001; + !byte $49,%01100000 + !byte $49,%10000001; + !byte $85,%01000010 + !byte $0F,%01100110 + !byte $0F,%10000111; + !byte $2F,%00100100 + !byte $73,%00000000 + !byte $0F,%11100011 + !byte $4B,%10100001 + !byte $79,%00100010 + !byte $99,%10100001 + !byte $1B,%11000011 + !byte $5B,%11000001 + !byte $77,%11000001 + !byte $93,%10100001 + !byte $B7,%00000110 + !byte $B9,%00000110 + !byte $8F,%11000001 + !byte $9F,%11100101 + !byte $BD,%00001100 + !byte $A1,%00100110 + !byte $33,%00000010 + !byte $75,%01000000 + !byte $AB,%00100110 + !byte $B5,%00000110 + !byte $53,%00100010 + !byte $5D,%01100000 + !byte $5D,%10000001; + !byte $BB,%11101011 + !byte $9D,%11100001 + !byte $BB,%00000110 + !byte $37,%00000000 + !byte $31,%11000011 + !byte $0D,%01100100 + !byte $0D,%10000101; + !byte $0D,%01000100 + !byte $55,%00100010 + !byte $87,%00100010 + !byte $BF,%00100110 + !byte $35,%01000000 + !byte $BD,%11101001 + !byte $BB,%01001010 + !byte $0D,%10100101 + !byte $29,%00100100 + !byte $9F,%11000101 + !byte $BF,%01101000 + !byte $BF,%10001001; + !byte $0F,%10100111 + !byte $0F,%01001000 + !byte $89,%00000010 + !byte $0D,%00100100 + !byte $4D,%11000001 + !byte $81,%01100010 + !byte $81,%10000011; + !byte $B3,%00000110 + !byte $0D,%01101000 + !byte $0D,%10001001; + !byte $9B,%10100001 + !byte $15,%10100011 + !byte $33,%11100001 + !byte $5F,%00100000 + !byte $9F,%10100101 + !byte $9F,%11100011 + !byte $9F,%00000100 + !byte $0D,%11000101 + !byte $51,%00000010 + !byte $7B,%01000010 + !byte $9F,%00100100 + !byte $9F,%01000100 + !byte $9F,%01100100 + !byte $9F,%10000101; + !byte $BD,%00000110 + !byte $13,%10100011 + !byte $9F,%11000011 + !byte $A9,%00100110 + !byte $0F,%11000011 + !byte $25,%00000100 + !byte $21,%11100011 + !byte $4F,%11100001 + !byte $59,%11100001 + !byte $7D,%01100010 + !byte $7D,%10000011; + !byte $9F,%10100011 + !byte $2D,%00100100 + !byte $79,%00000010 + !byte $57,%00000010 + !byte $0F,%11000111 + !byte $17,%10100011 + !byte $0D,%00000100 + !byte $B1,%00000110 + !byte $1D,%11000011 + !byte $2B,%00100100 + !byte $2F,%00000100 + !byte $9D,%11000001 + !byte $31,%10100011 + !byte $9F,%01100010 + !byte $9F,%10000011; + !byte $A3,%00100110 + !byte $91,%10100001 + !byte $0D,%11100101 + !byte $8B,%11100001 + !byte $0F,%00101000 + !byte $11,%10100011 + !byte $97,%01100000 + !byte $97,%10000001; + !byte $7F,%01100010 + !byte $7F,%10000011; + !byte $77,%10100001 + !byte $BB,%01101010 + !byte $BB,%10001011; + !byte $BB,%11001011 + !byte $BF,%00001100 + !byte $75,%00100000 + !byte $99,%01100000 + !byte $99,%10000001; + !byte $9F,%01000010 + !byte $A1,%00000110 + !byte $A7,%00100110 + !byte $0F,%11100111 + !byte $95,%01100000 + !byte $95,%10000001; + !byte $35,%00100000 + !byte $83,%01000010 + !byte $0F,%00001000 + !byte $33,%11000001 + !byte $45,%00000000 + !byte $BB,%10101011 + !byte $0D,%11100011 + !byte $A5,%00100110 + !byte $19,%10100011 + !byte $0D,%00000110 + !byte $BF,%10101001 + !byte $47,%00100000 + !byte $9F,%00100010 + !byte $0B,%01101000 + !byte $0B,%10001001; + !byte $5B,%10100001 + !byte $BF,%00000110 + !byte $AF,%00000110 + !byte $8D,%11000001 + !byte $BD,%00001010 + !byte $49,%01000000 + !byte $5D,%01000000 + !byte $31,%01100010 + !byte $31,%10000011; + !byte $33,%10100001 + !byte $0F,%10100011 + !byte $BD,%11101011 + !byte $9F,%00000010 + !byte $53,%00000010 + !byte $9B,%01100000 + !byte $9B,%10000001; + !byte $4B,%01100000 + !byte $4B,%10000001; + !byte $27,%00000100 + !byte $79,%11100001 + !byte $9D,%10100001 + !byte $55,%00000010 + !byte $77,%01100000 + !byte $77,%10000001; + !byte $93,%01100000 + !byte $93,%10000001; + !byte $09,%01101000 + !byte $09,%10001001; + !byte $2F,%11100011 + !byte $0D,%01001000 + !byte $23,%11100011 + !byte $0D,%00100110 + !byte $85,%00100010 + !byte $0D,%11000011 + !byte $B9,%11100101 + !byte $1F,%11000011 + !byte $7B,%00100010 + !byte $31,%01000010 + !byte $59,%11000001 + !byte $A1,%11100101 + !byte $BB,%11100101 + !byte $8F,%10100001 + !byte $B7,%11100101 + !byte $5F,%00000000 + !byte $35,%00000000 + !byte $9F,%11100001 + !byte $AD,%00000110 + !byte $1B,%10100011 + !byte $13,%01100010 + !byte $13,%10000011; + !byte $2D,%00000100 + !byte $87,%00000010 + !byte $07,%01101000 + !byte $07,%10001001; + !byte $51,%11100001 + !byte $7D,%01000010 + !byte $BD,%11100101 + !byte $BF,%11001001 + !byte $15,%01100010 + !byte $15,%10000011; + !byte $33,%01100000 + !byte $33,%10000001; + !byte $4F,%11000001 + !byte $4D,%10100001 + !byte $B5,%11100101 + !byte $BD,%00101010 + !byte $01,%01101000 + !byte $01,%10001001; + !byte $03,%01101000 + !byte $03,%10001001; + !byte $05,%01101000 + !byte $05,%10001001; + !byte $57,%11100001 + !byte $11,%01100010 + !byte $11,%10000011; + !byte $0D,%01000110 + !byte $75,%00000000 + !byte $81,%01000010 + !byte $5B,%01100000 + !byte $5B,%10000001; + !byte $A3,%00000110 + !byte $29,%00000100 + !byte $97,%01000000 + !byte $99,%01000000 + !byte $9D,%01100000 + !byte $9D,%10000001; + !byte $A1,%11000101 + !byte $0D,%10100011 + !byte $31,%00100010 + !byte $0B,%01000100 + !byte $0B,%00100100 + !byte $79,%11000001 + !byte $9F,%11000001 + !byte $BD,%11001011 + !byte $89,%11100001 + !byte $91,%01100000 + !byte $91,%10000001; + !byte $BF,%11100101 + !byte $0B,%00000100 + !byte $2B,%00000100 + !byte $7F,%01000010 + !byte $BF,%11101011 + !byte $17,%01100010 + !byte $17,%10000011; + !byte $2F,%11000011 + !byte $33,%01000000 + !byte $AB,%00000110 + !byte $95,%01000000 + !byte $0D,%00101000 + !byte $0D,%01100110 + !byte $0D,%10000111; + !byte $0F,%01100010 + !byte $0F,%10000011; + !byte $77,%01000000 + !byte $9B,%01000000 + !byte $0B,%01100100 + !byte $0B,%10000101; + !byte $B3,%11100101 + !byte $BD,%01001010 + !byte $5D,%00100000 + !byte $0B,%11100011 + !byte $25,%11100011 + !byte $21,%11000011 + !byte $0B,%01001000 + !byte $7B,%00000010 + !byte $A5,%00000110 + !byte $A9,%00000110 + !byte $1D,%10100011 + !byte $47,%00000000 + !byte $0B,%10100101 + !byte $31,%00000010 + !byte $A1,%10100101 + !byte $8B,%11000001 + !byte $BF,%11101001 + !byte $BD,%10101011 + !byte $0D,%10100111 + !byte $9F,%10100001 + !byte $83,%00100010 + !byte $A7,%00000110 + !byte $53,%11100001 + !byte $B1,%11100101 + !byte $BD,%01101010 + !byte $BD,%10001011; + !byte $0B,%11000101 + !byte $49,%00100000 + !byte $55,%11100001 + !byte $0B,%11000011 + !byte $19,%01100010 + !byte $19,%10000011; + !byte $0D,%00001000 + !byte $2D,%11100011 + !byte $2F,%10100011 + !byte $A1,%01100100 + !byte $A1,%10000101; + !byte $31,%11100001 + !byte $59,%10100001 + !byte $33,%00100000 + !byte $9D,%01000000 + !byte $0D,%11000111 + !byte $7D,%00100010 + !byte $0D,%11100111 + !byte $8D,%10100001 + !byte $A1,%10100011 + !byte $A1,%00100100 + !byte $A1,%01000100 + !byte $A1,%11000011 + !byte $A1,%11100011 + !byte $4B,%01000000 + !byte $93,%01000000 + !byte $A1,%00000100 + !byte $09,%01001000 + !byte $79,%10100001 + !byte $A1,%01100010 + !byte $A1,%10000011; + !byte $0D,%01100010 + !byte $0D,%10000011; + !byte $A3,%11100101 + !byte $85,%00000010 + !byte $0B,%11100101 + !byte $11,%01000010 + !byte $27,%11100011 + !byte $77,%00100000 + !byte $A1,%01000010 + !byte $57,%11000001 + !byte $4D,%01100000 + !byte $4D,%10000001; + !byte $13,%01000010 + !byte $99,%00100000 + !byte $9F,%01100000 + !byte $9F,%10000001; + !byte $AF,%11100101 + !byte $B9,%11000101 + !byte $BB,%11000101 + !byte $A1,%00100010 + !byte $5B,%01000000 + !byte $BD,%11000101 + !byte $51,%11000001 + !byte $0B,%10100011 + !byte $97,%00100000 + !byte $31,%11000001 + !byte $A1,%00000010 + !byte $33,%00000000 + !byte $4F,%10100001 + !byte $81,%00100010 + !byte $9B,%00100000 + !byte $BF,%11001011 + !byte $8F,%01100000 + !byte $8F,%10000001; + !byte $15,%01000010 + !byte $1F,%10100011 + !byte $2F,%01100010 + !byte $2F,%10000011; + !byte $0F,%01000010 + !byte $BF,%00001010 + !byte $BF,%11000101 + !byte $1B,%01100010 + !byte $1B,%10000011; + !byte $7F,%00100010 + !byte $0B,%00000110 + !byte $B7,%11000101 + !byte $0B,%00101000 + !byte $2B,%11100011 + !byte $29,%11100011 + !byte $07,%01001000 + !byte $7B,%11100001 + !byte $23,%11000011 + !byte $87,%11100001 + !byte $A1,%11100001 + !byte $5D,%00000000 + !byte $2D,%11000011 + !byte $AD,%11100101 + !byte $95,%00100000 + !byte $31,%10100001 + !byte $A5,%11100101 + !byte $05,%01001000 + !byte $79,%01100000 + !byte $79,%10000001; + !byte $B5,%11000101 + !byte $0B,%01100010 + !byte $0B,%10000011; + !byte $0D,%01000010 + !byte $17,%01000010 + !byte $91,%01000000 + !byte $03,%01001000 + !byte $0B,%00100110 + !byte $7D,%00000010 + !byte $9D,%00100000 + !byte $A1,%11000001 + !byte $A3,%11000101 + !byte $55,%11000001 + !byte $9F,%01000000 + !byte $01,%01001000 + !byte $53,%11000001 + !byte $2F,%01000010 + !byte $49,%00000000 + !byte $09,%00000100 + !byte $BF,%00101010 + !byte $31,%01100000 + !byte $31,%10000001; + !byte $89,%11000001 + !byte $77,%00000000 + !byte $09,%00100100 + !byte $59,%01100000 + !byte $59,%10000001; + !byte $BF,%10101011 + !byte $09,%11100011 + !byte $83,%00000010 + !byte $8B,%10100001 + !byte $AB,%11100101 + !byte $A1,%10100001 + !byte $25,%11000011 + !byte $09,%01000100 + !byte $A7,%11100101 + !byte $0B,%00001000 + !byte $09,%11000011 + !byte $BF,%01001010 + !byte $1D,%01100010 + !byte $1D,%10000011; + !byte $B3,%11000101 + !byte $57,%10100001 + !byte $93,%00100000 + !byte $A9,%11100101 + !byte $99,%00000000 + !byte $9B,%00000000 + !byte $0B,%01000110 + !byte $5B,%00100000 + !byte $7B,%11000001 + !byte $2F,%00100010 + !byte $BF,%01101010 + !byte $BF,%10001011; + !byte $8D,%01100000 + !byte $8D,%10000001; + !byte $A3,%10100101 + !byte $09,%01100100 + !byte $09,%10000101; + !byte $11,%00100010 + !byte $19,%01000010 + !byte $09,%00101000 + !byte $21,%10100011 + !byte $4B,%00100000 + !byte $09,%10100011 + !byte $0F,%00100010 + !byte $2D,%10100011 + !byte $97,%00000000 + !byte $51,%10100001 + !byte $31,%01000000 + !byte $4D,%01000000 + !byte $13,%00100010 + !byte $79,%01000000 + !byte $A1,%01100000 + !byte $A1,%10000001; + !byte $0B,%01000010 + !byte $9F,%00100000 + !byte $2B,%11000011 + !byte $0B,%01100110 + !byte $0B,%10000111; + !byte $B1,%11000101 + !byte $0B,%11100111 + !byte $81,%00000010 + !byte $9D,%00000000 + !byte $BD,%10100101 + !byte $7F,%00000010 + !byte $09,%10100101 + !byte $BB,%10100101 + !byte $BF,%10100101 + !byte $4F,%01100000 + !byte $4F,%10000001; + !byte $85,%11100001 + !byte $A3,%01100100 + !byte $A3,%10000101; + !byte $0D,%00100010 + !byte $0B,%11000111 + !byte $0B,%10100111 + !byte $A5,%11000101 + !byte $8F,%01000000 + !byte $27,%11000011 + !byte $31,%00100000 + !byte $15,%00100010 + !byte $2F,%00000010 + !byte $7D,%11100001 + !byte $B9,%10100101 + !byte $09,%01100010 + !byte $09,%10000011; + !byte $29,%11000011 + !byte $07,%00101000 + !byte $A3,%01000100 + !byte $09,%11000101 + !byte $87,%11000001 + !byte $7B,%10100001 + !byte $A1,%01000000 + !byte $95,%00000000 + !byte $55,%10100001 + !byte $2D,%01100010 + !byte $2D,%10000011; + !byte $53,%10100001 + !byte $AF,%11000101 + !byte $59,%01000000 + !byte $1B,%01000010 + !byte $1F,%01100010 + !byte $1F,%10000011; + !byte $0B,%00100010 + !byte $23,%10100011 + !byte $A3,%00100100 + !byte $2F,%11100001 + !byte $A3,%00000100 + !byte $A3,%01100010 + !byte $A3,%10000011; + !byte $B7,%10100101 + !byte $09,%00001000 + !byte $57,%01100000 + !byte $57,%10000001; + !byte $79,%00100000 + !byte $05,%00101000 + !byte $09,%01000010 + !byte $31,%00000000 + !byte $A3,%00100010 + !byte $A3,%01000010 + !byte $A3,%11000011 + !byte $A3,%11100011 + !byte $9F,%00000000 + !byte $A3,%10100011 + !byte $09,%11100101 + !byte $91,%00100000 + !byte $A3,%00000010 + !byte $5B,%00000000 + !byte $89,%10100001 + !byte $17,%00100010 + !byte $2F,%11000001 + !byte $A7,%11000101 + !byte $A3,%11100001 + !byte $83,%11100001 + !byte $2B,%10100011 + !byte $AD,%11000101 + !byte $A1,%00100000 + !byte $0F,%00000010 + !byte $A5,%10100101 + !byte $B5,%10100101 + !byte $4B,%00000000 + !byte $03,%00101000 + !byte $11,%00000010 + !byte $7F,%11100001 + !byte $A3,%11000001 + !byte $01,%00101000 + !byte $07,%11100011 + !byte $2D,%01000010 + !byte $51,%01100000 + !byte $51,%10000001; + !byte $AB,%11000101 + !byte $8B,%01100000 + !byte $8B,%10000001; + !byte $A9,%11000101 + !byte $07,%00000100 + !byte $0D,%00000010 + !byte $7D,%11000001 + !byte $07,%11000011 + !byte $09,%00000110 + !byte $25,%10100011 + !byte $7B,%01100000 + !byte $7B,%10000001; + !byte $93,%00000000 + !byte $4F,%01000000 + !byte $2F,%10100001 + !byte $A3,%10100001 + !byte $13,%00000010 + !byte $07,%00100100 + !byte $07,%10100011 + !byte $4D,%00100000 + !byte $81,%11100001 + !byte $09,%11100111 + !byte $59,%00100000 + !byte $09,%00100010 + !byte $79,%00000000 + !byte $8D,%01000000 + !byte $0B,%00000010 + !byte $85,%11000001 + !byte $B3,%10100101 + !byte $29,%10100011 + !byte $BF,%01100100 + !byte $BF,%10000101; + !byte $A3,%01100000 + !byte $A3,%10000001; + !byte $09,%00100110 + !byte $1D,%01000010 + !byte $21,%01100010 + !byte $21,%10000011; + !byte $07,%01100010 + !byte $07,%10000011; + !byte $07,%01000100 + !byte $27,%10100011 + !byte $BD,%01100100 + !byte $BD,%10000101; + !byte $07,%00001000 + !byte $19,%00100010 + !byte $55,%01100000 + !byte $55,%10000001; + !byte $A1,%00000000 + !byte $A5,%01100100 + !byte $A5,%10000101; + !byte $53,%01100000 + !byte $53,%10000001; + !byte $2D,%00100010 + !byte $2F,%01100000 + !byte $2F,%10000001; + !byte $BB,%01100100 + !byte $BB,%10000101; + !byte $15,%00000010 + !byte $8F,%00100000 + !byte $09,%11000111 + !byte $09,%01000110 + !byte $2B,%01100010 + !byte $2B,%10000011; + !byte $57,%01000000 + !byte $07,%01000010 + !byte $A3,%01000000 + !byte $B1,%10100101 + !byte $7B,%01000000 + !byte $07,%01100100 + !byte $07,%10000101; + !byte $2F,%01000000 + !byte $A7,%10100101 + !byte $09,%10100111 + !byte $09,%01100110 + !byte $09,%10000111; + !byte $B9,%01100100 + !byte $B9,%10000101; + !byte $09,%00000010 + !byte $87,%10100001 + !byte $91,%00000000 + !byte $A5,%01000100 + !byte $7D,%10100001 + !byte $7F,%11000001 + !byte $05,%00001000 + !byte $2D,%00000010 + !byte $23,%01100010 + !byte $23,%10000011; + !byte $0F,%11100001 + !byte $A3,%00100000 + !byte $0D,%11100001 + !byte $07,%00100010 + !byte $83,%11000001 + !byte $07,%10100101 + !byte $AF,%10100101 + !byte $B7,%01100100 + !byte $B7,%10000101; + !byte $2F,%00100000 + !byte $11,%11100001 + !byte $17,%00000010 + !byte $1B,%00100010 + !byte $1F,%01000010 + !byte $51,%01000000 + !byte $07,%11100111 + !byte $0B,%11100001 + !byte $59,%00000000 + !byte $89,%01100000 + !byte $89,%10000001; + !byte $A9,%10100101 + !byte $81,%11000001 + !byte $A5,%00100100 + !byte $07,%11000101 + !byte $03,%00001000 + !byte $4F,%00100000 + !byte $55,%01000000 + !byte $AD,%10100101 + !byte $2B,%01000010 + !byte $7B,%00100000 + !byte $29,%01100010 + !byte $29,%10000011; + !byte $2D,%11100001 + !byte $AB,%10100101 + !byte $2F,%00000000 + !byte $A5,%00000100 + !byte $A3,%00000000 + !byte $4D,%00000000 + !byte $13,%11100001 + !byte $25,%01100010 + !byte $25,%10000011; + !byte $A7,%01100100 + !byte $A7,%10000101; + !byte $01,%00001000 + !byte $B5,%01100100 + !byte $B5,%10000101; + !byte $53,%01000000 + !byte $8D,%00100000 + !byte $05,%11000011 + !byte $05,%10100011 + !byte $09,%11100001 + !byte $8B,%01000000 + !byte $A5,%11100011 + !byte $7D,%01100000 + !byte $7D,%10000001; + !byte $27,%01100010 + !byte $27,%10000011; + !byte $A5,%11100001 + !byte $A5,%01000010 + !byte $A5,%01100010 + !byte $A5,%10000011; + !byte $07,%00000010 + !byte $A5,%00000010 + !byte $A5,%10100011 + !byte $A5,%11000011 + !byte $07,%11100101 + !byte $57,%00100000 + !byte $A5,%00100010 + !byte $05,%11100011 + !byte $05,%01100010 + !byte $05,%10000011; + !byte $BF,%01000100 + !byte $85,%10100001 + !byte $A5,%11000001 + !byte $21,%01000010 + !byte $8F,%00000000 + !byte $A5,%10100001 + !byte $2D,%11000001 + !byte $7F,%10100001 + !byte $05,%00000100 + !byte $05,%01000010 + !byte $19,%00000010 + !byte $1D,%00100010 + !byte $BD,%01000100 + !byte $07,%11000111 + !byte $B3,%01100100 + !byte $B3,%10000101; + !byte $A5,%01100000 + !byte $A5,%10000001; + !byte $07,%00000110 + !byte $15,%11100001 + !byte $2B,%00100010 + !byte $05,%00100100 + !byte $05,%11100111 + !byte $0D,%11000001 + !byte $7B,%00000000 + !byte $87,%01100000 + !byte $87,%10000001; + !byte $2D,%10100001 + !byte $BB,%01000100 + !byte $05,%00100010 + !byte $0B,%11000001 + !byte $07,%10100111 + !byte $51,%00100000 + !byte $07,%11100001 + !byte $0F,%11000001 + !byte $A5,%01000000 + !byte $83,%10100001 + !byte $A7,%01000100 + !byte $07,%00100110 + !byte $7D,%01000000 + !byte $05,%01000100 + !byte $81,%10100001 + !byte $A9,%01100100 + !byte $A9,%10000101; + !byte $29,%01000010 + !byte $B1,%01100100 + !byte $B1,%10000101; + !byte $55,%00100000 + !byte $A5,%00100000 + !byte $23,%01000010 + !byte $07,%01100110 + !byte $07,%10000111; + !byte $07,%01000110 + !byte $09,%11000001 + !byte $B9,%01000100 + !byte $11,%11000001 + !byte $2D,%01100000 + !byte $2D,%10000001; + !byte $57,%00000000 + !byte $05,%00000010 + !byte $89,%01000000 + !byte $2B,%00000010 + !byte $53,%00100000 + !byte $17,%11100001 + !byte $4F,%00000000 + !byte $03,%11100111 + !byte $AF,%01100100 + !byte $AF,%10000101; + !byte $05,%01100100 + !byte $05,%10000101; + !byte $1B,%00000010 + !byte $1F,%00100010 + !byte $AB,%01100100 + !byte $AB,%10000101; + !byte $A5,%00000000 + !byte $7F,%01100000 + !byte $7F,%10000001; + !byte $27,%01000010 + !byte $A7,%00100100 + !byte $AD,%01100100 + !byte $AD,%10000101; + !byte $B7,%01000100 + !byte $25,%01000010 + !byte $07,%11000001 + !byte $2D,%01000000 + !byte $8B,%00100000 + !byte $05,%11000111 + !byte $13,%11000001 + !byte $85,%01100000 + !byte $85,%10000001; + !byte $01,%11100111 + !byte $7D,%00100000 + !byte $05,%11100001 + !byte $05,%10100101 + !byte $2B,%11100001 + !byte $A7,%00000100 + !byte $2D,%00100000 + !byte $BF,%00100100 + !byte $8D,%00000000 + !byte $03,%01100010 + !byte $03,%10000011; + !byte $0B,%10100001 + !byte $29,%00100010 + !byte $A9,%01000100 + !byte $03,%10100011 + !byte $03,%01000010 + !byte $0D,%10100001 + !byte $B5,%01000100 + !byte $55,%00000000 + !byte $21,%00100010 + !byte $03,%11000011 + !byte $51,%00000000 + !byte $09,%10100001 + !byte $81,%01100000 + !byte $81,%10000001; + !byte $A7,%11100011 + !byte $BD,%00100100 + !byte $05,%11000101 + !byte $0F,%10100001 + !byte $03,%00100010 + !byte $19,%11100001 + !byte $83,%01100000 + !byte $83,%10000001; + !byte $2D,%00000000 + !byte $05,%10100111 + !byte $1D,%00000010 + !byte $7F,%01000000 + !byte $05,%11000001 + !byte $A7,%11000011 + !byte $2B,%11000001 + !byte $03,%11100011 + !byte $87,%01000000 + !byte $15,%11000001 + !byte $B3,%01000100 + !byte $03,%11000111 + !byte $03,%00000010 + !byte $A7,%00000010 + !byte $A7,%10100011 + !byte $07,%10100001 + !byte $A7,%11000001 + !byte $A7,%00100010 + !byte $A7,%11100001 + !byte $A7,%01000010 + !byte $A7,%01100010 + !byte $A7,%10000011; + !byte $05,%11100101 + !byte $53,%00000000 + !byte $7D,%00000000 + !byte $03,%00000100 + !byte $A7,%10100001 + !byte $BB,%00100100 + !byte $27,%00100010 + !byte $AB,%01000100 + !byte $11,%10100001 + !byte $23,%00100010 + !byte $A7,%01100000 + !byte $A7,%10000001; + !byte $A9,%00100100 + !byte $05,%01100110 + !byte $05,%10000111; + !byte $05,%00000110 + !byte $29,%00000010 + !byte $A7,%01000000 + !byte $03,%11100001 + !byte $B1,%01000100 + !byte $25,%00100010 + !byte $03,%00100100 + !byte $2B,%10100001 + !byte $89,%00100000 + !byte $05,%01000110 + !byte $05,%00100110 + !byte $A7,%00100000 + !byte $AD,%01000100 + !byte $B9,%00100100 + !byte $1F,%00000010 + !byte $85,%01000000 + !byte $AF,%01000100 + !byte $05,%10100001 + !byte $8B,%00000000 + !byte $17,%11000001 + !byte $1B,%11100001 + !byte $03,%01000100 + !byte $81,%01000000 + !byte $01,%11000111 + !byte $0B,%01100000 + !byte $0B,%10000001; + !byte $7F,%00100000 + !byte $09,%01100000 + !byte $09,%10000001; + !byte $13,%10100001 + !byte $A7,%00000000 + !byte $0D,%01100000 + !byte $0D,%10000001; + !byte $03,%11000001 + !byte $2B,%01100000 + !byte $2B,%10000001; + !byte $A9,%00000100 + !byte $B7,%00100100 + !byte $03,%10100111 + !byte $07,%01100000 + !byte $07,%10000001; + !byte $83,%01000000 + !byte $29,%11100001 + !byte $03,%01100100 + !byte $03,%10000101; + !byte $27,%00000010 + !byte $AB,%00100100 + !byte $BF,%00000100 + !byte $01,%01000010 + !byte $0F,%01100000 + !byte $0F,%10000001; + !byte $21,%00000010 + !byte $2B,%01000000 + !byte $87,%00100000 + !byte $01,%01100010 + !byte $01,%10000011; + !byte $B5,%00100100 + !byte $01,%00100010 + !byte $03,%10100001 + !byte $01,%00000010 + !byte $05,%01100000 + !byte $05,%10000001; + !byte $01,%10100011 + !byte $A9,%11100011 + !byte $19,%11000001 + !byte $BD,%00000100 + !byte $03,%10100101 + !byte $1D,%11100001 + !byte $01,%11100001 + !byte $15,%10100001 + !byte $2B,%00100000 + !byte $03,%01100110 + !byte $03,%10000111; + !byte $7F,%00000000 + !byte $01,%11000011 + !byte $29,%11000001 + !byte $23,%00000010 + !byte $25,%00000010 + !byte $A9,%11000011 + !byte $81,%00100000 + !byte $AD,%00100100 + !byte $B3,%00100100 + !byte $01,%10100111 + !byte $03,%11000101 + !byte $11,%01100000 + !byte $11,%10000001; + !byte $89,%00000000 + !byte $BB,%00000100 + !byte $09,%01000000 + !byte $0B,%01000000 + !byte $01,%11000001 + !byte $01,%11100011 + !byte $85,%00100000 + !byte $07,%01000000 + !byte $27,%11100001 + !byte $AF,%00100100 + !byte $03,%01000110 + !byte $03,%01100000 + !byte $03,%10000001; + !byte $A9,%10100011 + !byte $AB,%00000100 + !byte $B1,%00100100 + !byte $03,%11100101 + !byte $2B,%00000000 + !byte $01,%00000100 + !byte $A9,%01100010 + !byte $A9,%10000011; + !byte $83,%00100000 + !byte $29,%10100001 + !byte $03,%00000110 + !byte $A9,%10100001 + !byte $03,%00100110 + !byte $1F,%11100001 + !byte $A9,%11000001 + !byte $A9,%01000010 + !byte $B9,%00000100 + !byte $05,%01000000 + !byte $A9,%00100010 + !byte $1B,%11000001 + !byte $A9,%11100001 + !byte $0D,%01000000 + !byte $A9,%01100000 + !byte $A9,%10000001; + !byte $A9,%00000010 + !byte $A9,%01000000 + !byte $13,%01100000 + !byte $13,%10000001; + !byte $17,%10100001 + !byte $A9,%00100000 + !byte $01,%10100001 + !byte $A9,%00000000 + !byte $01,%00100100 + !byte $0F,%01000000 + !byte $29,%01100000 + !byte $29,%10000001; + !byte $03,%01000000 + !byte $B7,%00000100 + !byte $01,%01100110 + !byte $01,%10000111; + !byte $81,%00000000 + !byte $87,%00000000 + !byte $21,%11100001 + !byte $AD,%00000100 + !byte $25,%11100001 + !byte $AB,%11100011 + !byte $27,%11000001 + !byte $01,%01100000 + !byte $01,%10000001; + !byte $BF,%11100011 + !byte $01,%01000100 + !byte $23,%11100001 + !byte $1D,%11000001 + !byte $B5,%00000100 + !byte $09,%00100000 + !byte $07,%00100000 + !byte $19,%10100001 + !byte $85,%00000000 + !byte $15,%01100000 + !byte $15,%10000001; + !byte $29,%01000000 + !byte $83,%00000000 + !byte $05,%00100000 + !byte $0B,%00100000 + !byte $AB,%11000011 + !byte $BD,%11100011 + !byte $AF,%00000100 + !byte $01,%01100100 + !byte $01,%10000101; + !byte $01,%01000000 + !byte $01,%01000110 + !byte $11,%01000000 + !byte $B3,%00000100 + !byte $B1,%00000100 + !byte $01,%10100101 + !byte $03,%00100000 + !byte $BB,%11100011 + !byte $0D,%00100000 + !byte $1F,%11000001 + !byte $27,%10100001 + !byte $AB,%10100011 + !byte $01,%00100110 + !byte $29,%00100000 + !byte $25,%11000001 + !byte $AD,%11100011 + !byte $01,%11000101 + !byte $01,%00000110 + !byte $01,%11100101 + !byte $AB,%01100010 + !byte $AB,%10000011; + !byte $13,%01000000 + !byte $1B,%10100001 + !byte $29,%00000000 + !byte $B9,%11100011 + !byte $01,%00100000 + !byte $17,%01100000 + !byte $17,%10000001; + !byte $0F,%00100000 + !byte $21,%11000001 + !byte $23,%11000001 + !byte $AB,%01000010 + !byte $07,%00000000 + !byte $05,%00000000 + !byte $27,%01100000 + !byte $27,%10000001; + !byte $09,%00000000 + !byte $AB,%00100010 + !byte $AB,%01000000 + !byte $AB,%11000001 + !byte $AB,%01100000 + !byte $AB,%10000001; + !byte $AB,%11100001 + !byte $AB,%00000010 + !byte $AB,%00100000 + !byte $AB,%10100001 + !byte $AF,%11100011 + !byte $AB,%00000000 + !byte $03,%00000000 + !byte $AD,%11000011 + !byte $B7,%11100011 + !byte $BF,%11000011 + !byte $1D,%10100001 + !byte $0B,%00000000 + !byte $25,%10100001 + !byte $B5,%11100011 + !byte $B1,%11100011 + !byte $19,%01100000 + !byte $19,%10000001; + !byte $15,%01000000 + !byte $B3,%11100011 + !byte $BD,%11000011 + !byte $01,%00000000 + !byte $11,%00100000 + !byte $27,%01000000 + !byte $AD,%10100011 + !byte $1F,%10100001 + !byte $0D,%00000000 + !byte $23,%10100001 + !byte $27,%00100000 + !byte $21,%10100001 + !byte $25,%01100000 + !byte $25,%10000001; + !byte $AF,%11000011 + !byte $BB,%11000011 + !byte $1B,%01100000 + !byte $1B,%10000001; + !byte $13,%00100000 + !byte $AD,%01100010 + !byte $AD,%10000011; + !byte $0F,%00000000 + !byte $17,%01000000 + !byte $B9,%11000011 + !byte $27,%00000000 + !byte $AD,%01000010 + !byte $B1,%11000011 + !byte $B7,%11000011 + !byte $AD,%00100010 + !byte $1D,%01100000 + !byte $1D,%10000001; + !byte $AF,%10100011 + !byte $25,%01000000 + !byte $23,%01100000 + !byte $23,%10000001; + !byte $B3,%11000011 + !byte $B5,%11000011 + !byte $BF,%10100011 + !byte $AD,%00000010 + !byte $11,%00000000 + !byte $AD,%01000000 + !byte $AD,%01100000 + !byte $AD,%10000001; + !byte $AD,%11100001 + !byte $15,%00100000 + !byte $AD,%00000000 + !byte $AD,%00100000 + !byte $AD,%11000001 + !byte $19,%01000000 + !byte $1F,%01100000 + !byte $1F,%10000001; + !byte $AD,%10100001 + !byte $21,%01100000 + !byte $21,%10000001; + !byte $BD,%10100011 + !byte $25,%00100000 + !byte $AF,%01100010 + !byte $AF,%10000011; + !byte $1B,%01000000 + !byte $B1,%10100011 + !byte $BB,%10100011 + !byte $13,%00000000 + !byte $23,%01000000 + !byte $17,%00100000 + !byte $AF,%01000010 + !byte $B9,%10100011 + !byte $B3,%10100011 + !byte $25,%00000000 + !byte $1D,%01000000 + !byte $B5,%10100011 + !byte $B7,%10100011 + !byte $21,%01000000 + !byte $AF,%00100010 + !byte $1F,%01000000 + !byte $B1,%01100010 + !byte $B1,%10000011; + !byte $19,%00100000 + !byte $BF,%01100010 + !byte $BF,%10000011; + !byte $23,%00100000 + !byte $15,%00000000 + !byte $AF,%00000010 + !byte $AF,%11100001 + !byte $BD,%01100010 + !byte $BD,%10000011; + !byte $AF,%11000001 + !byte $B3,%01100010 + !byte $B3,%10000011; + !byte $AF,%10100001 + !byte $1B,%00100000 + !byte $AF,%00000000 + !byte $AF,%01100000 + !byte $AF,%10000001; + !byte $B1,%01000010 + !byte $AF,%00100000 + !byte $AF,%01000000 + !byte $BB,%01100010 + !byte $BB,%10000011; + !byte $21,%00100000 + !byte $23,%00000000 + !byte $17,%00000000 + !byte $1D,%00100000 + !byte $B9,%01100010 + !byte $B9,%10000011; + !byte $B5,%01100010 + !byte $B5,%10000011; + !byte $1F,%00100000 + !byte $B7,%01100010 + !byte $B7,%10000011; + !byte $B1,%00100010 + !byte $19,%00000000 + !byte $B3,%01000010 + !byte $21,%00000000 + !byte $B1,%00000010 + !byte $BF,%01000010 + !byte $1B,%00000000 + !byte $BD,%01000010 + !byte $B1,%11100001 + !byte $B5,%01000010 + !byte $1F,%00000000 + !byte $1D,%00000000 + !byte $B1,%11000001 + !byte $B3,%00100010 + !byte $BB,%01000010 + !byte $B7,%01000010 + !byte $B1,%10100001 + !byte $B9,%01000010 + !byte $B1,%01100000 + !byte $B1,%10000001; + !byte $B1,%00000000 + !byte $B1,%00100000 + !byte $B1,%01000000 + !byte $B3,%00000010 + !byte $B5,%00100010 + !byte $BF,%00100010 + !byte $B3,%11100001 + !byte $B7,%00100010 + !byte $BD,%00100010 + !byte $B3,%11000001 + !byte $B9,%00100010 + !byte $BB,%00100010 + !byte $B5,%00000010 + !byte $B3,%10100001 + !byte $B3,%01100000 + !byte $B3,%10000001; + !byte $B3,%01000000 + !byte $B3,%00100000 + !byte $B5,%11100001 + !byte $B7,%00000010 + !byte $B3,%00000000 + !byte $BF,%00000010 + !byte $B9,%00000010 + !byte $BD,%00000010 + !byte $BB,%00000010 + !byte $B5,%11000001 + !byte $B7,%11100001 + !byte $B5,%10100001 + !byte $B5,%01100000 + !byte $B5,%10000001; + !byte $B9,%11100001 + !byte $B5,%01000000 + !byte $B7,%11000001 + !byte $BB,%11100001 + !byte $BF,%11100001 + !byte $B5,%00100000 + !byte $BD,%11100001 + !byte $B5,%00000000 + !byte $B7,%10100001 + !byte $B9,%11000001 + !byte $B7,%01100000 + !byte $B7,%10000001; + !byte $BB,%11000001 + !byte $B7,%01000000 + !byte $BD,%11000001 + !byte $BF,%11000001 + !byte $B9,%10100001 + !byte $B7,%00100000 + !byte $B7,%00000000 + !byte $BB,%10100001 + !byte $B9,%01100000 + !byte $B9,%10000001; + !byte $BD,%10100001 + !byte $B9,%01000000 + !byte $BF,%10100001 + !byte $BB,%01100000 + !byte $BB,%10000001; + !byte $B9,%00100000 + !byte $B9,%00000000 + !byte $BD,%01100000 + !byte $BD,%10000001; + !byte $BB,%01000000 + !byte $BF,%01100000 + !byte $BF,%10000001; + !byte $BB,%00100000 + !byte $BD,%01000000 + !byte $BB,%00000000 + !byte $BF,%01000000 + !byte $BD,%00100000 + !byte $BF,%00100000 + !byte $BD,%00000000 + !byte $BF,%00000000 diff --git a/src/fx/fx.hgr.wavy.iris.in.a b/src/fx/fx.hgr.wavy.iris.in.a new file mode 100644 index 0000000..e0c9faa --- /dev/null +++ b/src/fx/fx.hgr.wavy.iris.in.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/WAVY.IRIS.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_REVERSE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.hgr.wavy.ripple.a b/src/fx/fx.hgr.wavy.ripple.a new file mode 100644 index 0000000..3a10272 --- /dev/null +++ b/src/fx/fx.hgr.wavy.ripple.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/WAVY.RIPPLE",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 17 + !text "FX/WAVY.IRIS.DATA" diff --git a/src/fx/fx.hgr.wavy.ripple.bloom.a b/src/fx/fx.hgr.wavy.ripple.bloom.a new file mode 100644 index 0000000..31c5cbf --- /dev/null +++ b/src/fx/fx.hgr.wavy.ripple.bloom.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019-2020 by 4am/qkumba +; +!cpu 6502 +!to "build/FX/W.RIPPLE.BLOOM",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.2bit.a" + + +FX_INITONCE_2BIT CoordinatesFile, Start + +FX_RIPPLE_2BIT +Start + +FX_PRECOMPUTED_2BIT Coordinates2Bit + +CoordinatesFile + !byte 18 + !text "FX/W.IR.BLOOM.DATA" diff --git a/src/fx/fx.shr.fizzle.a b/src/fx/fx.shr.fizzle.a new file mode 100644 index 0000000..d707a64 --- /dev/null +++ b/src/fx/fx.shr.fizzle.a @@ -0,0 +1,49 @@ +;license:MIT +;(c) 2019-2020 by qkumba/4am/John Brooks + +!cpu 6502 +!to "build/FX/SHR.FIZZLE",plain +*=$A000 + +addrs=$80 ; [128 bytes] +src=addrs-$20 ; [word] + + lda #$A0 ; create address lookup table + tax + tay +- dey + sty addrs-$21, x + dex + bne - + sta $C005 +- lda $9D00, y ; pre-copy SHR SCB and palette + sta $9D00, y + lda $9E00, y + sta $9E00, y + lda $9F00, y + sta $9F00, y + iny + bne - +loop txa +loop1 eor #$60 ; LFSR form 0x6000 with period 32767 + tax +loop2 lda addrs, x + sta src+1 + lda (src), y + sta (src), y + txa + lsr + tax + tya + ror + tay + bcc loop2 + bne loop + bit $C000 + bmi exit + txa + bne loop1 +exit lda $2000 ; last lousy byte (because LFSR never hits 0) + sta $2000 + sta $C004 + rts diff --git a/src/fx/macros.a b/src/fx/macros.a new file mode 100644 index 0000000..ee25618 --- /dev/null +++ b/src/fx/macros.a @@ -0,0 +1,163 @@ +!ifndef _FX_MACROS_ { + !source "src/macros.a" + +; .hgrlo, .hgr1hi will each be filled with $C0 bytes +; based on routine by John Brooks +; posted on comp.sys.apple2 on 2018-07-11 +; https://groups.google.com/d/msg/comp.sys.apple2/v2HOfHOmeNQ/zD76fJg_BAAJ +!macro BUILD_HGR_LOOKUP_TABLES .hgrlo, .hgr1hi { + ldx #0 + +BUILD_HGR_LOOKUP_TABLES_X_IS_ALREADY_0 .hgrlo, .hgr1hi +} + +; use this macro instead if you know X is already 0 on entry, to save 2 bytes +!macro BUILD_HGR_LOOKUP_TABLES_X_IS_ALREADY_0 .hgrlo, .hgr1hi { +- txa + and #$F8 + bpl + + ora #5 ++ asl + bpl + + ora #5 ++ asl + asl + sta .hgrlo,x + txa + and #7 + rol + asl .hgrlo,x + rol + ora #$20 + sta .hgr1hi,x + inx + cpx #$C0 + bne - +} + +; .hgrlomirror, .hgr1himirror will each be filled with $C0 bytes +!macro BUILD_HGR_MIRROR_LOOKUP_TABLES .hgrlomirror, .hgr1himirror { + ldx #$C0 + ldy #0 +- tya + and #$F8 + bpl + + ora #5 ++ asl + bpl + + ora #5 ++ asl + asl + sta .hgrlomirror-1,x + tya + and #7 + rol + asl .hgrlomirror-1,x + rol + ora #$20 + sta .hgr1himirror-1,x + iny + dex + bne - +} + +!macro HGR_CALC { +; in: A = HGR row (0x00..0xBF) +; out: A/X clobbered +; Y preserved +; ($26) points to first byte of given HGR row on hi-res page 1 +; ($3C) points to same byte on hi-res page 2 +; based on 'Woz Recodes Hi-Res Address Calculations' +; Apple Assembly Line vol. 7 issue 3 (December 1986) +; http://www.txbobsc.com/aal/1986/aal8612.html#a9 + asl + tax + and #$F0 + bpl @calc1 + ora #$05 +@calc1 bcc @calc2 + ora #$0A +@calc2 asl + asl + sta $26 + txa + and #$0E + adc #$10 + asl $26 + rol + sta $27 + eor #$60 + sta $3d + lda $26 + sta $3c +} + +!macro HGR_ROW_CALC { + asl + asl + asl + +HGR_CALC +} + +; /!\ C must be clear before using this macro +!macro HGR_INC_WITHIN_BLOCK { + lda $27 + adc #$04 + sta $27 + eor #$60 + sta $3d +} + +!macro RESET_HGR_CALC { + lda $27 + sec + sbc #$20 + sta $27 + eor #$60 + sta $3d +} + +!macro COPY_BIT .src1, .dest1, .copymasks { + lda (.src1),y + eor (.dest1),y ; merge source and destination bits + and .copymasks,x ; isolate the bits to replace, zero the rest + eor (.dest1),y ; unmerge source and destination bits, leaves 'to keep' destination bits intact + sta (.dest1),y ; write the result +} + +!macro COPY_BIT_ZP .src1, .dest1, .zpcopymask { + lda (.src1),y + eor (.dest1),y ; merge source and destination bits + and <.zpcopymask ; isolate the bits to replace, zero the rest + eor (.dest1),y ; unmerge source and destination bits, leaves 'to keep' destination bits intact + sta (.dest1),y ; write the result +} + +!macro SWITCH_TO_MASKS .copy { + lda #<.copy + sta CopyMaskAddr + lda #>.copy + sta CopyMaskAddr+1 +} + +; must set N flag based on Y immediately before using these macros +; e.g. LDY, INY, DEY, TYA +!macro IS_Y_OFFSCREEN { + bpl + + sec + bcs ++ ++ cpy #40 +++ +} +!macro BRANCH_IF_Y_IS_OFFSCREEN .target { + cpy #40 + bcs .target +} +!macro LONG_BRANCH_IF_Y_IS_OFFSCREEN .target { + cpy #40 + bcc + + jmp .target ++ +} + +_FX_MACROS_=* +} diff --git a/src/glue.decompress.a b/src/glue.decompress.a new file mode 100644 index 0000000..4f781d3 --- /dev/null +++ b/src/glue.decompress.a @@ -0,0 +1,87 @@ +;license:MIT +;(c) 2018-2020 by 4am & qkumba +; +; Exomizer glue functions +; +; Public functions +; - DecompressHGR +; - DecompressDHGR +; - DecompressSHR +; + +DECRUNCH = $0314 ; decrunch entry point + +;------------------------------------------------------------------------------ +; DecompressSHR +; +; in: compressed SHR loaded to $1FF8+ +; file size in sizelo2/sizehi2 as set by ProRWTS2 +; out: decompressed SHR at $2000..$9FFF +; $00A7..$00A8 clobbered by decompressor +; $00AE..$00AF clobbered by decompressor +; $00FC..$00FF clobbered by decompressor +; $0200..$03CB clobbered by decompressor +;------------------------------------------------------------------------------ +DecompressSHR + lda #$1F + +HIDE_NEXT_2_BYTES + ; /!\ execution falls through here + +;------------------------------------------------------------------------------ +; DecompressHGR +; +; in: compressed HGR loaded to $3FF8+ +; file size in sizelo2/sizehi2 as set by ProRWTS2 +; out: decompressed HGR at $4000..$5FFF +; $00A7..$00A8 clobbered by decompressor +; $00AE..$00AF clobbered by decompressor +; $00FC..$00FF clobbered by decompressor +; $0200..$03CB clobbered by decompressor +;------------------------------------------------------------------------------ +DecompressHGR + lda #$3F + pha + jsr SwitchToBank2 + jsr EnableAccelerator + lda sizehi2 + pha + lda sizelo2 + pha + lda #>(@loaddecrunch - 1) + pha + lda #<(@loaddecrunch - 1) + pha + lda auxreq + bne + + jmp LoadFile ; load decompression code to $200 ++ jmp LoadAuxFile ; load decompression code to $200/aux +@loaddecrunch + !word kRootDirectory + !word kDecrunchFile + !word $200 + ldx auxreq + sta READMAINMEM,x ; X = 0 or 1, so this will be READMAINMEM or READAUXMEM + sta WRITEMAINMEM,x ; X = 0 or 1, so this will be WRITEMAINMEM or WRITEAUXMEM + jsr DECRUNCH ; loaded from separate file + jsr SwitchToBank2 + jmp DisableAcceleratorAndSwitchToBank1 + +;------------------------------------------------------------------------------ +; DecompressDHGR +; +; in: compressed DHGR loaded to aux $3FF8+ +; file size in sizelo2/sizehi2 as set by ProRWTS2 +; out: decompressed HGR at $4000..$5FFF/main and $4000..$5FFF/aux +; $6000..$7FFF/aux clobbered by decompressor +; $00A7..$00A8 clobbered by decompressor +; $00AE..$00AF clobbered by decompressor +; $00FC..$00FF clobbered by decompressor +; $0200..$03CB clobbered by decompressor +;------------------------------------------------------------------------------ +DecompressDHGR + jsr DecompressHGR + sta WRITEMAINMEM + lda #$60 + sta PageFrom+2 + lda #$40 + jmp CopyHGR ; switches back to READMAINMEM on exit diff --git a/src/glue.launch.a b/src/glue.launch.a new file mode 100644 index 0000000..825a40b --- /dev/null +++ b/src/glue.launch.a @@ -0,0 +1,277 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; Functions to launch games and self-running demos +; +; Public functions +; - GetGameToLaunch +; - FindGame +; - FindGameInActionSlideshow +; - GetGameDisplayName +; - PlayGame +; - Launch +; +; Public variables: +; - gGameToLaunch - 0-based index into gGamesListStore (word) +; + +gGameToLaunch + !word $FFFF + +;------------------------------------------------------------------------------ +; AnyGameSelected +; get index of game that is currently selected in the UI (if any) +; +; in: none +; out: A/Y = gGameToLaunch (word) +; C clear if gGameToLaunch is not #$FFFF +; C set if gGameToLaunch is #$FFFF +; X preserved +;------------------------------------------------------------------------------ +AnyGameSelected + +LD16 gGameToLaunch + +CMP16 $FFFF + bne ForceGoodResult + rts ; CMP sets carry when equal + +;------------------------------------------------------------------------------ +; GetGameToLaunch +; get filename of game that is currently selected in the UI (if any) +; +; in: gGameToLaunch = index into gGamesListStore (word) or #$FFFF if no game selected +; out: C clear if a game is selected, and +; A/Y points to game filename +; C set if no game is selected +;------------------------------------------------------------------------------ +GetGameToLaunch + jsr AnyGameSelected + bcs _gameToLaunchExit + +ST16 WINDEX + +LDADDR gGamesListStore + jsr okvs_nth +ForceGoodResult + clc +_gameToLaunchExit + rts + +;------------------------------------------------------------------------------ +; FindGame +; check if an arbitrary game exists, for some definition of 'exists' +; +; in: A/Y points to game filename +; out: C clear if game exists in gGamesListStore, and +; $WINDEX = game index, or #$FFFF if the game doesn't really +; exist but we want to return a successful result anyway +; C set if game does not exist (this can happen because slideshows +; list games that require a joystick, but the games list parser +; filters them out if the machine doesn't have a joystick) +; all registers clobbered +;------------------------------------------------------------------------------ +FindGame + +ST16 @key + jsr okvs_find + !word gGamesListStore +@key !word $FDFD ; SMC + bcc GlueLaunchRTS +; Hack to allow self-running demos that don't correspond to a game +; filename. If the name ends in a '.', accept it unconditionally. + ldx #$FF + stx WINDEX + stx WINDEX+1 + +LD16 @key + +ST16 PARAM + ldy #0 + lda (PARAM),y + tay + lda (PARAM),y + cmp #"." + beq ForceGoodResult + sec +GlueLaunchRTS + rts + +;------------------------------------------------------------------------------ +; FindGameInActionSlideshow +; check if an arbitrary game exists, for some definition of 'exists', while +; in the middle of a slideshow +; +; /!\ This function assumes that gSlideshowStore exists and is populated, +; which is generally only true during the callback function of a slideshow +; +; in: A/Y points to game filename +; out: C clear if game exists, and +; $WINDEX = game index, and +; A/Y points to game display name + game info bitfield +; C set if game can't be found by any means +;------------------------------------------------------------------------------ +FindGameInActionSlideshow + +ST16 @sskey + jsr FindGame + bcc GetGameDisplayName +; if the game was not found, try getting the value of the current record from +; gSlideshowStore (some games have multiple action screenshots, in which case +; the key is only the screenshot filename, and the value is the actual game +; filename) + jsr okvs_get + !word gSlideshowStore +@sskey !word $FDFD ; SMC + jsr FindGame + bcs GlueLaunchRTS + ; /!\ execution falls through here to GetGameDisplayName + +;------------------------------------------------------------------------------ +; GetGameDisplayName +; lookup or construct the display name for a specific game +; +; in: A/Y contains address of a key in gGamesListStore +; out: A/Y contains address of game display name + game info bitfield +; (this might be just the corresponding value in gGamesListStore, +; or it might be a temporary buffer in main memory that we constructed +; out of thin air) +; gValLen possibly clobbered (up to gValLen+MaxInputLength) +; X preserved +; C clear +;------------------------------------------------------------------------------ +GetGameDisplayName + +ST16 SAVE + jsr okvs_get_current ; get value for this key + ; (PTR) -> truncated game display name + info bitfield + ldy #0 + lda (PTR), y ; A = length of truncated game display name + info bitfield + cmp #1 ; 1 means there's no title, just info bitfield (1 byte) + beq + + +LD16 PTR + clc + rts ++ ; game display name is truncated, we must expand it + iny ; Y = 1 + lda (PTR), y ; A = game info bitfield + pha ; save on stack + dey + lda (SAVE), y ; A = length of key + tay + iny + sty @len + sty gValLen + lda #$24 ; BIT opcode + sta @or ; first character remains capitalized + ldy #1 +- lda (SAVE), y + cmp #$49 ; 'I' + bne + + cmp gValLen-1,y + beq ++ ; preserve 'II' casing ++ cmp #$2E + bne @or + lda #$20 ; convert '.' to ' ' +@or ora #$20 ; SMC (opcode) +++ sta gValLen, y + cmp #$20 + bne + + lda #$24 ; first character after ' ' remains capitalized + +HIDE_NEXT_2_BYTES ++ lda #$09 ; OR opcode + sta @or +@next iny +@len=*+1 + cpy #$FD ; SMC + bne - + pla + sta gValLen, y + +LDADDR gValLen + clc + rts + +;------------------------------------------------------------------------------ +; PlayGame +; +; in: gGameToLaunch != #$FFFF +; out: exits via the game, but also backs up the stack, which may get +; restored in |Reenter|... what I'm saying is that we might actually +; 'return' from this after the user is done playing the game, which is +; a neat trick +;------------------------------------------------------------------------------ +PlayGame + jsr GetGameToLaunch + ; A/Y = address of game filename + +ST16 SAVE + +ST16 @pfile + + jsr ClearScreens ; avoid seeing code load into the HGR page + ; (clobbers $106, must do now before loading prelaunch code) + + jsr LoadFile ; load this game's prelaunch file at $106 + !word kPrelaunchDirectory +@pfile !word $FDFD + !word $0106 + + ; we start by placing the subdirectory name at gPathname+kGameDirectoryLen + ; to leave room for the GameDirectory name as the parent + + lda #kGameDirectoryLen + sta gPathname + +LD16 SAVE + jsr AddToPath + + ; attach the separator + + inc gPathname + lda #'/' + sta gPathname+1,x + + ; then we save the length of the resulting string without the count byte + + dex + txa + pha + + ; then attach the game name + + +LD16 SAVE + jsr AddToPath + + ; don't look while I do this + ; we "place" a string at gPathname+kGameDirectoryLen + ; whose length is the subdirectory name and game name + ; then we load it + ; the load sets the path to the GameDirectory + ; and then finds the subdirectory name and game name right after it + ; and attaches it to the path by overwriting the count byte + + ;;sec ; carry set by AddToPath + lda gPathname + sbc #kGameDirectoryLen + sta gPathname+kGameDirectoryLen + jsr LoadFile ; load the game startup file + !word kGameDirectory + !word gPathname+kGameDirectoryLen + !word 0 ; use file's default address + + pla + sta ProDOS_prefix ; set 'root' directory to the path part + ; of the game startup file we just loaded + ; so games can load other files without + ; knowing which directory they're in + + ; execution falls through here +Launch + jsr SwitchToBank2 + lda #$BD + sta launchpatch + jsr saveslot ; set proper slot information + lda #$9D + sta launchpatch + jmp LaunchInternal + +Joystick + jsr LoadFile + !word kPrelaunchDirectory + !word kStandardPrelaunch + !word $0106 + + jsr LoadFile + !word kRootDirectory + !word kJoystickFile + !word 0 + + jmp Launch diff --git a/src/glue.launch.lc2.a b/src/glue.launch.lc2.a new file mode 100644 index 0000000..f62863b --- /dev/null +++ b/src/glue.launch.lc2.a @@ -0,0 +1,26 @@ +;license:MIT +;(c) 2018-9 by 4am & qkumba +; +; Functions to launch games and self-running demos +; +; /!\ These live in LC RAM 2 and rely on the ProRWTS code which is also in LC RAM 2. /!\ +; Code in LC RAM 1 (which is most program code) should call the functions in glue.launch +; which handle bank switching for you. + +LaunchInternal + ldy #$F1 +- lda $100,y + sta STACKBASE - $EF,y ; back up stack + iny + bne - + tsx ; back up stack pointer + stx STACKPTR + 1 + sty RestoreStackNextTime + 1 + ; tell |Reenter| to restore the stack and stack pointer + + tya + ldy #$18 +- sta $bf57,y + dey + bne - + jmp $106 ; jump to pre-launch code diff --git a/src/glue.prorwts2.a b/src/glue.prorwts2.a new file mode 100644 index 0000000..db33600 --- /dev/null +++ b/src/glue.prorwts2.a @@ -0,0 +1,113 @@ +;license:MIT +;(c) 2018-2020 by 4am & qkumba +; +; ProRWTS2 glue functions +; +; Public functions +; - LoadFile +; - LoadDHRFile +; +; Public variables +; - gRootDirectory +; +; A general note about paths: +; +; LoadFile, LoadDHRFile, and SaveSmallFile support subdirectories. +; Directories are delimited by '/' like ProDOS. At program startup, we get the +; current directory and save it; that is the PROGRAM ROOT DIRECTORY. All +; pathnames are relative to the PROGRAM ROOT DIRECTORY. There is no concept of +; setting or changing the 'current' directory. +; +; The PROGRAM ROOT DIRECTORY is not guaranteed to be the root directory of the +; underlying ProDOS disk (although it can be). But it doesn't matter, because +; these functions provide no access to any directory above the PROGRAM ROOT +; DIRECTORY. You can't use '..' to access the parent directory, and you can't +; start a pathname with '/' to access the root directory of the underlying +; ProDOS disk. +; +; Examples: +; 'PREFS.CONF' points to a file named 'PREFS.CONF' in the PROGRAM ROOT +; DIRECTORY. +; +; 'FX/RIPPLE' points to a file named 'RIPPLE' in a directory named 'FX' in the +; PROGRAM ROOT DIRECTORY. + +;------------------------------------------------------------------------------ +; LoadFile +; Load a file into memory all at once, using ProRWTS2 +; +; supports paths, see note +; +; in: stack contains 6 bytes of parameters: +; +1 [word] address of length-prefixed pathname +; +3 [word] address of length-prefixed filename +; +5 [word] address to load file, or 0 to use file's default address +; out: all flags clobbered +; all registers clobbered +; gPathname clobbered +;------------------------------------------------------------------------------ +LoadFile + +PARAMS_ON_STACK 6 + +LDPARAM 1 + jsr SetPath + +LDPARAM 3 + jsr AddToPath + +LDPARAMPTR 5, ldrlo ; set load address + jsr SwitchToBank2 + jsr LoadFileInternal + jmp SwitchToBank1 + +;------------------------------------------------------------------------------ +; LoadAuxFile +; Load a file into aux memory all at once, using ProRWTS2 +; +; supports paths, see note +; +; in: stack contains 6 bytes of parameters: +; +1 [word] address of length-prefixed pathname +; +3 [word] address of length-prefixed filename +; +5 [word] address to load file, or 0 to use file's default address +; out: all flags clobbered +; all registers clobbered +; gPathname clobbered +;------------------------------------------------------------------------------ +LoadAuxFile + +PARAMS_ON_STACK 6 + +LDPARAM 1 + jsr SetPath + +LDPARAM 3 + jsr AddToPath + +LDPARAMPTR 5, ldrlo ; set load address + jsr SwitchToBank2 + lda #1 ; request aux memory + jsr LoadFileAuxInternal + jmp SwitchToBank1 + +;------------------------------------------------------------------------------ +; LoadDHRFile +; load .A2FC file (uncompressed double hi-res graphics) into memory +; all at once, using ProRWTS2 +; first $2000 bytes of file are loaded into auxiliary memory $4000..$5FFF +; second $2000 bytes of file are loaded into main memory $4000..$4FFF +; +; supports paths, see note +; +; in: stack contains 4 bytes of parameters: +; +1 [word] address of length-prefixed pathname +; +3 [word] address of length-prefixed filename +; out: all flags clobbered +; all registers clobbered +; stack set to next instruction after parameters +;------------------------------------------------------------------------------ +LoadDHRFile + +PARAMS_ON_STACK 4 + +LDPARAM 1 + jsr SetPath + +LDPARAM 3 + jsr AddToPath + jsr SwitchToBank2 + jsr LoadDHRFileInternal + jmp SwitchToBank1 + +gRootDirectory + !word $FDFD diff --git a/src/glue.prorwts2.lc2.a b/src/glue.prorwts2.lc2.a new file mode 100644 index 0000000..c68bfcc --- /dev/null +++ b/src/glue.prorwts2.lc2.a @@ -0,0 +1,91 @@ +;license:MIT +;(c) 2018-2020 by 4am & qkumba +; +; ProRWTS2 glue functions +; +; /!\ These live in LC RAM 2 and rely on the ProRWTS code which is also in LC RAM 2. /!\ +; Code in LC RAM 1 (which is most program code) should call the functions in glue.prorwts2 +; and parse.prefs which handle bank switching for you. + +LoadFileInternal + lda #0 ; 0 = read into main memory +LoadFileAuxInternal + sta @auxreq+1 ; call with A=1 to load directly into aux memory + +LDADDR gPathname +!if RELBASE != $2000 { + !ifdef PASS2 { + } else { ;PASS2 + !if * != LoadFileDirect { + !error "LoadFileDirect=",*, ", fix constants.a" + } + } +} + +ST16 namlo ; set filename + jsr traverse ; go to subdirectory, set up filename for read + lda #cmdread ; read (instead of write) + sta reqcmd + lsr + sta auxreq + lda ldrlo+1 + bne + ; if caller provided a load address, use it + sta sizelo ; otherwise query the load address from file metadata + sta sizehi ; 0 = query load address + jsr hddopendir ; call ProRWTS2 + +LD16 ldrlo2 + +ST16 ldrlo ++ lda #$FF ; read entire file (ProRWTS2 will figure out exact size) + sta sizehi +!if RELBASE != $2000 { + !ifdef PASS2 { + } else { ;PASS2 + !if *+1 != iAuxReq { + !error "iAuxReq=",*+1, ", fix constants.a" + } + } +} +@auxreq + lda #0 + sta auxreq +JumpOpen + jmp hddopendir ; exit via ProRWTS2 + +LoadDHRFileInternal + +LDADDR gPathname + +ST16 namlo ; set filename + jsr traverse ; go to subdirectory, set up filename for read + lda #$20 + sta sizehi + asl + sta ldrhi ; into $4000 + lda #cmdread ; read (instead of write) + sta reqcmd + ;;lda #1 ; 1 = read into aux memory + sta auxreq + lsr ; read first $2000 bytes + sta sizelo + sta ldrlo + jsr hddopendir ; call ProRWTS2 + lda #$20 ; read next $2000 bytes + sta sizehi + dec auxreq ; 0 = read into main memory + clc ; not a subdirectory + jmp hddrdwrpart ; call ProRWTS2 + +SaveSmallFileInternal + +LDADDR gPathname + +ST16 namlo ; set filename for ProRWTS2 + jsr traverse ; go to subdirectory, set up filename for read + ;lda #cmdread ; read (instead of write) + ;sta reqcmd + lda #0 ; 0 = read into main memory + sta sizelo + ;sta sizehi ; 0 = query load address + ;jsr hddopendir ; call ProRWTS2 + ;lda ldrlo2 + sta ldrlo + lda #$80 ;lda ldrhi2 + sta ldrhi + lda #cmdwrite ; write (instead of read) + sta reqcmd + sta sizehi ; 512 bytes + bne JumpOpen ; exit via ProRWTS2 (must re-open the file after query) diff --git a/src/hw.accel.a b/src/hw.accel.a new file mode 100755 index 0000000..9f92c2e --- /dev/null +++ b/src/hw.accel.a @@ -0,0 +1,382 @@ +;license:MIT +;(c) 2019-2020 by 4am & qkumba +; +; Functions to enable and disable acceleration on various +; Apple II models, cards, and environments +; +; Forked from NORMFAST Release 6 (see changelog below) +; +; For Total Replay, we split the machine identification code from +; the (de)acceleration code, because we can do the ID part once +; at program startup (when ROM is easily available), then +; (de)accelerate repeatedly from the language card (when ROM +; is switched out). +; +; -------------------------------------------------------------- +; +; Original changelog and documentation: +; +;;; NORMFAST Disable/enable Apple II compatible accelerator +; (no copyright info given) +; +; Release 7 2019-11-27 FASTChip control just like ZipChip. +; Prevents unexpected acceleration by user. +; +; Release 6 2017-10-05 Fix Mac IIe card check +; +; Release 5 2017-09-27 Add Macintosh IIe Card. Addon +; accelerators are now set blindly, so will access +; annunciators/IIc locations and may trigger the +; paddle timer. +; No plans for the Saturn Systems Accelerator which would +; require a slot search. +; +; Release 4 2017-09-06 Add Laser 128EX, TransWarp I, UW +; +; Release 3 2017-08-29 Change FASTChip partially back to +; release 1, which seems to work the way release 2 was +; intended?! +; +; Release 2 2017-08-27 change enable entry point, add Zip +; Chip, change setting FASTChip speed to disable/enable +; +; Release 1 2017-08-25 IIGS, //c+ and FASTChip +; +; WARNING: The memory location to set the accelerator +; speed may overlap existing locations such as: +; annuciators or Apple //c specific hardware +; paddle trigger +; +; Known to work: IIGS, //c+ +; Theoretically: FASTChip, Laser 128EX, Mac IIe Card, +; TransWarp I, trademarked German product, Zip Chip +; +; BRUN NORMFAST or CALL 768 to disable the accelerator. +; CALL 771 to enable the accelerator. +; Enabling an older accelerator may set maximum speed. +; Accelerators such as the FASTChip or Zip Chip can run +; slower than 1Mhz when enabled. +; +; NORMFAST is position independent and can be loaded most +; anywhere in the first 48K of memory. +; The ROMs must be enabled to identify the model of the +; computer. +; +; This was originally for the //c+ which is normally +; difficult to set to 1Mhz speed. +; The other expected use is to set the speed in a program. +; +; Written for Andrew Jacobs' Java based dev65 assembler at +; http://sourceforge.net/projects/dev65 but has portability +; in mind. + +; addresses are lowercase, constant values are in CAPS + +romid = $FBB3 +; $38=][, $EA=][+, $06=//e compatible +ROMID_IIECOMPAT = 6 +romid_ec = $FBC0 +; $EA=//e original, $E0=//e enhanced, $E1=//e EDM, $00=//c +; Laser 128s are $E0 +romid_c = $FBBF +; $FF=original, $00=Unidisk 3.5 ... $05=//c+ +ROMID_CPLUS = 5 +romid_maciie_2 = $FBDD ; 2 + +; IIGS +idroutine = $FE1F ; SEC, JSR $FE1F, BCS notgs +gsspeed = $C036 +GS_FAST = $80 ; mask + +; //c+ Cache Glue Gate Array (accelerator) +cgga = $C7C7 ; entry point +CGGA_ENABLE = 1 ; fast +CGGA_DISABLE = 2 ; normal +CGGA_LOCK = 3 +CGGA_UNLOCK = 4 ; required to make a change + +; Macintosh IIe Card +maciie = $C02B +MACIIE_FAST = 4 ; mask + +l128irqpage = $C4 +; From the 4.2, 4.5 and EX2 ROM dumps at the Apple II +; Documentation Project, the Laser 128 IRQ handlers are +; in the $C4 page. +; A comp.sys.apple2 post says the 6.0 ROM for the 128 and +; 128EX are identical, so there may not be an easy way to +; tell a plain 128 from an (accelerated) 128EX. +irq = $FFFE ; 6502 IRQ vector + +; may overlap with paddle trigger +ex_cfg = $C074 ; bits 7 & 6 for speed +EX_NOTSPEED = $3F +EX_1MHZMASK = $0 +EX_2MHZMASK = $80 ; 2.3Mhz +EX_3MHZMASK = $C0 ; 3.6Mhz + +; FASTChip +fc_lock = $C06A +fc_enable = $C06B +fc_speed = $C06D +fc_config = $C06E +fc_data = $C06F +FC_UNLOCK = $6A ; write 4 times +FC_LOCK = $A6 +FC_1MHZ = 9 +FC_ON = 40 ; doco says 16.6Mhz + +; TransWarp I +; may overlap with paddle trigger +tw1_speed = $C074 +TW1_1MHZ = 1 +TW1_MAX = 0 + +; Zip Chip +; overlaps annunciator 1 & //c vertical blank +zc_lock = $C05A +ZC_UNLOCK = $5A ; write 4 times +ZC_LOCK = $A5 +zc_enable = $C05B + +iobase = $C000 ; easily confused with kbd + +BuildAcceleratorFunction +; in: none +; out: A/Y points to lo/hi address of code block +; X contains length of code block + + ;; first check built-in accelerators + ldx romid + cpx #ROMID_IIECOMPAT + bne build_addon ; not a //e + + ldx romid_ec + beq iic ; //c family + + ; not worth the bytes for enhanced //e check + ldx irq+1 + cpx #l128irqpage + bne gscheck + + ; a Laser 128, hopefully harmless on a non EX + + ldy #EX_3MHZMASK ; phew, all needed bits set + ldx #<(ex_cfg) + bne build_setspeed ; always branches + +gscheck + pha + sec + jsr idroutine + pla + bcs maccheck ; not a gs + + ; set IIGS speed + + ldy #GS_FAST + ldx #<(gsspeed) + bne build_setspeed ; always branches + +maccheck + ldx romid_maciie_2 + cpx #2 + bne build_addon ; no built-in accelerator + + ; the IIe Card in a Mac + + ldy #MACIIE_FAST + ldx #<(maciie) + bne build_setspeed ; always branches + +iic + lda #$D0 + sta FASTChip + lda #(skip_fc-FASTChip)-2 + sta FASTChip+1 + lda #$9D + sta fixiic + lda #$C0 + sta fixiic+2 + ldx romid_c + cpx #ROMID_CPLUS + bne build_addon ; not a //c+, eventually hit Zip + + lda #iicplus + ldx #(end_iicplus-iicplus) + rts + +build_setspeed + stx setspeed_x + sty setspeed_y + lda #setspeed + ldx #(end_setspeed-setspeed) + rts + +build_addon + lda #addon + ldx #(end_addon-addon) + rts + +;----------------------------------------------------------- +; 3 distinct accelerator functions +; +; Only 1 of these will be required on any particular machine. +; +; Each has 2 entry points, +0 to disable acceleration and +; +3 to enable acceleration. +; +; setspeed must be self-modified before use (setspeed_x and +; setspeed_y). +; +;----------------------------------------------------------- + +; Function #1: Apple IIc+ +iicplus !pseudopc DisableAccelerator { +; Set //c+ speed. Uses the horrible firmware in case other +; code works "by the book", that is can check and set +; whether the accelerator is enabled. +; The //c+ is otherwise Zip compatible. +; This code cannot run from LC, and *must* bank in ROM. +; CGGA assumes that ROM is already banked in. + + lda #$3A ; DEC, disable accelerator entry point + !byte $2C ; BIT , hide next lda # + lda #$4A ; LSR, enable accelerator entry point + sta @pokery ; action after CGGA_UNLOCK + + ; cgga calls save X and Y regs but sets $0 to 0 + ; (this will get a laugh from C programmers) + lda $0 + pha + php + sei ; timing sensitive + jsr @jiggerypokery + lda gMachineInDHGRMode + bne + ; DHGR mode doesn't need fix + sta $C05B ; fix HGR-mode colouring ++ plp ; restore interrupt state + pla + sta $0 + rts + +@jiggerypokery + tsx + ldy #(@endpokery - @jiggery) +@copyiicp + lda @jiggery-1,y + pha + dey + bne @copyiicp + txa + tsx + iny +!cpu 65c02 + phy + phx +!cpu 6502 + tax + rts + +@jiggery + +READ_ROM_NO_WRITE + lda #CGGA_LOCK ; should lock after a change + pha +@pokery + nop ; SMC + pha + lda #CGGA_UNLOCK ; unlock to change + pha + jsr cgga ; disable/enable + jsr cgga + jsr cgga ; reads parm from stack, must JSR + txs + +READ_RAM2_WRITE_RAM2 + rts +@endpokery +} +end_iicplus + +; Function #2: IIgs, Laser 128EX, or IIe card +;; setspeed - set 1Mhz with AND and fast with OR +; +; A = lsb set for normal speed +; X = low byte address of speed location +; Y = OR mask for fast +setspeed + lda #1 ; disable accelerator entry point + !byte $2C ; BIT , hide next lda # + lda #0 ; enable accelerator entry point + +setspeed_x=*+1 + ldx #$FD ; SMC +setspeed_y=*+1 + ldy #$FD ; SMC + lsr + tya + bcs setnorm + ora iobase,x + ldy #$d6 + bne setsta ; always branches +setnorm + eor #$FF + and iobase,x + ldy #$56 +setsta + sta iobase,x + sty $7FE ; Laser checks it + rts +end_setspeed + +; Function #3: Card-based accelerator (TransWarp, ZipChip, +; FastChip, &c.) +; We blindly set switches for all known cards. +addon + lda #1 ; disable accelerator entry point + !byte $2C ; BIT , hide next lda # + lda #0 ; enable accelerator entry point + + ; TransWarp I + sta tw1_speed + + ; no UW support here because the softswitch to enable + ; acceleration triggers DHGR bugs in OpenEmulator :-( + + ; Zip Chip + ldy #FC_1MHZ + eor #1 + tax + beq + + ldy #FC_ON ++ lda #ZC_UNLOCK + php + sei ; following sequence is timing sensitive + sta zc_lock + sta zc_lock + sta zc_lock + sta zc_lock + lsr ; not ZC_LOCK or ZC_UNLOCK + sta zc_lock,x ; disable/enable + lda #ZC_LOCK + sta zc_lock + +FASTChip + lda #FC_UNLOCK + sta fc_lock + sta fc_lock + sta fc_lock + sta fc_lock + sta fc_enable + sty fc_speed + lda #FC_LOCK + sta fc_lock +skip_fc + ldx gMachineInDHGRMode +fixiic + bit $D05F ; fix colouring on IIc (SMC to STA,X on IIc) ++ plp ; restore interrupt state + rts +end_addon diff --git a/src/hw.accel.lc2.a b/src/hw.accel.lc2.a new file mode 100644 index 0000000..5287d12 --- /dev/null +++ b/src/hw.accel.lc2.a @@ -0,0 +1,17 @@ +;license:MIT +;(c) 2019 by 4am & qkumba +; +; Functions to enable and disable acceleration on various +; Apple II models, cards, and environments +; +; /!\ These live in LC RAM 2 and rely on other code which is also in LC RAM 2. /!\ +; (EnableAccelerator and DisableAccelerator are copied into LC2 in 4sports.init.) +; You can call these functions directly if and only if you are already in LC2. + +EnableAcceleratorAndSwitchToBank1 + jsr EnableAccelerator + jmp SwitchToBank1 + +DisableAcceleratorAndSwitchToBank1 + jsr DisableAccelerator + jmp SwitchToBank1 diff --git a/src/hw.joystick.a b/src/hw.joystick.a new file mode 100644 index 0000000..1260eee --- /dev/null +++ b/src/hw.joystick.a @@ -0,0 +1,88 @@ +;------------------------------------------------------------------------------ +; HasJoystick +; Checks whether computer has joystick connected +; +; in: none +; out: C set if joystick found +; C clear if no joystick found +; other flags clobbered +; A,X clobbered +; Y preserved +; +; adapted from "Prince of Persia" by Jordan Mechner +; (c) 1989 Broderbund Software +; https://github.com/jmechner/Prince-of-Persia-Apple-II/blob/master/01%20POP%20Source/Source/GRAFIX.S#L1225 +;------------------------------------------------------------------------------ +; Fastchip firmware 0.4b-compatibility fix by Frank M. (0.5b seems unaffected) +;------------------------------------------------------------------------------ +HasJoystick + + lda $FBB3 + cmp #$06 + bne ++ + lda $FBC0 + cmp #$E0 + beq + ; test for Fastchip on enhanced //e + cmp #$EA + beq + ; test for Fastchip on non-enhanced //e + jmp ++ + ++ ; FASTChip +fc_lock = $C06A +fc_enable = $C06B +fc_config = $C06E +fc_data = $C06F +FC_UNLOCK = $6A ; write 4 times +FC_LOCK = $A6 +FC_SPKR = 2 ; speaker delay register +FC_HIFI = 4 ; set to 'HIFI' +FC_JOY = 3 ; joystick delay register +FC_LONG = 2 ; set to 'LONG' + + lda #FC_UNLOCK + sta fc_lock + sta fc_lock + sta fc_lock + sta fc_lock + sta fc_enable + lda fc_enable ; 00 if no fastchip + cmp #$80 ; 80 if Fastchip normal + bne ++ ; A0 if Fastchip disabled + + lda #FC_JOY ; change Fastchip joystick delay setting to 'LONG' + sta fc_config ; (improves joystick detection) + lda #FC_LONG + sta fc_data + + lda #FC_SPKR ; change Fastchip speaker delay setting to 'HIFI' + sta fc_config ; (improves sound on most games) + lda #FC_HIFI + sta fc_data + + lda #FC_LOCK ; (settings revert on power cycle) + sta fc_lock +++ + lda #0 + sta @joyX + sta @joyY + lda $C070 ; reset analog input timers +@loop ldx #1 +@1 lda $C064,x ; check timer input + bpl @beat + inc @joyX,x ; still high, increment counter +@nextpdl dex + bpl @1 + lda $C064 + ora $C065 + bpl @yes ; both inputs low, we're done + lda @joyX + ora @joyY + bpl @loop ; do it again +@no clc + +HIDE_NEXT_BYTE +@yes sec + rts +@beat nop + bpl @nextpdl ; kill time +@joyX !byte 0 +@joyY !byte 0 diff --git a/src/hw.memcheck.a b/src/hw.memcheck.a new file mode 100644 index 0000000..09b9155 --- /dev/null +++ b/src/hw.memcheck.a @@ -0,0 +1,79 @@ +;------------------------------------------------------------------------------ +; Has64K +; Checks whether computer has functioning language card (64K) +; +; in: none +; out: C clear if 64K detected +; C set if 64K not detected +; all other flags and registers clobbered +; ROM in memory (not LC RAM bank) +;------------------------------------------------------------------------------ +Has64K + +READ_RAM1_WRITE_RAM1 + lda #$AA ; test #1 for $D0 page + sta $D000 + eor $D000 + bne @no + lsr $D000 ; test #2 for $D0 page + lda #$55 + eor $D000 + bne @no + clc + +HIDE_NEXT_BYTE +@no sec + +READ_ROM_NO_WRITE + rts + +;------------------------------------------------------------------------------ +; Has128K +; Checks whether computer has functioning auxiliary memory (128K) +; +; in: none +; out: C set if 128K detected +; C clear if 128K not detected +; all other flags and registers clobbered +; zp $80-$9F clobbered +; ROM in memory (not LC RAM bank) +; +; adapted from "Prince of Persia" by Jordan Mechner +; (c) 1989 Broderbund Software +; https://github.com/jmechner/Prince-of-Persia-Apple-II/blob/master/01%20POP%20Source/Source/BOOT.S#L119 +;------------------------------------------------------------------------------ +Has128K + +READ_ROM_NO_WRITE + sta STOREOFF + lda ROM_MACHINEID + cmp #$A0 + beq + ; Spectrum ED + cmp #6 + bne @no ; earlier than //e -> no 128K ++ lda SLOT3STATUS + bmi @no ; no 80-column card -> no 128K + ldx #@checklen +- lda @checker,x + sta $80,x + dex + bpl - + jmp $80 ; check if auxmem actually works +@checker + lda #$EE + sta WRITEAUXMEM + sta READAUXMEM + sta $0C00 + sta $0800 + lda $0C00 + cmp #$EE + bne @no + asl $0C00 + asl + cmp $0C00 + bne @no + cmp $0800 + bne @yes +@no clc + +HIDE_NEXT_BYTE +@yes sec +@finish sta WRITEMAINMEM + sta READMAINMEM + rts +@checklen=*-@checker diff --git a/src/hw.mockingboard.a b/src/hw.mockingboard.a new file mode 100644 index 0000000..05c36b7 --- /dev/null +++ b/src/hw.mockingboard.a @@ -0,0 +1,250 @@ +;license:MIT +;(c) 2019-2020 by Andrew Roughan, qkumba, 4am, Tom Charlesworth, Rob Justice +; +; Mockingboard support functions +; + +;------------------------------------------------------------------------------ +; GetMockingboardStuff +; detect Mockingboard card by searching for 6522 timers across all slots 7->1 +; access 6522 timers with deterministic cycle counts +; +; based on prior art in Mockingboard Developers Toolkit +; with optimisation from deater/french touch +; also takes into account FastChip //e clock difference +; +; in: A/Y contains address of callback to call if card was found +; (this will be called before the speech detection routine, and +; (zp$81 will contain the slot in form $Cx) +; /!\ ALL ACCELERATORS MUST BE OFF OR SET TO 1 MHZ +; out: if card was found, X = #$?n where n is the slot number of the card, otherwise #$00 +; and bit 6 = 0 if Mockingboard Sound I found +; or bit 6 = 1 if Mockingboard Sound II or "A" found +; and bit 7 = 1 if Mockingboard Sound/Speech I or "C" found +; flags clobbered +; zp $80-$82 clobbered +; A/Y clobbered +;------------------------------------------------------------------------------ +GetMockingboardStuff + +ST16 @callback+1 + lda #$00 + sta $80 + sta $82 ; type + ldx #$C1 +@slotLoop + stx $81 + ldy #$04 ; 6522 #1 $Cx04 + jsr @timercheck + bcc @foundI + +@nextSlot + inx + cpx #$C8 + bne @slotLoop + ldx #$00 ; not found + rts + +@foundI ; sound I or better + jsr @callback + ldy #$84 ; 6522 #2 $Cx84 + jsr @timercheck + bcc @foundII + + ldy #$0c + sty @mb_smc1 + 1 + iny + sty @mb_smc10 + 1 + iny + sty @mb_smc5 + 1 + sty @mb_smc14 + 1 + clc + + +HIDE_NEXT_BYTE +@foundII ;stereo + sec + ror $82 + + lda $81 + sta @mb_smc1 + 2 + sta @mb_smc2 + 2 + sta @mb_smc3 + 2 + sta @mb_smc4 + 2 + sta @mb_smc5 + 2 + sta @mb_smc6 + 2 + sta @mb_smc7 + 2 + sta @mb_smc8 + 2 + sta @mb_smc9 + 2 + sta @mb_smc10 + 2 + sta @mb_smc11 + 2 + sta @mb_smc12 + 2 + sta @mb_smc13 + 2 + sta @mb_smc14 + 2 + sta @mb_smc15 + 2 + sta @mb_smc17 + 2 + sta @mb_smc18 + 2 + sta @mb_smc19 + 2 + sta @mb_smc20 + 2 + sta @mb_smc21 + 2 + sta @mb_smc22 + 2 + + ; detect speech - SSI263 + + sei + +READ_RAM2_WRITE_RAM2 + lda #$40 ; setup NMI vector (rti) + sta $3fb + lda #$fb + sta $fffa + lda #3 + sta $fffb + lda #<@mb_irq ; setup IRQ vector + sta $3fe + sta $fffe + lda #>@mb_irq + sta $3ff + sta $ffff + + lda #$0c ; CB2 - input neg edge, CB1 neg edge, CA2 low output, CA1 neg edge +@mb_smc1 + sta $c48c ; peripheral control register 6522#2 + lda #$80 ; ctl=1 +@mb_smc2 + sta $c443 ; C = SSI reg 3, S/S I or A = 6522#1 ddr a + lda #$c0 ; duration=11 phoneme=000000 (pause) +@mb_smc3 + sta $c440 ; C = SSI reg 0, S/S I or A = 6522#1 port b data + lda #$70 ; ctl=0 (A/R active - phoneme timing response) +@mb_smc4 + sta $c443 ; C = SSI reg 3, S/S I or A = 6522#1 ddr a + lda #$82 ; enable CA1 interrupt +@mb_smc5 + sta $c48e ; interrupt enable register 6522#2 + + ldx #$80 ; 0= ~650ms, 80 = ~325ms + ldy #0 + sec + cli + +@wait_irq + lda $80 + bne @got_irq + iny + bne @wait_irq + inx + bne @wait_irq + + ; detect speech - SC-01 + ;based on S/S I demo dsk + ;init sc-01 interface + lda #$ff +@mb_smc15 + sta $c402 ; ddr portb - all outputs + lda #$b0 ; cb2 pulse output,cb1 pos edge +@mb_smc17 + sta $c40c ; pcr + lda #$10 ; clear all interrupt flags +@mb_smc18 + sta $c40d ; ifr + ;output stop phoneme + lda #$3f ; stop +@mb_smc19 + sta $c400 ; orb, write phoneme & pitch + + ldx #$D0 ; wait ~120ms, stop takes 47ms +- lda #$10 +@mb_smc20 + bit $c40d ; ifr, check for cb1 interrupt flag + bne + ; flag set, we found one + iny + bne - + inx + bne - + clc ; not found + bcc @got_irq + +@mb_smc21 ++ sta $c40d ; ifr, clear flag + lda #$00 ; turn off cb2 pulse mode to disable false writes to sc01 +@mb_smc22 + sta $c40c ; pcr + sec ; found, we have an S/S I + ror $82 + ldy #$ff + bcc @ssI + +@got_irq + sei + ror $82 + +@onlyI + ldy #$ff +@mb_smc6 + sty $c403 ; 6522#1 ddra + lda #7 +@mb_smc7 + sta $c402 ; 6522#1 ddrb + + iny + sty $80 + tya + sta ($80),y ; 6522#1 orb + lda #4 + sta ($80),y ; 6522#1 orb + dey +@ssI +@mb_smc8 + sty $c483 ; 6522#2 ddra + lda #7 +@mb_smc9 + sta $c482 ; 6522#2 ddrb + + iny + tya + ldy #$80 + sta ($80),y ; 6522#2 orb + lda #4 + sta ($80),y ; 6522#2 orb + + lda #7 + and $81 + ora $82 + tax + lda #Ignore + sta $ffff + +READ_ROM_NO_WRITE + + rts ; found + +@timercheck + sec + lda ($80),y ; read 6522 timer low byte + sbc ($80),y ; second time + sec + sbc #5 ; looking for 5 cycles between reads + cmp #2 ; or 6 cycles with the FastChip //e + rts + +@mb_irq + lda #2 ; clear CA1 interrupt flag +@mb_smc10 + sta $c48d ; interrupt flag register 6522#2 + lda #$80 ; ctl=1 +@mb_smc11 + sta $c443 ; C = SSI reg 3, S/S I or A = 6522#1 ddr a + lda #0 ; duration=00 phoneme=000000 (pause) +@mb_smc12 + sta $c440 ; C = SSI reg 0, S/S I or A = 6522#1 port b data + lda #$70 ; ctl=0 (A/R active - phoneme timing response) +@mb_smc13 + sta $c443 ; C = SSI reg 3, S/S I or A = 6522#1 ddr a + sta $80 ; found + lda #2 ; disable CA1 interrupt +@mb_smc14 + sta $c48e ; interrupt enable register 6522#2 + lda $45 + rti + +@callback + jmp $FDFD ; SMC diff --git a/src/hw.vbl.a b/src/hw.vbl.a new file mode 100644 index 0000000..d0fa9b6 --- /dev/null +++ b/src/hw.vbl.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2020 by qkumba +; +; Functions to enable and disable VBL polling on various +; Apple II models + +iWaitForVBL + sei ; IIc is special + sta $C07F ; enable access to VBL register + sta $C05B ; enable VBL polling + sta $C07E ; disable access to VBL register +WaitForVBL_iie ; IIe/IIgs have a relatively sane VBL + ; but it's reversed between the two + ; so we default to IIe, and patch in + ; the reverse case if it's a IIGS. +patch_VBL_iic1 +- lda $C019 ; $c019 bit 7 is sticky, reset it (SMC->#$70 for IIc) +patch_VBL_iigs1 +patch_VBL_iic2 + bpl - +- bit $C019 +patch_VBL_iic3 +patch_VBL_iigs2 + bmi - +WaitForVBL_nop ; II/II+ have no easy VBL + rts + +iUnwaitForVBL + lda $C070 ; $c019 bit 7 is sticky, reset it +- bit $C019 + bpl - + sta $C07F ; enable access to VBL register + sta $C05A ; disable VBL polling + sta $C07E ; disable access to VBL register + cli + rts diff --git a/src/hw.vbl.init.a b/src/hw.vbl.init.a new file mode 100644 index 0000000..de55884 --- /dev/null +++ b/src/hw.vbl.init.a @@ -0,0 +1,51 @@ +;license:MIT +;(c) 2020 by qkumba +; +; Identify platform and construct appropriate VBL routine + +romid = $FBB3 +; $38=][, $EA=][+, $06=//e compatible +ROMID_IIECOMPAT = 6 +romid_ec = $FBC0 +; $EA=//e original, $E0=//e enhanced, $E1=//e EDM, $00=//c +romid_mac = $FBDD +ROMID_IIECARD = 2 + +; IIGS +idroutine = $FE1F ; SEC, JSR $FE1F, BCS notgs + +BuildVBLFunction + ldx romid + cpx #ROMID_IIECOMPAT + bne @build_none ; not a //e + lda romid_ec + beq @build_iic ; //c family + lda romid_mac + cmp #ROMID_IIECARD + beq @build_none ; broken in some versions, disable + sec + jsr idroutine ; check for IIgs + bcs @NotGS + lda #$30 + sta patch_VBL_iigs1 + lda #$10 + sta patch_VBL_iigs2 +@NotGS + rts +@build_iic + sta patch_VBL_iic2+1 + lda #$70 + sta patch_VBL_iic1+1 + lda #$10 + sta patch_VBL_iic3 + lda #iWaitForVBL + sta WaitForVBL+2 + lda #$4C + sta UnwaitForVBL + rts +@build_none + lda #$60 + sta WaitForVBL + rts diff --git a/src/hw.vidhd.a b/src/hw.vidhd.a new file mode 100644 index 0000000..12d7f6a --- /dev/null +++ b/src/hw.vidhd.a @@ -0,0 +1,39 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; VidHD support functions +; + +;------------------------------------------------------------------------------ +; HasVidHDCard +; detect VidHD card by searching for magic bytes across all slots +; +; in: none +; out: C set if VidHD card found in any slot +; if card was found, X = #$Cn where n is the slot number of the card +; C clear if no VidHD card found +; other flags clobbered +; A/Y clobbered +;------------------------------------------------------------------------------ +HasVidHDCard + ldx #$C7 +@slotLoop + stx @byteLoop+2 + ldy #$02 +@byteLoop + lda $FD00, y ; SMC (high byte) + cmp @kVidHDMagicBytes, y + bne @nextSlot + dey + bpl @byteLoop +@found + sec ; found + rts +@nextSlot + dex + cpx #$C0 + bne @slotLoop + clc ; not found + rts +@kVidHDMagicBytes + !byte $24, $EA, $4C diff --git a/src/macros.a b/src/macros.a new file mode 100755 index 0000000..6c5a8dd --- /dev/null +++ b/src/macros.a @@ -0,0 +1,392 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; common assembler macros (6502 compatible) +; + +!ifndef _MACROS_ { + !source "src/constants.a" + +; for functions that take parameters on the stack +; set (PARAM) to point to the parameters and +; move the stack pointer to the first byte after the parameters +; clobbers A,X,Y +!macro PARAMS_ON_STACK .bytes { + pla + sta PARAM + clc + adc #.bytes + tay + pla + sta PARAM+1 + adc #0 + pha + tya + pha +} + +; for functions that take parameters on the stack +; load a 16-bit value from the parameters on the stack into A (low) and Y (high) +; (assumes PARAMS_ON_STACK was used first) +!macro LDPARAM .offset { + ldy #.offset + lda (PARAM),y + pha + iny + lda (PARAM),y + tay + pla +} + +; for functions that take parameters on the stack +; load a 16-bit value from the parameters on the stack into A (low) and Y (high) +; then store it as new source +; (assumes PARAMS_ON_STACK was used first) +!macro LDPARAMPTR .offset,.dest { + ldy #.offset + lda (PARAM),y + sta .dest + iny + lda (PARAM),y + sta .dest+1 +} + +; load the address of .ptr into A (low) and Y (high) +!macro LDADDR .ptr { + lda #<.ptr + ldy #>.ptr +} + +; load a 16-bit value into A (low) and Y (high) +!macro LD16 .ptr { + lda .ptr + ldy .ptr+1 +} + +; load a 16-bit value into X (low) and Y (high) +!macro LDX16 .ptr { + ldx .ptr + ldy .ptr+1 +} + +; store a 16-bit value from A (low) and Y (high) +!macro ST16 .ptr { + sta .ptr + sty .ptr+1 +} + +; store a 16-bit value from X (low) and Y (high) +!macro STX16 .ptr { + stx .ptr + sty .ptr+1 +} + +; decrement a 16-bit value in A (low) and Y (high) +!macro DEC16 { + sec + sbc #1 + bcs + + dey ++ +} + +; decrement a 16-bit value in X (low) and Y (high) +; destroys A! +!macro DEX16 { + txa + bne + + dey ++ dex +} + +; increment a 16-bit value in A (low) and Y (high) +!macro INC16 { + clc + adc #1 + bne + + iny ++ +} + +; increment a 16-bit value in X (low) and Y (high) +!macro INX16 { + inx + bne + + iny ++ +} + +; compare a 16-bit value in A (low) and Y (high) to an absolute address +; zeroes A! +!macro CMP16ADDR .addr { + eor .addr + bne + + cpy .addr+1 ++ +} + +; compare a 16-bit value in X (low) and Y (high) to an absolute address +!macro CPX16ADDR .addr { + cpx .addr + bne + + cpy .addr+1 ++ +} + +; compare a 16-bit value in A (low) and Y (high) to an immediate value +!macro CMP16 .val { + cmp #<.val + bne + + cpy #>.val ++ +} + +; compare a 16-bit value in X (low) and Y (high) against zero +; requires LDX16 immediately prior, since Y comparison is implicit! +; destroys A! +!macro CPX16_0 { + bne + + txa ++ +} + +!macro LBPL .target { + bmi + + jmp .target ++ +} + +!macro LBMI .target { + bpl + + jmp .target ++ +} + +!macro LBNE .target { + beq + + jmp .target ++ +} + +!macro LBCS .target { + bcc + + jmp .target ++ +} + +; use BIT to swallow the following 1-byte opcode +!macro HIDE_NEXT_BYTE { + !byte $24 +} + +; use BIT to swallow the following 2-byte opcode +!macro HIDE_NEXT_2_BYTES { + !byte $2C +} + +; debugging +!macro DEBUGWAIT { + bit $c010 +- bit $c000 + bpl - + bit $c010 +} + +; various language card configurations +!macro READ_RAM1_NO_WRITE { + bit $C088 +} + +!macro READ_RAM1_WRITE_RAM1 { + bit $C08B + bit $C08B +} + +!macro READ_RAM2_NO_WRITE { + bit $C080 +} + +!macro READ_RAM2_WRITE_RAM2 { + bit $C083 + bit $C083 +} + +!macro READ_ROM_WRITE_RAM1 { + bit $C089 + bit $C089 +} + +!macro READ_ROM_WRITE_RAM2 { + bit $C081 + bit $C081 +} + +!macro READ_ROM_NO_WRITE { + bit $C082 +} + +; requires setting zpCharMask in zero page to #$FF or #$DF before use +!macro FORCE_UPPERCASE_IF_REQUIRED { + cmp #$E1 + bcc + + and zpCharMask ++ +} + +!macro HGR_BYTE_TO_DHGR_BYTES { +;1GFEDCBA -> +;1GGFFEED (main) + +;1DCCBBAA (aux) +; +; in: A = HGR byte +; out: A = DHGR byte in mainmem +; X = DHGR byte in auxmem +; preserves Y +; clobbers zero page $00,$01,$02 + sty $02 + ldy #$02 +-- stx $01 + ldx #$04 +- ror $00 ; duplicate previous bit + lsr ; fetch bit + php + ror $00 ; insert bit + plp + dex + bne - + ldx $00 + dey + bne -- + txa + sec + ror $01 ; set bit 7 explicitly on auxmem value + ldx $01 + ldy $02 +} + +; these are mostly for prelaunchers -- code in the main program should keep track of which bank is active to minimize code size +!macro ENABLE_ACCEL { + +READ_RAM2_NO_WRITE + jsr EnableAccelerator + +READ_ROM_NO_WRITE +} + +!macro DISABLE_ACCEL { + +READ_RAM2_NO_WRITE + jsr DisableAccelerator + +READ_ROM_NO_WRITE +} + +!macro GET_MACHINE_STATUS { + +READ_RAM2_NO_WRITE + lda MachineStatus + +READ_ROM_NO_WRITE +} + +!macro GET_MOCKINGBOARD_SPEECH { ;carry set if present + +READ_RAM2_NO_WRITE + lda MockingboardStuff + asl + +READ_ROM_NO_WRITE +} + +!macro GET_MOCKINGBOARD_SPEECH_AND_MACHINE_STATUS { ;carry set if present + +READ_RAM2_NO_WRITE + lda MockingboardStuff + asl + lda MachineStatus + +READ_ROM_NO_WRITE +} + +!macro GET_MOCKINGBOARD_SLOT { ;carry set if present + +READ_RAM2_NO_WRITE + lda MockingboardStuff + cmp #1 + ora #$C0 + +READ_ROM_NO_WRITE +} + +!macro GET_MOCKINGBOARD_SLOT_AND_MACHINE_STATUS { ;carry set if present + +READ_RAM2_NO_WRITE + lda MockingboardStuff + cmp #1 + ora #$C0 + tax + lda MachineStatus + +READ_ROM_NO_WRITE +} +!macro USES_TEXT_PAGE_2 { + lda ROM_MACHINEID + cmp #$06 + bne + + sec + jsr $FE1F ; check for IIgs + bcs + + jsr ROM_TEXT2COPY ; set alternate display mode on IIgs (required for some games) + cli ; enable VBL interrupts ++ +} + +!macro RESET_VECTOR .addr { + lda #<.addr + sta $3F2 + lda #>.addr + sta $3F3 + eor #$A5 + sta $3F4 +} + +; for games that clobber $100-$105, the prelaunch code constructs a new reset vector +; somewhere else and sets its +!macro NEW_RESET_VECTOR .addr { + lda #$2C + sta .addr + lda #$88 + sta .addr+1 + lda #$C0 + sta .addr+2 + lda #$6C ; JMP ($FFFC) points to 'Reenter' + sta .addr+3 + lda #$FC + sta .addr+4 + lda #$FF + sta .addr+5 + +RESET_VECTOR .addr +} + +; for 64k games on ][+ which either hang or restart +; updates reset hook to reboot on ctrl-reset +!macro LC_REBOOT { + inc $101 ; (assumes LC is switched in) + lda #$A6 + sta $104 + lda #$FA + sta $105 ; update reset hook to reboot + lda #1 + sta $FFFD + lsr + sta $FFFC ; LC reset vector fix +} + +; load an external file by pathname +; LC RAM 2 MUST BE BANKED IN +; LOW BYTE OF .addr MUST BE $00 +!macro LOAD_FILE_AT .filepath, .addr { + lda #0 + sta iAuxReq ; read to main memory + lda #>.addr + sta ldrhi + lda iCurBlockLo + pha + lda iCurBlockHi + pha + +LDADDR .filepath + jsr LoadFileDirect + pla + sta iCurBlockHi + pla + sta iCurBlockLo +} + +_MACROS_=* +} diff --git a/src/okvs.a b/src/okvs.a new file mode 100644 index 0000000..f9ef0dc --- /dev/null +++ b/src/okvs.a @@ -0,0 +1,562 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Ordered key/value store (6502 compatible)(256+ records compatible) +; +; Public functions +; - okvs_init(address) reset (required) +; - okvs_len(address) get number of keys +; - okvs_append(address, key, value, max_len) add new key/value pair +; - okvs_update(address, key, value) update key/value pair +; - okvs_get(address, key) get value by key lookup +; - okvs_find(address, key) get key by key lookup +; - okvs_nth(address, n) get key by numeric index +; - okvs_next(address, n) get next key by numeric index +; - okvs_iter(address, callback) iterate through keys +; - okvs_iter_values(address, callback) iterate through values +; +; Call init() once. Call it again to reset the store to 0 records. +; +; Records are maintained in a singly linked list, so most functions are O(n). +; len() and append() are O(1) though. +; +; Record count is stored as a word, so a store can hold 65535 records. +; +; Keys and values are length-prefixed strings (Pascal style), so max length +; of any single key or value is 255 bytes. +; +; Keys are case-sensitive. Lookups are an exact byte-for-byte comparison. +; +; append() has a max_len argument to reserve more space for the value, in case +; you want to update it later. max_len is the total space to reserve, not the +; additional space. One exception: max_len can be 0, and it will be treated as +; length(value) at append time. update() always modifies the value in place. +; There is no range checking because this is assembly. + +; All functions take the starting address of the store's data buffer in +; memory, so there can be multiple independent stores at one time. The next- +; record pointers are actual memory addresses, so stores are not easily +; relocatable. append() will happily extend the store's data buffer without +; limit. There is no overflow protection because this is assembly. +; +; There is no sort() function. +; +; There is no delete() function. +; +; Keys can be duplicated, but get() and find() will always return the one that +; was append()ed first. +; +; Structures: +; +; Store +; +0 number of records (word) +; +2 free space pointer after last record (word) +; +4 Record +; ...Record... +; ...Record... +; +; Record +; +0 next-record pointer (word) +; +2 key length +; +3 key +; +K+2 value length (actual length, not max length) +; +K+3 value +; ... filler bytes up to value max length (set at append() time) + +;------------------------------------------------------------------------------ +; okvs_init +; +; in: A/Y = handle to storage space +; out: $00/$01 clobbered +; $02/$03 clobbered +; all registers clobbered +;------------------------------------------------------------------------------ +okvs_init + jsr GetStoreAddressFromAY + ; PTR -> store + ; Y = 0 + tya + sta (PTR),y ; set number of keys in store to 0 (word) + iny + sta (PTR),y + + iny ; set next-free-space pointer to store + 4 + ldx PTR+1 + lda PTR + clc + adc #$04 + bcc + + inx ++ sta (PTR),y + iny + txa + sta (PTR),y + rts + +;------------------------------------------------------------------------------ +; okvs_len +; +; in: A/Y = handle to storage space +; out: $WCOUNT contains number of keys in this store +; X preserved +; A, Y clobbered +; $00/$01 clobbered +; $02/$03 clobbered +;------------------------------------------------------------------------------ +okvs_len + jsr GetStoreAddressFromAY + ; PTR -> store + ; Y = 0 + lda (PTR), y ; get number of keys in store (word) + sta WCOUNT + iny + lda (PTR), y + sta WCOUNT+1 + rts + +;------------------------------------------------------------------------------ +; okvs_append +; +; in: stack contains 7 bytes of parameters: +; +1 [word] handle to storage space +; +3 [word] address of key +; +5 [word] address of value +; +7 [byte] maximum length of value (or 0 to fit) +; out: (new record count is not returned because no one cares) +; all registers clobbered +; $00/$01 clobbered +; $02/$03 clobbered +; $04/$05 has the address of the next available byte after the new record +; $08/$09 clobbered +;------------------------------------------------------------------------------ +okvs_append + +PARAMS_ON_STACK 7 + jsr GetStoreAddress + ; PTR -> store + ; Y = 0 + lda (PTR),y ; A = number of keys in store + sta WINDEX + iny + lda (PTR), y + sta WINDEX+1 + inc WINDEX + bne + + inc WINDEX+1 ++ + dey + lda WINDEX + sta (PTR),y ; increment number of keys + lda WINDEX+1 + iny + sta (PTR),y + iny + lda (PTR),y ; get address of next free space + tax + iny + lda (PTR),y + sta PTR+1 + sta SAVE+1 + stx PTR + stx SAVE + ; PTR -> new record + ; SAVE -> new record + jsr incptr2 + ; PTR -> space for new key + +LDPARAMPTR 3, SRC ; SRC -> new key to copy + ldy #0 + lda (SRC),y + tay + tax +- lda (SRC),y ; copy new key + sta (PTR),y + dey + cpy #$FF + bne - + + ;;sec + txa + adc PTR ; update PTR to byte after copied key + sta PTR + bcc + + inc PTR+1 ++ ; PTR -> space for new value + +LDPARAMPTR 5, SRC ; SRC -> new value to copy + iny ;;ldy #7 + lda (PARAM),y ; get max length of value + tax + bne + + tay + lda (SRC),y ; no max, use actual length instead + tax + inx ++ tay +- lda (SRC),y + sta (PTR),y + dey + cpy #$FF + bne - + + txa + clc + adc PTR + sta SRC + bcc + + inc PTR+1 ++ lda PTR+1 + sta SRC+1 ; SRC -> byte after this record + +LD16 SAVE + +ST16 PTR ; PTR -> this record again + ldy #0 + lda SRC ; update next-record pointer + sta (PTR),y + iny + lda SRC+1 + sta (PTR),y + jsr GetStoreAddress + ; PTR -> store + ldy #2 + lda SRC-2,y + sta (PTR),y ; update next-free-space pointer in head + iny + lda SRC-2,y + sta (PTR),y + rts + +;------------------------------------------------------------------------------ +; okvs_find / okvs_get +; +; in: stack contains 4 bytes of parameters: +; +1 [word] handle to storage space +; +3 [word] address of key +; out: if C clear, record was found +; A/Y = lo/hi address of key (okvs_find) or value (okvs_get) +; $WINDEX = index of found record (word) +; if C set, keyrecord was not found and X/Y are clobbered, A=0 +; all other flags clobbered +; $00/$01 clobbered +; $02/$03 clobbered +; $04/$05 clobbered +;------------------------------------------------------------------------------ +okvs_find + lda #$60 + +HIDE_NEXT_2_BYTES +okvs_get + lda #$EA + sta @maybeGetValue + +PARAMS_ON_STACK 4 + jsr GetStoreAddress + ; PTR -> store + ; Y = 0 + lda (PTR),y ; A = number of keys in store + sta WCOUNT + iny + lda (PTR),y + sta WCOUNT+1 + bne + + dey + lda (PTR),y + beq @fail ; no keys, fail immediately ++ + jsr incptr4 + ; PTR -> first record + +LDPARAMPTR 3, SRC ; SRC -> key we want to find + ldy #0 + sty WINDEX + sty WINDEX+1 + lda (SRC),y + tay + iny + sty KEYLEN +@matchRecordLoop + +LD16 PTR + clc + adc #2 + bcc + + iny ; DEST -> key of this record ++ +ST16 DEST + ldy #0 +@matchKeyLoop + lda (SRC),y + cmp (DEST),y + bne @next + iny +KEYLEN = *+1 + cpy #$D1 ; SMC + bne @matchKeyLoop + +LD16 DEST + clc +@maybeGetValue + brk ; SMC + jsr okvs_get_current + +LD16 PTR + clc + rts +@next jsr derefptr ; PTR -> next record + inc WINDEX + bne + + inc WINDEX+1 ++ + lda WINDEX + cmp WCOUNT + bne @matchRecordLoop + lda WINDEX+1 + eor WCOUNT+1 + bne @matchRecordLoop +@fail sec + rts + +okvs_get_current + +ST16 PTR + ldy #0 + lda (PTR),y + clc + adc PTR + sta PTR + bcc + + inc PTR+1 ++ jmp incptr + +;------------------------------------------------------------------------------ +; okvs_next +; get (N+1)th key, with wraparound +; +; in: A/Y = handle to storage space +; $WINDEX = record index (word) +; out: A/Y = lo/hi address of ($WINDEX+1)th key, or first key if $WINDEX was the last record +; $WINDEX = record index of next record +; see okvs_nth for other exit conditions +;------------------------------------------------------------------------------ +okvs_next + +ST16 PARAM + inc WINDEX + bne + + inc WINDEX+1 ++ + jsr okvs_len + +LD16 WINDEX + +CMP16ADDR WCOUNT + bne + + sta WINDEX + sta WINDEX+1 ++ + +LD16 PARAM + ; /!\ execution falls through here to okvs_nth +;------------------------------------------------------------------------------ +; okvs_nth +; get (N)th key +; +; in: A/Y = handle to storage space +; $WINDEX = record index +; out: A/Y = lo/hi address of nth key +; $WINDEX preserved +; X = 0 +; Z = 0 +; all other flags clobbered +; $PTR clobbered +;------------------------------------------------------------------------------ +okvs_nth + jsr GetStoreAddressFromAY + ; PTR -> store + jsr incptr4 + ; PTR -> first record + +LD16 WINDEX + +ST16 SAVE + jmp @next +- jsr derefptr +@next + lda SAVE + dec SAVE + tay + bne - + lda SAVE+1 + dec SAVE+1 + tay + bne - + jsr incptr2 + +LD16 PTR + ldx #0 + rts + +;------------------------------------------------------------------------------ +; okvs_update +; +; in: stack contains 6 bytes of parameters: +; +1 [word] handle to storage space +; +3 [word] address of key +; +5 [word] address of new value +; out: if C clear, key was found and value was updated +; if C set, key was not found +; all registers are clobbered +; all other flags clobbered +; $00/$01 clobbered +; $02/$03 clobbered +; $04/$05 clobbered +;------------------------------------------------------------------------------ +okvs_update + +PARAMS_ON_STACK 6 + ldy #6 + lda (PARAM),y + sta SAVE+1 + dey + lda (PARAM),y + sta SAVE + dey +- lda (PARAM),y + sta @getparams,y + dey + bne - + jsr okvs_get +@getparams=*-1 + !word $FDFD ; SMC + !word $FDFD ; SMC + bcs @exit + +ST16 DEST + ldy #0 + lda (SAVE),y + tay +- lda (SAVE),y + sta (DEST),y + dey + cpy #$FF + bne - + clc +@exit rts + +;------------------------------------------------------------------------------ +; okvs_iter / okvs_iter_values +; +; in: stack contains 4 bytes of parameters: +; +1 [word] handle to storage space +; +3 [word] address of callback +; out: will be called for each record in the store, in order, with +; $WINDEX = numeric index of record (word) +; A/Y = address of key or value (depends on which entry point you call) +; all registers are clobbered +; Z=1 +; all other flags clobbered +; PARAM clobbered +; PTR clobbered +; WINDEX clobbered +; WCOUNT clobbered +;------------------------------------------------------------------------------ +okvs_iter + lda #$D0 ; 'BNE' opcode + +HIDE_NEXT_2_BYTES +okvs_iter_values + lda #$24 ; 'BIT' opcode + sta @branch + +PARAMS_ON_STACK 4 + jsr GetStoreAddress + ; PTR -> store + ; Y = 0 + lda (PTR),y ; get number of keys in store (word) + sta WCOUNT + iny + lda (PTR),y + sta WCOUNT+1 + bne + + dey + lda (PTR),y + beq @exit ; no keys, exit immediately ++ + +LDPARAM 3 + +ST16 @callback + jsr incptr4 + ; PTR -> first record + lda #0 + sta WINDEX + sta WINDEX+1 +@loop + lda #2 ; for iter, skip length = 2 +@branch bne + ; SMC (iter_values puts a BIT here, so no branch) + ; for iter_values, skip length = length(key) + 2 + 1 + tay ;;ldy #2 + lda (PTR),y ; A = length of key + clc + adc #3 ; skip over pointer to next record (2 bytes) + key length (1 byte) ++ sta @skiplen + lda WCOUNT+1 ; save WCOUNT on stack + pha + lda WCOUNT + pha + lda WINDEX+1 ; save WINDEX on stack + pha + lda WINDEX + pha + lda PTR+1 + tay + pha + lda PTR + pha ; save PTR on stack + clc +@skiplen=*+1 + adc #$FD ; SMC skip over pointer (and possibly key) + bcc + + iny ; A/Y -> value ++ +@callback=*+1 + jsr $FDFD ; SMC + pla + sta PTR + pla + sta PTR+1 ; restore PTR from stack + pla + sta WINDEX + pla + sta WINDEX+1 + pla + sta WCOUNT + pla + sta WCOUNT+1 + jsr derefptr ; PTR -> next record + inc WINDEX + bne + + inc WINDEX+1 ++ + lda WINDEX + cmp WCOUNT + bne @loop + lda WINDEX+1 + cmp WCOUNT+1 + bne @loop +@exit rts + +;------------------------------------------------------------------------------ +; internal functions + +incptr4 jsr incptr2 +incptr2 jsr incptr +incptr +; preserves A, X, and Y + inc PTR + bne + + inc PTR+1 ++ rts + +GetStoreAddressFromAY + +ST16 PTR + jmp derefptr + +GetStoreAddress +; in: PARAM = address of stack params (any PARAMS_ON_STACK macro will do this) +; out: PTR = address of store (always the first parameter on stack) +; preserves X + ldy #1 + lda (PARAM),y + sta PTR + iny + lda (PARAM),y + sta PTR+1 ; PTR -> first parameter on stack + ; execution falls through here +derefptr +; out: Y = 0 +; preserves X + ldy #1 + lda (PTR),y + pha + dey + lda (PTR),y + sta PTR + pla + sta PTR+1 + rts diff --git a/src/parse.common.a b/src/parse.common.a new file mode 100644 index 0000000..353bdcb --- /dev/null +++ b/src/parse.common.a @@ -0,0 +1,137 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; generic key/value text parser +; +; Public functions: +; - ParseKeyValueList +; - IncAndGetChar +; + +;------------------------------------------------------------------------------ +; ParseKeyValueList +; parse buffer with KEY=VALUE lines of a text file into an okvs +; keys and values limited to 127 characters, which should be enough for anyone +; if '=' is missing, key is kept and value is a 0-length string +; blank lines are ignored +; '#' character at beginning of line is a comment, entire line is ignored +; '[' character at beginning of line exits the parser +; +; in: stack contains 5 bytes of parameters: +; +1 [word] handle to storage space for okvs +; +3 [word] handle to buffer containing contents of text file +; +5 [byte] max length for okvs records (or 0) +; out: all registers and flags clobbered +; $1F00..$1FFF clobbered +; $00/$01 clobbered +; $02/$03 clobbered +; $04/$05 has the address of the next available byte after the okvs +; $FE/$FF clobbered +;------------------------------------------------------------------------------ +ParseKeyValueList + +PARAMS_ON_STACK 5 + + +LDPARAM 1 + +ST16 @store2 + jsr SetKeyPtr + ldy #5 + lda (PARAM),y + sta @maxLength + + ldy #$00 ; index into ($FE) pointing to current character +@newkey ldx #$00 ; X = index into current key + stx gValLen ; initialize value length (in case this line has no value) + beq @emptyline ; always branches +@skipLine ; skip to CR + jsr IncAndGetChar + cmp #$0A ; CR + bne @skipLine +@emptyline + jsr IncAndGetChar + cmp #$0A ; CR in first position (blank line) -> no key + beq @emptyline + cmp #$23 ; '#' starts a comment -> no key, skip to CR + beq @skipLine + cmp #$5B ; '[' ends the parsing + beq .parseKeyValueDone + bne @appendToKey +@gatherKey + jsr IncAndGetChar + cmp #$0A ; CR -> finalize key, no value + beq @finalizeKey + cmp #$3D ; '=' -> finalize key, start gathering value + beq @finalizeKey +@appendToKey + sta gKey,x + inx + bpl @gatherKey +@finalizeKey + stx gKeyLen + cmp #$0A + beq @storeInOKVS + ldx #$00 ; now X = index into the current value +@gatherValue + jsr IncAndGetChar + cmp #$0A ; CR -> finalize value + beq @finalizeValue + sta gVal,x + inx + bpl @gatherValue +@finalizeValue + stx gValLen +@storeInOKVS + tya + pha ; okvs functions clobber everything but we need Y + jsr okvs_append +@store2 !word $FDFD ; SMC + !word gKeyLen + !word gValLen +@maxLength + !byte $FD ; SMC + pla + tay + clc + bcc @newkey ; always branches + +;------------------------------------------------------------------------------ +; SetKeyPtr +; +; in: PARAM set +; out: okvs initialised +; ($FE) -> buffer +;------------------------------------------------------------------------------ +SetKeyPtr + jsr okvs_init ; reset key/value store + + +LDPARAMPTR 3, $FE + + ldy #0 + lda ($FE),y + tax + bne + + iny + lda ($FE),y + sta $FF + dec $FF ++ dex + stx $FE + rts + +;------------------------------------------------------------------------------ +; IncAndGetChar +; +; in: Y = index into ($FE) +; ($FE) -> buffer +; out: A contains next byte from buffer +; Y incremented +; $FF possibly incremented +;------------------------------------------------------------------------------ +IncAndGetChar + iny + bne + + inc $FF ++ lda ($FE),y + cmp #$0D ; CR - hide it + beq IncAndGetChar +.parseKeyValueDone + rts diff --git a/src/parse.games.a b/src/parse.games.a new file mode 100644 index 0000000..16becb1 --- /dev/null +++ b/src/parse.games.a @@ -0,0 +1,113 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; GAMES.CONF parser +; +; Public functions: +; - ParseGamesList +; + +;------------------------------------------------------------------------------ +; ParseGamesList +; parse buffer with ABC,KEY=VALUE lines of text into an okvs +; keys and values limited to 127 characters, which should be enough for anyone +; '[' character at beginning of line ends the parsing +; (see games.conf file for more format information) +; +; in: stack contains 4 bytes of parameters: +; +1 [word] handle to storage space for okvs +; +3 [word] handle to buffer containing contents of GAMES.CONF +; out: all registers and flags clobbered +; $1F00..$1FFF clobbered +; $00/$01 clobbered +; $02/$03 clobbered +; $04/$05 has the address of the next available byte after the okvs +; $FE/$FF clobbered +;------------------------------------------------------------------------------ +ParseGamesList + +PARAMS_ON_STACK 4 + + +LDPARAM 1 + +ST16 @store2 + jsr SetKeyPtr + + ldy #$00 ; index into ($FE) pointing to current character + beq @newkey ; always branches +@skipLine ; skip to CR + jsr IncAndGetChar + cmp #$0A ; CR + bne @skipLine +@newkey ldx #$00 ; X = index into current key + stx gValLen ; initialize value length (in case this line has no value) +@emptyline + jsr IncAndGetChar ; get first filter character ('1' if game requires joystick) + cmp #$0A ; ignore blank line + beq @emptyline + cmp #$5B ; '[' ends the parsing + beq @exit + cmp #$30 ; '0' -> no filtering on joystick + beq @filterOnMemory + cmp #$31 ; not '0' or '1' or '[' or CR -> ignore entire line (e.g. comment) + bne @skipLine + bit zpMachineStatus + bpl @skipLine ; game requires joystick but we don't have one, so ignore entire line +@filterOnMemory + jsr IncAndGetChar ; get second filter character ('1' if game requires 128K) + cmp #$30 ; '0' -> no filtering on memory + beq @parseDHGRTitle + cmp #$31 ; not '0' or '1' -> ignore entire line + bne @skipLine + bit zpMachineStatus + bvc @skipLine ; game requires 128K but we only have 64K, so ignore entire line +@parseDHGRTitle + jsr IncAndGetChar ; get third character ('1' if game has DHGR title) + and #$01 + pha +@parseCheatsAvailable + jsr IncAndGetChar ; get fourth character (cheat category, int) + and #CHEAT_CATEGORY + pha +@swallowComma + jsr IncAndGetChar +@gatherKey + jsr IncAndGetChar + cmp #$0A ; CR -> finalize key, no value + beq @endKey + cmp #$3D ; '=' ends the key + beq @endKey + sta gKey,x + inx + bpl @gatherKey +@endKey stx gKeyLen + ldx #$00 ; now X = index into the current value + cmp #$0A + beq @endValue +@gatherValue + jsr IncAndGetChar + cmp #$0A ; CR ends the value + beq @endValue + sta gVal,x + inx + bpl @gatherValue +@endValue + pla ; pop cheat category + sta gVal,x ; store after game display name + pla ; pop has-DHGR-title flag + lsr + ror + ora gVal,x + sta gVal,x ; store in bit 7 of same byte as cheat category + inx + stx gValLen + tya + pha ; okvs functions clobber everything but we need Y + jsr okvs_append +@store2 !word $FDFD ; SMC + !word gKeyLen + !word gValLen + !byte 0 + pla ; pop saved Y + tay + jmp @newkey + +@exit rts diff --git a/src/parse.prefs.a b/src/parse.prefs.a new file mode 100644 index 0000000..f8a23df --- /dev/null +++ b/src/parse.prefs.a @@ -0,0 +1,222 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Parser for global preferences file +; +; Public functions +; - pref_get +; - pref_set +; - SaveSmallFile +; +; Public constants (all length-prefixed strings) +; - kNextAttract +; - kNextFX +; - kNextDFX +; - kCheat +; + +kGlobalPrefsBuffer = $8000 + +; valid pref keys +kNextAttract + !byte 11 + !raw "NEXTATTRACT" +kNextFX + !byte 6 + !raw "NEXTFX" +kNextDFX + !byte 7 + !raw "NEXTDFX" +kCheat + !byte 5 + !raw "CHEAT" + +.kEquals !byte 1 + !raw "=" +.kLF !byte 1,$0A +.kFluff1 !byte .kFluff2-*-1 + !raw "# Total Replay II preferences file",$0A + !raw "# Do not edit by hand.",$0A + !raw "# Or do. I'm a comment, not a cop.",$0A + !byte $0A + !raw "# value=module listed in ATTRACT.CONF",$0A +.kFluff2 !byte .kFluff3-*-1 + !byte $0A + !raw "# value=effect listed in FX.CONF",$0A +.kFluff3 !byte .kFluff4-*-1 + !byte $0A + !raw "# value=effect listed in DFX.CONF",$0A +.kFluff4 !byte .kEOF-*-1 + !byte $0A + !raw "# value=0 or 1",$0A +.kEOF !byte ._-*-1 + !byte $0A + !raw "[eof]",$0A +._ + +.addStringFromStore + +ST16 .key + jsr .addString + +LDADDR .kEquals + jsr .addString + jsr okvs_get + !word gGlobalPrefsStore +.key !word $FDFD ; SMC + jsr .addString + +LDADDR .kLF + ; execution falls through here +.addString + +ST16 $00 + ldy #0 + lda ($00),y + beq PREFRTS + tay + clc + adc $FE + tax +- lda ($00),y + dey + sta ($FE),y + bne - + stx $FE + bcc PREFRTS + inc $FF +PREFRTS rts + +;------------------------------------------------------------------------------ +; pref_get +; get pref value by pref key, and optionally validate that the pref value +; exists as a key in another OKVS +; +; example usage: +; jsr pref_get +; !word kNextFX +; !word gFXStore +; +; See above for list of valid pref keys. +; +; The OKVS you pass in as the second parameter must have at least 1 record. +; This is not checked. +; +; in: stack contains 4 bytes of parameters: +; +1 [word] address of length-prefixed pref key +; +3 [word] address of OKVS, or 0 +; gGlobalPrefsStore must be initialized (this is done in 4sports.init) +; out: A/Y = address of pref value +; $WINDEX = index of pref value in passed store +; (if OKVS parameter is 0, no validation occurs and X=0 and Z=1 on exit, +; some callers rely on this behavior, so don't change it!) +; PARAM clobbered +; PTR clobbered +; SRC clobbered +; SAVE clobbered +;------------------------------------------------------------------------------ +pref_get + +PARAMS_ON_STACK 4 + +LDPARAMPTR 1, + + +LDPARAMPTR 3, .store1 + + jsr okvs_get ; look up pref key in prefs store + !word gGlobalPrefsStore ++ !word $FDFD ; SMC + bcs .useDefaultValue ; if pref key is not found, use default value + ldx .store1+1 + beq PREFRTS ; if no OKVS to validate against, we're done + +ST16 + + +ST16 PTR + ldy #0 + lda (PTR),y + beq .useDefaultValue ; if pref value is empty, use default value + jsr okvs_get ; check whether the pref value exists as a key in the passed-in store +.store1 !word $FDFD ; SMC ++ !word $FDFD ; SMC + bcc + ; found key, continue +.useDefaultValue ; did not find key, use first key in passed store as a default value + sta WINDEX + sta WINDEX+1 ++ + +LD16 .store1 + jmp okvs_nth + +;------------------------------------------------------------------------------ +; pref_set +; set pref value by pref key, serialize prefs, and write them to disk +; +; in: stack contains 4 bytes of parameters: +; +1 [word] address of length-prefixed pref key +; +3 [word] address of length-prefixed pref value +; out: all registers and flags clobbered +; PARAM clobbered +; PTR clobbered +; SRC clobbered +; $FE/$FF clobbered +;------------------------------------------------------------------------------ +pref_set + +PARAMS_ON_STACK 4 + +LDPARAMPTR 1, + + +LDPARAMPTR 3, ++ + + jsr okvs_update ; save that in prefs store + !word gGlobalPrefsStore ++ !word $FDFD ; SMC +++ !word $FDFD ; SMC + + +LDADDR kGlobalPrefsBuffer ; clear prefs buffer + +ST16 $FE + ldx #$02 + ldy #$00 + tya +- sta ($FE),y + iny + bne - + inc $FF + dex + bne - + dec $FF + dec $FF + + +LDADDR .kFluff1 ; serialize prefs into prefs buffer + jsr .addString + +LDADDR kNextAttract + jsr .addStringFromStore + + +LDADDR .kFluff2 + jsr .addString + +LDADDR kNextFX + jsr .addStringFromStore + + +LDADDR .kFluff3 + jsr .addString + +LDADDR kNextDFX + jsr .addStringFromStore + + +LDADDR .kFluff4 + jsr .addString + +LDADDR kCheat + jsr .addStringFromStore + + +LDADDR .kEOF + jsr .addString + + +LDADDR kGlobalPrefsFilename ; write prefs buffer to file on disk + jsr SetPath + +LD16 kGlobalPrefsBuffer + ; /!\ execution falls through here to glue.prorwts/SaveSmallFile +;------------------------------------------------------------------------------ +; SaveSmallFile +; Save a file into memory all at once, using ProRWTS2. +; /!\ Only first block (512 bytes) is written. Keep those files small. /!\ +; /!\ All 512 bytes are written to disk. Clear buffer before calling. /!\ +; +; supports paths, see note +; +; in: A/Y points to data buffer +; gPathname contains path+filename to write +; out: all flags clobbered +; all registers clobbered +;------------------------------------------------------------------------------ +SaveSmallFile + +ST16 ldrlo ; set data buffer address for ProRWTS2 + jsr SwitchToBank2 + jsr SaveSmallFileInternal + jmp SwitchToBank1 diff --git a/src/prelaunch/common.a b/src/prelaunch/common.a new file mode 100644 index 0000000..d4b4233 --- /dev/null +++ b/src/prelaunch/common.a @@ -0,0 +1,36 @@ +;license:MIT +;(c) 2019 by 4am +; +; common code used by all prelaunchers +; +; you should include this file with a '!source' directive, not assemble it directly + + !source "src/constants.a" ; no code in these + !source "src/macros.a" + + ldx #0 ; wipe zero page + txa +- sta $00,x + inx + bne - + + lda #$65 ; Initialize 'random' seed. These are + sta RNDSEED ; arbitrary values. Some games like Pooyan + lda #$02 ; require these to be non-zero. Ask me + sta RNDSEED+1 ; how long that one took to debug. + + +READ_ROM_NO_WRITE + + jsr ROM_IN0 ; Initialize machine like a cold boot. + jsr ROM_PR0 ; Many games assume a 'clean slate' and + jsr ROM_NORMAL ; rely on zero page values set by these + sta STOREOFF ; ROM routines, + sta READMAINMEM ; e.g. Wavy Navy just prints out text via + sta WRITEMAINMEM ; $FDED and expects it to work. Having it + sta CLR80VID ; print all null characters is amusing, in + sta PRIMARYCHARSET ; a quiet way, but not really helpful. + jsr ROM_TEXT + jsr ROM_HOME + + bit CLEARKBD + sei diff --git a/src/prelaunch/standard.a b/src/prelaunch/standard.a new file mode 100644 index 0000000..fb69eac --- /dev/null +++ b/src/prelaunch/standard.a @@ -0,0 +1,24 @@ +;license:MIT +;(c) 2019 by qkumba + +!cpu 6502 +!to "build/PRELAUNCH/STANDARD",plain +*=$106 + + ldy $5A ; set up game entry point in stack page + ldx $59 ; (last ProRWTS load address - 1) + bne + + dey ++ dex + stx $1FE + sty $1FF + + !source "src/prelaunch/common.a" + + ldx #$FD ; Jump to game entry point via stack pop. + txs + rts + +!if * > $1C0 { + !error "code is too large, ends at ", * +} diff --git a/src/proboothd/proboothd.s b/src/proboothd/proboothd.s new file mode 100644 index 0000000..554729d --- /dev/null +++ b/src/proboothd/proboothd.s @@ -0,0 +1,150 @@ +;license:BSD-3-Clause +;minimal open/read binary file in ProDOS filesystem +;copyright (c) Peter Ferrie 2016-2019 +!cpu 6502 +!to "proboothd",plain +*=$800 + + ;zpage usage, arbitrary selection except for the "ProDOS constant" ones + command = $42 ;ProDOS constant + unit = $43 ;ProDOS constant + adrlo = $44 ;ProDOS constant + adrhi = $45 ;ProDOS constant + bloklo = $46 ;ProDOS constant + blokhi = $47 ;ProDOS constant + + A2L = $3e + A2H = $3f + sizehi = $53 + + ;constants + scrn2p2 = $f87b + dirbuf = $1e00 ;for size-optimisation + + !byte 1 + tay +- txa + jsr scrn2p2 + and #7 + ora #$c0 + sta $be30, y + sta slot+2 + sta entry+2 +slot lda $cfff + sta entry+1 + + lda fakeMLI_e-$100, y + sta $be00+fakeMLI_e-fakeMLI, y + iny + bne - + sty adrlo + stx $bf30 + sty $200 + +opendir ;read volume directory key block + ldx #2 + + ;include volume directory header in count + +firstent lda #>dirbuf + sta adrhi + sta A2H + jsr seekread + lda #4 + sta A2L +nextent ldy #0 + + ;match name lengths before attempting to match names + + lda (A2L), y + and #$0f + tax + inx +- cmp filename, y + beq foundname + + ;move to next directory in this block + + clc + lda A2L + adc #$27 + sta A2L + bcc + + + ;there can be only one page crossed, so we can increment instead of adc + + inc A2H ++ cmp #$ff ;4+($27*$0d) + bne nextent + + ;read next directory block when we reach the end of this block + + ldx dirbuf+2 + ldy dirbuf+3 + bcs firstent + +foundname iny + lda (A2L), y + dex + bne - + stx $ff + + ;cache KEY_POINTER + + ldy #$11 + lda (A2L), y + tax + iny + lda (A2L), y + tay + +readfile jsr seekread + inc adrhi + inc adrhi + + ;fetch data block and read it + +blockind ldy $ff + inc $ff + ldx dirbuf, y + lda dirbuf+256, y + tay + bne readfile + txa + bne readfile + +readdone jmp $2000 + +seekread stx bloklo + sty blokhi + lda #1 + sta command + lda adrhi + pha +entry jsr $d1d1 + pla + sta adrhi + rts + +fakeMLI bne retcall +readblk dey + dey + sty adrhi + tay + jsr $bf00+seekread-fakeMLI +retcall pla + tax + inx + inx + inx + txa + pha + rts +fakeMLI_e + +filename !byte filename_e - filename_b +filename_b !text "LAUNCHER.SYSTEM" ;your start-up file, file is max 40kb +filename_e + +*=$9f8 +!byte $D3,$C1,$CE,$A0,$C9,$CE,$C3,$AE diff --git a/src/prodos.impl.lc2.a b/src/prodos.impl.lc2.a new file mode 100644 index 0000000..5237fcd --- /dev/null +++ b/src/prodos.impl.lc2.a @@ -0,0 +1,601 @@ +;license:MIT +;(c) 2019-2020 by 4am & qkumba +; +; Pseudo-ProDOS environment +; +; /!\ These live in LC RAM 2 and rely on the ProRWTS code which is also in LC RAM 2. /!\ + +;------------------------------------------------------------------------------ +; ProDOS_enter +; intercept certain ProDOS requests +; wrap them to ProRWTS2 file requests +; +; in: return address+1 is command and pointer to parameter block +; out: all flags clobbered +; A=0, X and Y preserved +; stack set to next instruction after parameters +;------------------------------------------------------------------------------ +ipacket = first_zp ;word +buffer = first_zp+2 ;word + +!if RELBASE != $2000 { + !ifdef PASS2 { + } else { ;PASS2 + !if * != iProDOS_enter { + !error "iProDOS_enter=",*, ", fix constants.a" + } + } +} +ProDOS_enter +!set CloseHandles = @imp_close + stx ProDOS_savedX+1 + sty ProDOS_savedY+1 + jsr @swap_zp + pla + tay + pla + sta @fetchaddr+1 + pla + sta @fetchaddr+2 + jsr @fetchbyte + sta @request+1 + jsr @fetchbyte + sta ipacket + jsr @fetchbyte + sta ipacket+1 + lda @fetchaddr+2 + pha + lda @fetchaddr+1 + pha + tya + pha + ldy #2 +@request + lda #$d1 + cmp #$40 + beq @imp_allocint ;;@do_allocint + cmp #$41 + beq @do_deallocint + cmp #$65 + beq @do_quit + cmp #$80 + beq @imp_rdwrblock ;;@do_readblock + cmp #$81 + beq @imp_rdwrblock ;;@do_writeblock + cmp #$c0 + beq @do_create + cmp #$c4 + beq @imp_getattrib ;;@do_getattrib + cmp #$c6 + beq @do_setprefix + cmp #$c7 + beq @do_getprefix + cmp #$c8 + beq @do_open + cmp #$ca + beq @do_read + cmp #$cb + beq @do_write + cmp #$cc + beq @do_close + cmp #$ce + beq @do_seek + cmp #$d0 + beq @do_seteof +;; cmp #$d1 +;; bne @do_fatal +@do_geteof + jmp @imp_geteof +@do_allocint +;; jmp @imp_allocint +@do_quit + jmp $100 +@do_readblock +@do_writeblock +;; jmp @imp_rdwrblock +@do_getattrib +;; jmp @imp_getattrib +@do_getprefix + jmp @imp_getprefix +@do_open + jmp @imp_open +@do_read + jmp @imp_read +@do_write + jmp @imp_write +@do_close + jsr @imp_close ;subroutine special case because of dual-use +@do_deallocint ;nothing for now +@do_create ;nothing for now +@do_setprefix ;nothing for now +@do_seteof ;nothing for now + jmp @restore_zp +@do_seek + jmp @imp_seek +@do_fatal +;; jmp ProDOS_fatal + +@imp_allocint + ;;ldy #2 + lda (ipacket), y + sta ProDOS_irq + 1 + iny + lda (ipacket), y + sta ProDOS_irq + 2 + lda #ProDOS_int + sta $3fe + sta $fffe + stx $3ff + stx $ffff + bne @jmp_zp2 ;always + +@imp_rdwrblock + and #$7f + adc #0 + sta @rdwrop+1 + ldx #$44 + ;;ldy #2 + jsr @setbuffer + lda (ipacket), y + tax + iny + lda (ipacket), y +@rdwrop + ldy #$d1 ; SMC + jsr hddseekrd+2 + bcc @jmp_zp2 ;always + +@imp_getattrib + lda ipacket+1 + pha + lda ipacket + pha + ldx #namlo + jsr @setbuffer1 + lda #$60 + sta attribpatch + jsr hddopendir + lda #$10 + sta attribpatch + pla + sta ipacket + pla + sta ipacket+1 + ldy #5 + lda ldrlo2 + sta (ipacket), y + iny + lda ldrlo2+1 + sta (ipacket), y + ldy #$13 + jsr fetchscratch + ldy #9 + sta (ipacket), y + txa + dey + sta (ipacket), y +@jmp_zp2 + jmp @restore_zp + +@imp_getprefix + ldx #buffer + jsr @setbuffer1 + ldy ProDOS_prefix + iny + iny + tya + pha +@copy_prefix + lda ProDOS_prefix-1, y + sta (buffer), y + dey + bne @copy_prefix + pla + sta (buffer), y + tay + lda #'/' + sta (buffer), y + ldy #1 + sta (buffer), y + bne @jmp_zp2 ;always + +@imp_open + ldx #namlo + jsr @setbuffer1 + inc @handles+1 +@handles + ldx #0 + iny + lda (ipacket), y + sta @handle-1, x + jsr @patch_buffer + iny + lda #1 + sta (ipacket), y + lsr + sta reqcmd + sta sizehi + sta sizelo + jsr hddopendir + stx blkidx + beq @link_jmpzp ;always + +resetval=$f0 +@imp_seek + jsr @set_rdwrbuff + ldx #0 + stx blkidx + stx blkofflo + stx blkoffhi + stx reqcmd + jsr @reset + ldx sizelo + bne @seek64 + cmp ldrhi + bcc @seek64 + bne @seek32 + ldx ldrlo + beq @seek32 + +@seek64 + sta sizehi + sta sizelo + jsr @seekreset + lda ldrhi + sbc #resetval + sta ldrhi + +@seek32 + lda ldrhi + sta sizehi + lda ldrlo + sta sizelo + jsr @seekreset + lda ldrhi + ora ldrlo + bne @jmp_zp + dec blkidx +@link_jmpzp + beq @jmp_zp ;always + +@seekreset + jsr hddrdwrpart +@reset + lda #resetval + sta blefthi + stx bleftlo + rts + +@imp_read + clc +@imp_write + php + lda #cmdread + adc #0 + sta reqcmd + jsr @set_rdwrbuff + plp + bcc @skip_align + ldx #sizelo + jsr @round + lda #0 + sta sizelo + ldx #bleftlo + jsr @round + +@skip_align + jsr hddrdwrpart + ldx #hddencbuf + +@patch_buffer + sta encbufpatch1+1 + sta encbufpatch2+1 + tax + inx + stx dirbufpatch1+1 + inx + stx dirbufpatch2+2 + stx dirbufpatch3+2 + stx dirbufpatch4+2 + stx dirbufpatch6+1 + stx dirbufpatch7+2 + stx dirbufpatch9+2 + stx dirbufpatch10+1 + inx + stx dirbufpatch5+2 + stx dirbufpatch8+2 +@close_ret + rts + +@fetchbyte + inc @fetchaddr+1 + bne @fetchaddr + inc @fetchaddr+2 +@fetchaddr + lda $d1d1 + rts + +@set_rdwrbuff + ldy #1 + lda (ipacket), y + tax + lda @handle-1, x + jsr @patch_buffer + ldx #ldrlo + iny + jsr @setbuffer + ldx #sizelo + !byte $2c +@setbuffer1 + ldy #1 + +@setbuffer + lda (ipacket), y + sta $0,x + iny + lda (ipacket), y + sta $1,x + iny + rts + +@round + clc + lda $0,x + adc #$ff + lda $1,x + adc #1 + and #$fe + sta $1,x + rts + +@swap_zp + ldx #last_zp-first_zp +@save_zp + lda first_zp,x + ldy @saved_zp,x + sta @saved_zp,x + sty first_zp,x + dex + bpl @save_zp + rts + +@restore_zp + jsr @swap_zp + jmp ProDOS_exit + +@handle + !byte 0, 0 ;only up to two handles at a time + +@saved_zp + !fill (last_zp - first_zp) + 1 + +;------------------------------------------------------------------------------ +; traverse [private] +; +; in: (namlo) points to length-prefixed pathname+filename +; out: all flags clobbered +; all registers clobbered +;------------------------------------------------------------------------------ +!ifdef PASS2 { +} else { ;PASS2 + !if * != itraverse { + !error "itraverse=",*, ", fix constants.a" + } +} +traverse + +LD16 gRootDirectory + sta (reloc + unrhddblocklo - unrelochdd) + 1 + sty (reloc + unrhddblockhi - unrelochdd) + 1 + sta @myreadblock+1 + sty @myreadblock+3 ; reset 'root' directory (saved at program start) + + ;search for '/' character in filename + + ldx #0 + ldy #0 + lda (namlo), y + tay +- inx + dey + bmi @go ; no '/', just do the read + lda (namlo), y + cmp #'/' + bne - + sty sizelo + txa + pha + +@myreadblock +@myx80_parms + ldx #2 + lda #0 + jsr hddreaddirsel + lda #NAME_LENGTH + sta bloklo + lda #>(hdddirbuf - 1) + sta blokhi + + ;there can be only one page crossed, so we can increment here + +@mynextent1 + inc blokhi +@mynextent + ldy #0 + lda (bloklo), y + pha + and #$0f + tax +-- iny + lda (bloklo), y + cmp (namlo), y + beq @myfoundname + + ;match failed, move to next directory in this block, if possible + +- pla + +@myskiphdr + clc + lda bloklo + adc #ENTRY_SIZE + sta bloklo + bcs @mynextent1 + cmp #$ff ;4 + ($27 * $0d) + bne @mynextent + + ;read next directory block when we reach the end of this block + + lda hdddirbuf + NEXT_BLOCK_LO + ldx hdddirbuf + NEXT_BLOCK_HI + bcs + + +@myfoundname + dex + bne -- + + ;parse path until last directory is seen + + iny + lda (namlo), y + cmp #'/' + bne - + pla + and #$20 ;Volume Directory Header XOR subdirectory + bne @myskiphdr + tya + eor #$ff + adc sizelo + sta sizelo + clc + tya + adc namlo + sta namlo + + ;cache block number of current directory + ;as starting position for subsequent searches + + ldy #(KEY_POINTER + 1) + lda (bloklo), y + tax + dey + lda (bloklo), y + sta (reloc + unrhddblocklo - unrelochdd) + 1 + stx (reloc + unrhddblockhi - unrelochdd) + 1 ++ sta @myx80_parms + 1 + stx @myx80_parms + 3 +++ lda sizelo + bne @myreadblock + tay + + pla + sta (namlo), y +@go + rts + +;------------------------------------------------------------------------------ +; promote [private] +; +; tiny ProDOS-style interface for ProRWTS +; in: whatever ProDOS expects for the supported functions +; out: carry clear, A=0 +; X, Y, and other flags clobbered +;------------------------------------------------------------------------------ + +promote +!pseudopc $bf00 { + php + sei + bit $c083 + !byte $24 + !if * != $bf06 { + !error "$BF06 misplaced (",*,")" + } + rts ;clock interface, must be RTS on real ProDOS if program uses $20x + + bit $c083 + jmp ProDOS_enter +ProDOS_exit + sta $c082 + bmi ProDOS_savedX ;always + !if * != $bf12 { + !error "$BF12 misplaced (",*,")" + } + !word $c1d1, $c2d1, $c3d1, $c4d1, $c5d1, $c6d1, $c7d1 +ProDOS_savedX + ldx #$d1 +ProDOS_savedY + ldy #$d1 + plp + clc + lda #0 + rts + + !if * > $bf30 { + !error "$BF30 misplaced (",*,")" + } else { + !if * != $bf30 { + !fill $bf30-* + } + } +ProDOS_unit + !byte $d1 + +ProDOS_int + pha + txa + pha + tya + pha +ProDOS_irq + jsr $d1d1 ;SMC + pla + tay + pla + tax + pla + bit $c012 + bmi + + lda $45 ++ rti + + !if * > $bf58 { + !error "code is too large, ends at ", * + } + +ProDOS_fatal ;only for debugging, will be removed +;; bit $c081 +;; pha +;; jsr $fe89 +;; jsr $fe93 +;; pla +;; jsr $fdda +;; jmp $ff65 +;;*=$bf58 +;; !fill $18 ;filled by init instead + +ProDOS_prefix=gPathname +; !fill $2e +} +end_promote diff --git a/src/prodos.path.a b/src/prodos.path.a new file mode 100644 index 0000000..09bf9a7 --- /dev/null +++ b/src/prodos.path.a @@ -0,0 +1,171 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; ProDOS - functions for constructing and passing around ProDOS pathnames +; +; Public functions +; - SetPath +; - AddToPath +; + +;------------------------------------------------------------------------------ +; SetPath/AddToPath +; append a length-prefixed string to gPathname +; SetPath will reset the path first +; +; in: A contains low byte of address of length-prefixed string to append +; Y contains high byte of address of length-prefixed string to append +; out: all registers and flags clobbered +; $02/$03 (PTR/PTR+1) clobbered +; gPathname updated with concatenated length-prefixed string +;------------------------------------------------------------------------------ +SetPath +kRootDirectory=*+1 + ldx #0 + stx gPathname + ; execution falls through here +!if RELBASE != $2000 { + !ifdef PASS2 { + } else { ;PASS2 + !if * != iAddToPath { + !error "iAddToPath=",*, ", fix constants.a" + } + } +} +AddToPath + +ST16 PTR + ldy #0 + lda (PTR),y ; length of this segment + beq @done + tay + iny + sty @max + ldx gPathname ; current pathname length + ldy #$01 +- lda (PTR),y + sta gPathname+1,x + inx + iny +@max = *+1 + cpy #$D1 ; SMC + bcc - + stx gPathname +@done + rts + +kHGRTitleDirectory + !byte 10 + !raw "TITLE.HGR/" + +kDHGRTitleDirectory + !byte 11 + !raw "TITLE.DHGR/" + +kAnimatedTitleDirectory + !byte 15 + !raw "TITLE.ANIMATED/" + +kHGRActionDirectory + !byte 11 + !raw "ACTION.HGR/" + +kDHGRActionDirectory + !byte 12 + !raw "ACTION.DHGR/" + +kGRActionDirectory + !byte 10 + !raw "ACTION.GR/" + +kSHRArtworkDirectory + !byte 12 + !raw "ARTWORK.SHR/" + +kMiniAttractDirectory + !byte 8 + !raw "ATTRACT/" + +kAttractModeSlideshowDirectory + !byte 3 + !raw "SS/" + +kDemoDirectory + !byte 5 + !raw "DEMO/" + +kGameDirectory + !byte 2 + !raw "X/" +kGameDirectoryLen = 3 ; we need this elsewhere + +kFXDirectory + !byte 3 + !raw "FX/" + +kPrelaunchDirectory + !byte 10 + !raw "PRELAUNCH/" + +kGameHelpDirectory + !byte 9 + !raw "GAMEHELP/" + +kStandardPrelaunch + !byte 8 + !raw "STANDARD" + +kGlobalPrefsFilename + !byte 10 + !raw "PREFS.CONF" + +kAttractModeConfFile + !byte 12 + !raw "ATTRACT.CONF" + +kFXConfFile + !byte 7 + !raw "FX.CONF" + +kDFXConfFile + !byte 8 + !raw "DFX.CONF" + +kCreditsFile + !byte 7 + !raw "CREDITS" + +kHelpBackgroundFile + !byte 4 + !raw "HELP" + +kHelpTextFile + !byte 8 + !raw "HELPTEXT" + +kTitleFile + !byte 5 + !raw "TITLE" + +kCoverFile + !byte 5 + !raw "COVER" + +kCoverFadeFile + !byte 9 + !raw "COVERFADE" + +kGRFizzleFile + !byte 9 + !raw "GR.FIZZLE" + +kSFXFizzleFile + !byte 10 + !raw "SHR.FIZZLE" + +kDecrunchFile + !byte 8 + !raw "DECRUNCH" + +kJoystickFile + !byte 8 + !raw "JOYSTICK" diff --git a/src/prorwts2.a b/src/prorwts2.a new file mode 100644 index 0000000..e8f3bce --- /dev/null +++ b/src/prorwts2.a @@ -0,0 +1,3605 @@ +;license:BSD-3-Clause +;extended open/read/write binary file in ProDOS filesystem, with random access +;copyright (c) Peter Ferrie 2013-2020 + +ver_02 = 1 + +!if ver_02 = 1 { + !cpu 6502 +} else { ;ver_02 = 0 + !cpu 65c02 +} ;ver_02 + +;place no code before init label below. + + ;user-defined options + verbose_info = 0 ;set to 1 to enable display of memory usage + enable_floppy = 0 ;set to 1 to enable floppy drive support + poll_drive = 0 ;set to 1 to check if disk is in drive, recommended if allow_multi is enabled + use_smartport = 1 ;set to 1 to enable support for more than two MicroDrive (or more than four CFFA) partitions + override_adr = 1 ;set to 1 to require an explicit load address + aligned_read = 0 ;set to 1 if all reads can be a multiple of block size + enable_readseq=0 ;set to 1 to enable reading multiple sequential times from the same file without seek + ;(exposes a fixed address that can be called for either floppy or hard disk support) + enable_write = 1 ;set to 1 to enable write support + ;file must exist already and its size cannot be altered + ;writes occur in multiples of block size + enable_format= 0 ;used only by RWTS mode, requires enable_write and fast_subindex + enable_seek = 1 ;set to 1 to enable seek support + ;seeking with aligned_read=1 requires non-zero offset + allow_multi = 0 ;set to 1 to allow multiple floppies + allow_zerovol= 0 ;set to 1 to support volume 0 (=last used volume) + check_chksum = 0 ;set to 1 to enforce checksum verification for floppies + allow_subdir = 1 ;set to 1 to allow opening subdirectories to access files + might_exist = 0 ;set to 1 if file is not known to always exist already + ;makes use of status to indicate success or failure + many_files = 0 ;set to 1 to support more than 256 files in a directory + allow_aux = 1 ;set to 1 to allow read/write directly to/from aux memory + ;requires load_high to be set for arbitrary memory access + ;else driver must be running from same memory target + ;i.e. running from main if accessing main, running from aux if accessing aux + allow_saplings=1 ;enable support for saplings + allow_trees = 0 ;enable support for tree files, as opposed to only seedlings and saplings + ;required in RWTS mode if file > 128kb + fast_trees = 0 ;keep tree block in memory, requires an additional 512 bytes of RAM + always_trees = 0 ;set to 1 if the only file access involves tree files + ;not compatible with allow_subdir, allow_saplings + ;required in RWTS mode if allow_trees is enabled + detect_treof = 0 ;detect EOF during read of tree files + fast_subindex= 0 ;keep subindex block in memory, requires an additional 512 bytes of RAM + ;halves the disk access for double the speed (ideal for RWTS mode) + allow_sparse = 1 ;enable support for reading sparse files + ;recommended if enable_write is enabled, to prevent writing to sparse blocks + bounds_check = 1 ;set to 1 to prevent access beyond the end of the file + ;but limits file size to 64k-2 bytes. + return_size = 0 ;set to 1 to receive file size on open in read-only mode + one_shot = 0 ;set to 1 to load entire file in one pass (avoids the need to specify size) + no_interrupts= 0 ;set to 1 to disable interrupts across calls + detect_err = 0 ;set to 1 to to detect errors in no_interrupt mode + swap_zp = 0 ;set to 1 to include code to preserve zpage + ;used only by RWTS mode + swap_scrn = 1 ;set to 1 to preserve screen hole contents across SmartPort calls + ;reading directly into screen memory that includes holes (either main or aux) is not recommended + ;because SCSI firmware writes there (i.e. whichever bank is active) on exit, which will damage read content + ;recommended if allow_aux is used, to avoid device reset + ;requires 64 bytes to save all holes + rwts_mode = 0 ;set to 1 to enable emulation of DOS RWTS when running from hard disk + ;uses a one-time open of a tree file, no other file access allowed + ;use unique volume numbers to distinguish between images in the same file + ;requires override_adr, allow_trees, always_trees + ;not compatible with enable_floppy, allow_subdir, might_exist, bounds_check + mem_swap = 0 ;set to 1 if zpage can be swapped between main and aux, and swap_zp is unsuitable + ;(caches index registers in code instead of zpage) + load_high = 0 ;set to 1 to load to top of RAM (either main or banked, enables a himem check) + load_aux = 0 ;load to aux memory + load_banked = 1 ;set to 1 to load into banked RAM instead of main RAM (can be combined with load_aux for aux banked) + lc_bank = 2 ;load into specified bank (1 or 2) if load_banked=1 + one_page = 0 ;set to 1 if verbose mode says that you should (smaller code) + + ;user-defined driver load address +!if load_banked = 1 { + !if load_high = 1 { + !ifdef PASS2 { + } else { ;PASS2 not defined + reloc = $fe00 ;page-aligned, as high as possible, the ideal value will be shown on mismatch + } ;PASS2 + } else { ;load_high = 0 + reloc = $d400 ;page-aligned, but otherwise wherever you want + } ;load_high = 1 +} else { ;load_banked = 0 + !if load_high = 1 { + !ifdef PASS2 { + } else { ;PASS2 not defined + reloc = $bf00 ;page-aligned, as high as possible, the ideal value will be shown on mismatch + } ;PASS2 + } else { ;load_high = 0 + reloc = $bc00 ;page-aligned, but otherwise wherever you want ($BC00 is common for rwts_mode) + } ;load_high = 1 +} ;load_banked = 1 + + ;there are also buffers that can be moved if necessary: + ;dirbuf, encbuf, treebuf (and corresponding hdd* versions that load to the same place) + ;they are independent of each other so they can be placed separately + ;see near EOF for those + ;note that hddencbuf must be even-page-aligned in RWTS-mode + + ;zpage usage, arbitrary selection except for the "ProDOS constant" ones + ;feel free to move them around + +!if (might_exist + poll_drive) > 0 { + status = $50 ;returns non-zero on error +} ;might_exist = 1 or poll_drive = 1 +!if allow_aux = 1 { + auxreq = $51 ;set to 1 to read/write aux memory, else main memory is used +} ;allow_aux = 1 + sizelo = $52 ;set if enable_write=1 and writing, or reading, or if enable_seek=1 and seeking + sizehi = $53 ;set if enable_write=1 and writing, or reading, or if enable_seek=1 and seeking +!if (enable_write + enable_seek + allow_multi + rwts_mode) > 0 { + reqcmd = $54 ;set (read/write/seek) if enable_write=1 or enable_seek=1 + ;if allow_multi=1, bit 7 selects floppy drive in current slot (clear=drive 1, set=drive 2) during open call + ;bit 7 must be clear for read/write/seek on opened file +} ;enable_write = 1 or enable_seek = 1 or allow_multi = 1 or rwts_mode = 1 + ldrlo = $55 ;set to load address if override_adr=1 + ldrhi = $56 ;set to load address if override_adr=1 + namlo = $57 ;name of file to access + namhi = $58 ;name of file to access + ldrlo2 = $59 ;original load address read from filesystem + ldrhi2 = $5a ;original load address read from filesystem + sizelo2 = $5b ;original file size read from filesystem + sizehi2 = $5c ;original file size read from filesystem + !set last_zp = $5c ;highest address to save if swap_zp enabled (max 127 entries later) + +!if enable_floppy = 1 { + tmpsec = $3c ;(internal) sector number read from disk + reqsec = $3d ;(internal) requested sector number + curtrk = $40 ;(internal) track number read from disk +} ;enable_floppy = 1 + + command = $42 ;ProDOS constant + unit = $43 ;ProDOS constant + adrlo = $44 ;ProDOS constant + adrhi = $45 ;ProDOS constant + bloklo = $46 ;ProDOS constant + blokhi = $47 ;ProDOS constant + + scratchlo = $48 ;(internal) + scratchhi = $49 ;(internal) + + entries = $3f ;(internal) total number of entries in directory +!if many_files = 1 { + entrieshi = $3b ;(internal) total number of entries in directory +} ;many_files = 1 + +!if mem_swap = 0 { + !if rwts_mode = 1 { + lasttree = $59 ;(internal) last used index in tree buffer + } ;rwts_mode = 1 + !if allow_trees = 1 { + treeidx = $5a ;(internal) index into tree block + !set last_zp = $5a ;highest address to save if swap_zp enabled (max 127 entries later) + !if always_trees = 0 { + istree = $5b ;(internal) flag to indicate tree file + } ;always_trees = 0 + !if fast_trees = 0 { + treeblklo = $5c + treeblkhi = $5d + !set last_zp = $5d ;highest address to save if swap_zp enabled (max 127 entries later) + } ;fast_trees = 0 + } ;allow_trees = 1 + blkidx = $5e ;(internal) index into sapling block list + !if rwts_mode = 1 { + lastblk = $5f ;(internal) previous index into sapling block list + !set last_zp = $5f ;highest address to save if swap_zp enabled (max 127 entries later) + } ;rwts_mode = 1 + !if (bounds_check + return_size + one_shot) > 0 { + bleftlo = $60 ;(internal) bytes left in file + } ;bounds_check = 1 or return_size = 1 or one_shot = 1 + !if (bounds_check + return_size + aligned_read + one_shot) > 0 { + blefthi = $61 ;(internal) bytes left in file + !set last_zp = $61 ;highest address to save if swap_zp enabled (max 127 entries later) + } ;bounds_check = 1 or return_size = 1 or aligned_read = 1 or one_shot = 1 + !if aligned_read = 0 { + blkofflo = $62 ;(internal) offset within cache block + blkoffhi = $63 ;(internal) offset within cache block + !set last_zp = $63 ;highest address to save if swap_zp enabled (max 127 entries later) + } ;aligned_read = 0 +} ;mem_swap = 0 + +!if enable_floppy = 1 { + step = $64 ;(internal) state for stepper motor + tmptrk = $65 ;(internal) temporary copy of current track + phase = $66 ;(internal) current phase for seek + !set last_zp = $66 ;highest address to save if swap_zp enabled (max 127 entries later) +} ;enable_floppy = 1 + + ;constants + cmdseek = 0 ;requires enable_seek=1 + cmdread = 1 ;requires enable_write=1 + cmdwrite = 2 ;requires enable_write=1 + SETKBD = $fe89 + SETVID = $fe93 + DEVNUM = $bf30 + PHASEOFF = $c080 + MOTOROFF = $c088 + MOTORON = $c089 + DRV0EN = $c08a + Q6L = $c08c + Q6H = $c08d + Q7L = $c08e + Q7H = $c08f + MLI = $bf00 + NAME_LENGTH = $4 ;ProDOS constant + MASK_SUBDIR = $d0 ;ProDOS constant + MASK_ALL = $f0 ;ProDOS constant + KEY_POINTER = $11 ;ProDOS constant + EOF_LO = $15 ;ProDOS constant + EOF_HI = $16 ;ProDOS constant + AUX_TYPE = $1f ;ProDOS constant + ENTRY_SIZE = $27 ;ProDOS constant + NEXT_BLOCK_LO = $2 ;ProDOS constant + NEXT_BLOCK_HI = $3 ;ProDOS constant + SAPLING = $20 ;ProDOS constant + FILE_COUNT = $25 ;ProDOS constant + DEVADR01HI = $bf11 ;ProDOS constant + ROMIN = $c081 + LCBANK2 = $c089 + CLRAUXRD = $c002 + CLRAUXWR = $c004 + SETAUXWR = $c005 + CLRAUXZP = $c008 + SETAUXZP = $c009 + + first_zp = $40 ;lowest address to save if swap_zp enabled + ;last_zp is calculated automatically + + D1S1 = 1 ;disk 1 side 1 volume ID if rwts_mode enabled + +init lda DEVNUM + sta x80_parms + 1 + sta unrunit1 + 1 + and #$70 +!if (enable_floppy + enable_write) > 1 { + sta unrslot1 + 1 + sta unrslot2 + 1 + sta unrslot3 + 1 + sta unrslot4 + 1 +} ;enable_floppy = 1 and enable_write = 1 + pha +!if enable_floppy = 1 { + ora # 0 { + sta unrdrvoff2 + 1 + } ;might_exist = 1 or poll_drive = 1 + !if (aligned_read + allow_aux) = 0 { + sta unrdrvoff3 + 1 + } ;aligned_read = 0 and allow_aux = 0 + sta unrdrvoff4 + 1 + tax + inx ;MOTORON + !if allow_multi = 1 { + stx unrdrvon1 + 1 + } ;allow_multi = 1 + stx unrdrvon2 + 1 + !if aligned_read = 0 { + stx unrdrvon3 + 1 + } ;aligned_read = 0 + stx unrdrvon4 + 1 + inx ;DRV0EN + !if allow_multi = 1 { + stx unrdrvsel2 + 1 + } ;allow_multi = 1 + inx + !if allow_multi = 1 { + stx unrdrvsel1 + 1 + } ;allow_multi = 1 + inx ;Q6L + stx unrread1 + 1 + !if (poll_drive + allow_multi) > 0 { + stx unrread2 + 1 + stx unrread3 + 1 + } ;poll_drive = 1 or allow_multi = 1 + stx unrread4 + 1 + stx unrread5 + 1 + !if check_chksum = 1 { + stx unrread6 + 1 + } ;check_chksum = 1 +} ;enable_floppy = 1 + ldx #1 + stx namlo + inx + stx namhi + + ;fetch path, if any + + jsr MLI + !byte $c7 + !word c7_parms + ldx $200 + dex + stx sizelo + sec + bmi +++ + + ;find current directory name in directory + + php + +readblock jsr MLI + !byte $80 + !word x80_parms + + lda #<(readbuff + NAME_LENGTH) + sta scratchlo + lda #>(readbuff + NAME_LENGTH) + sta scratchhi +inextent ldy #0 + lda (scratchlo), y + pha + and #$0f + tax +-- iny + lda (scratchlo), y + cmp (namlo), y + beq ifoundname + + ;match failed, move to next directory in this block, if possible + +- pla + +skiphdr clc + lda scratchlo + adc #ENTRY_SIZE + sta scratchlo + bcc + + + ;there can be only one page crossed, so we can increment instead of adc + + inc scratchhi ++ cmp #<(readbuff + $1ff) ;4 + ($27 * $0d) + lda scratchhi + sbc #>(readbuff + $1ff) + bcc inextent + + ;read next directory block when we reach the end of this block + + lda readbuff + NEXT_BLOCK_LO + ldx readbuff + NEXT_BLOCK_HI + bcs + + +ifoundname dex + bne -- + + ;parse path until last directory is seen + + iny + lda (namlo), y + cmp #'/' + bne - + pla + and #$20 ;Volume Directory Header XOR subdirectory + beq adjpath + pla + clc + php + lsr + bcc skiphdr + inx + +adjpath tya + eor #$ff + adc sizelo + sta sizelo + clc + tya + adc namlo + sta namlo + dex + beq ++ + + ;cache block number of current directory + ;as starting position for subsequent searches + + ldy #(KEY_POINTER + 1) + lda (scratchlo), y + tax + dey + lda (scratchlo), y +!if enable_floppy = 1 { + sta unrblocklo + 1 + stx unrblockhi + 1 +} ;enable_floppy = 1 + sta unrhddblocklo + 1 + stx unrhddblockhi + 1 ++ sta x80_parms + 4 + stx x80_parms + 5 +++ lda sizelo + bne readblock + pla + + ;unit to slot for ProDOS interface + ++++ pla + lsr + lsr + lsr + tay + ldx DEVADR01HI, y + cpx #$c8 + bcc set_slot1 +!if use_smartport = 1 { + php +} ;use_smartport = 1 +!if enable_floppy = 1 { + + ;check if current device is floppy + + lsr + ora #$c0 + tax + stx scratchhi + ldy #0 + sty scratchlo + iny + lda (scratchlo), y + cmp #$20 + bne not_floppy + iny + iny + lda (scratchlo), y + bne not_floppy + iny + iny + lda (scratchlo), y + cmp #3 + bne not_floppy + ldy #$ff + lda (scratchlo), y + beq set_slot1 + +not_floppy +} ;enable_floppy = 1 + + ;find SmartPort device for basic MicroDrive support + + ldx #$c8 +- dex + stx scratchhi + ldy #0 + sty scratchlo + iny + lda (scratchlo), y + cmp #$20 + bne - + iny + iny + lda (scratchlo), y + bne - + iny + iny + lda (scratchlo), y + cmp #3 + bne - + ldy #$ff + lda (scratchlo), y + beq - + +!if use_smartport = 1 { +set_slot plp +} ;use_smartport = 1 +set_slot1 stx slot + 2 + stx unrentry + 2 +slot ldx $cfff + stx unrentry + 1 +!if enable_floppy = 1 { + php +} ;enable_floppy = 1 +!if use_smartport = 1 { + !if enable_floppy = 1 { + beq + + } ;enable_floppy = 1 + bcs ++ ++ jmp bankram + +++ lda #$8c ;STY + !if (rwts_mode + enable_write) > 1 { + sta unrcommand1 + } ;rwts_mode = 1 and enable_write = 1 + sta unrcommand3 + lda # 1 { + sta unrcommand1 + 1 + } ;rwts_mode = 1 and enable_write = 1 + !if (rwts_mode + aligned_read + (enable_write xor 1)) = 0 { + sta unrcommand2 + 1 + } ;rwts_mode = 0 and aligned_read = 0 and enable_write = 1 + sta unrcommand3 + 1 + lda #>pcommand + !if (rwts_mode + enable_write) > 1 { + sta unrcommand1 + 2 + } ;rwts_mode = 1 and enable_write = 1 + !if (rwts_mode + aligned_read + (enable_write xor 1)) = 0 { + sta unrcommand2 + 2 + } ;rwts_mode = 0 and aligned_read = 0 and enable_write = 1 + sta unrcommand3 + 2 + lda #$8e ;STX + !if (rwts_mode + aligned_read + (enable_write xor 1)) = 0 { + sta unrcommand2 + } ;rwts_mode = 0 and aligned_read = 0 and enable_write = 1 + sta unrbloklo + lda #pblock + sta unrbloklo + 2 + lda #$8d ;STA + sta unrblokhi + lda #<(pblock + 1) + sta unrblokhi + 1 + lda #>(pblock + 1) + sta unrblokhi + 2 + lda #$a5 ;LDA + sta unrunit1 + lda #adrlo + sta unrunit1 + 1 + lda #$8d ;STA + sta unrunit1 + 2 + lda #paddr + sta unrunit1 + 4 + + ;use SmartPort entrypoint instead + + inx + inx + inx + stx unrentry + 1 + + ldx #2 + stx x80_parms + 4 + lda #0 + sta x80_parms + 5 + jsr MLI + !byte $80 + !word x80_parms + lda #cmdread + sta unrpcommand + lda #$ea + sta hackstar + +iterunit inc unrunit2 + jsr unrentrysei + ++ ldy #$10 +- lda readbuff + 3, y + cmp readbuff + $203, y + bne iterunit + dey + bne - + lda #$68 + sta hackstar + lda #packet + sta unrppacket + 1 +} ;use_smartport = 1 + +bankram +!if load_banked = 1 { + lda LCBANK2 + 2 - ((lc_bank - 1) * 8) + lda LCBANK2 + 2 - ((lc_bank - 1) * 8) +} ;load_banked = 1 +!if load_aux = 1 { + sta SETAUXWR + (load_banked * 4) ;SETAUXWR or SETAUXZP +} ;load_aux = 1 +!if enable_floppy = 1 { + ldx #>unrelocdsk + ldy #unrelochdd + ldy #((codeend - rdwrpart) + $ff) + ldy #0 +- lda (scratchlo), y +reladr sta reloc, y + iny + bne - + inc scratchhi + inc reladr + 2 + dex + bne - + plp + bne ++ + + ;build 6-and-2 denibbilisation table + + ldx #$16 +-- stx scratchlo + txa + asl + bit scratchlo + beq + + ora scratchlo + eor #$ff + and #$7e +- bcs + + lsr + bne - + tya + sta nibtbl - $16, x + !if enable_write = 1 { + ;and 6-and-2 nibbilisation table if writing + + txa + ora #$80 + sta xlattbl, y + } ;enable_write = 1 + iny ++ inx + bpl -- + +unrdrvon1 lda MOTORON + jsr readadr + lda curtrk + sta trackd1 + + !if allow_multi = 1 { +unrdrvsel1 lda DRV0EN + 1 + jsr spinup + jsr poll + bcs + + lda #$c8 ;iny + sta twodrives + inc driveind + 1 + jsr readadr + lda curtrk + sta trackd2 ++ + } ;allow_multi = 1 +unrdrvoff1 lda MOTOROFF +++ +} else { ;enable_floppy = 0 + ldy #0 +- lda unrelochdd, y + sta reloc, y + + !if one_page = 0 { + ;hack to avoid address overflow when load_high and load_banked + ;and code is less than two pages long (e.g. aligned_read, no write) + ;can't insert code during pass two because it breaks existing offsets + + lda unrelochdd + $100, y + sta reloc + $100, y + lda unrelochdd + $200, y + sta reloc + $200, y + } ;one_page = 0 + iny + bne - +} ;enable_floppy = 1 +!if swap_scrn = 1 { + jsr saveslot + lda #$91 + sta initpatch +} ;swap_scrn = 1 +!if load_aux = 1 { + sta CLRAUXWR + (load_banked * 4) ;CLRAUXWR or CLRAUXZP +} ;load_aux = 1 + +!if rwts_mode = 1 { + ;read volume directory key block + ;self-modified by init code + +hddopendir +unrhddblocklo = * + ldx #2 +unrhddblockhi = * + lda #0 +hddreaddir1 jsr hddreaddirsel + +hddfirstent lda #NAME_LENGTH + sta scratchlo + lda #>(hdddirbuf - 1) + sta scratchhi + + ;there can be only one page crossed, so we can increment here + +hddnextent1 inc scratchhi +hddnextent ldy #0 + + ;match name lengths before attempting to match names + + lda (scratchlo), y + and #$0f + tax + inx +- cmp filename, y + beq hddfoundname + + ;match failed, move to next entry in this block, if possible + ++ clc + lda scratchlo + adc #ENTRY_SIZE + sta scratchlo + bcs hddnextent1 + cmp #$ff ;4 + ($27 * $0d) + bne hddnextent + + ;read next directory block when we reach the end of this block + + ldx hdddirbuf + NEXT_BLOCK_LO + lda hdddirbuf + NEXT_BLOCK_HI + bcs hddreaddir1 + +hddfoundname iny + lda (scratchlo), y + dex + bne - + + !if ((swap_zp xor 1) + mem_swap) > 0 { + !if allow_trees = 1 { + stx treeidx + sty lasttree ;guarantee no match + } ;allow_trees = 1 + stx blkidx + sty lastblk ;guarantee no match + } else { ;swap_zp = 1 and mem_swap = 0 + !if allow_trees = 1 { + stx zp_array + treeidx - first_zp + sty zp_array + lasttree - first_zp ;guarantee no match + } ;allow_trees = 0 + stx zp_array + blkidx - first_zp + sty zp_array + lastblk - first_zp ;guarantee no match + } ;swap_zp = 0 or mem_swap = 1 + + !if allow_trees = 1 { + ;fetch KEY_POINTER + + ldy #KEY_POINTER + lda (scratchlo), y + !if fast_trees = 0 { + !if ((swap_zp xor 1) + mem_swap) > 0 { + sta treeblklo + } else { ;swap_zp = 1 and mem_swap = 0 + sta zp_array + treeblklo - first_zp + } ;swap_zp = 0 or mem_swap = 1 + } else { ;fast_trees = 1 + tax + } ;fast_trees = 0 + iny + lda (scratchlo), y + !if fast_trees = 0 { + !if ((swap_zp xor 1) + mem_swap) > 0 { + sta treeblkhi + } else { ;swap_zp = 1 and mem_swap = 0 + sta zp_array + treeblkhi - first_zp + } ;swap_zp = 0 or mem_swap = 1 + } else { ;fast_trees = 1 + ldy #>hddtreebuf + jsr hddreaddirsect + } ;fast_trees = 0 + } ;allow_trees = 1 + + lda #>iob + ldy #iob + ldy # 0 { + jmp rdwrfile + } ;enable_readseq = 1 or allow_subdir = 1 +opendir + !if no_interrupts = 1 { + !if detect_err = 1 { + clc + } ;detect_err = 1 + php + sei + jsr + + !if detect_err = 1 { + pla + adc #0 + pha + } ;detect_err = 1 + plp + rts ++ + } ;no_interrupts = 1 + + ;read volume directory key block + ;self-modified by init code + +unrblocklo = unrelocdsk + (* - reloc) + ldx #2 +unrblockhi = unrelocdsk + (* - reloc) + lda #0 + jsr readdirsel + +readdir ;note that calling this location directly limits subdirectories to 14 entries! + lda #NAME_LENGTH + ENTRY_SIZE +firstent sta scratchlo + lda #>(dirbuf - 1) + sta scratchhi + + !if might_exist = 1 { + lda dirbuf + FILE_COUNT ;assuming only 256 files per subdirectory + sta entries + !if many_files = 1 { + lda dirbuf + FILE_COUNT + 1 + sta entrieshi + } ;many_files = 1 + } ;might_exist = 1 + + ;there can be only one page crossed, so we can increment here + +nextent1 inc scratchhi +nextent ldy #0 + !if (might_exist + allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + lda (scratchlo), y + !if might_exist = 1 { + sty status + + ;skip deleted entries without counting + + and #MASK_ALL + beq + + } ;might_exist = 1 + + !if (allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + ;remember type + ;now bits 5-4 are represented by carry (subdirectory), sign (sapling) + + asl + asl + + !if allow_trees = 1 { + ;now bits 5-3 are represented by carry (subdirectory), sign (sapling), + ;overflow (seedling), and sign+overflow (tree) + + sta treeidx + bit treeidx + } ;allow_trees = 1 + php + } ;allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + } ;might_exist = 1 or allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + + ;match name lengths before attempting to match names + + lda (scratchlo), y + and #$0f + tax + inx +- cmp (namlo), y + beq foundname + + ;match failed, check if any directory entries remain + + !if (allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + plp + } ;allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + !if might_exist = 1 { + dec entries + bne + + !if many_files = 1 { + lda entrieshi + bne ++ + } ;many_files = 1 + } ;might_exist = 1 + !if (might_exist + poll_drive) > 0 { +nodisk +unrdrvoff2 = unrelocdsk + (* - reloc) + lda MOTOROFF + inc status + rts + } ;might_exist = 1 or poll_drive = 1 + + !if (might_exist + many_files) > 1 { +++ dec entrieshi + } ;might_exist = 1 and many_files = 1 + + ;move to next entry in this block, if possible + ++ clc + lda scratchlo + adc #ENTRY_SIZE + sta scratchlo + bcs nextent1 + cmp #$ff ;4 + ($27 * $0d) + bne nextent + + ;read next directory block when we reach the end of this block + + ldx dirbuf + NEXT_BLOCK_LO + lda dirbuf + NEXT_BLOCK_HI + jsr readdirsec + lda #NAME_LENGTH + bne firstent + +foundname iny + lda (scratchlo), y + dex + bne - + + ;initialise essential variables + + !if allow_trees = 1 { + stx treeidx + !if always_trees = 0 { + stx istree + } ;always_trees = 0 + } ;allow_trees = 1 + stx blkidx + !if (aligned_read + one_shot) = 0 { + stx blkofflo + stx blkoffhi + } ;aligned_read = 0 and one_shot = 0 + !if enable_write = 1 { + !if aligned_read = 0 { + ldy reqcmd + cpy #cmdwrite ;control carry instead of zero + bne + + } ;aligned_read = 0 + !if one_shot = 0 { + + ;round requested size up to nearest block if writing + + lda sizelo + adc #$fe + lda sizehi + adc #1 + and #$fe + sta sizehi + !if aligned_read = 0 { + stx sizelo + !if bounds_check = 1 { + sec + } ;bounds_check = 1 + } ;aligned_read = 0 + } ;one_shot = 0 ++ + } ;enable_write = 1 + + !if (bounds_check + return_size + one_shot) > 0 { + ;cache EOF (file size, loaded backwards) + + ldy #EOF_HI + lda (scratchlo), y + !if (enable_write + aligned_read) > 0 { + tax + dey ;EOF_LO + lda (scratchlo), y + + ;round file size up to nearest block if writing without aligned reads + ;or always if using aligned reads + + !if aligned_read = 0 { + bcc + + } else { ;aligned_read = 1 + !if enable_write = 1 { + sec + } ;enable_write = 1 + } ;aligned_read = 0 + adc #$fe + txa + adc #1 + and #$fe + !if aligned_read = 0 { + tax + lda #0 + !if one_shot = 0 { ++ stx blefthi + sta bleftlo + } else { ;one_shot = 1 ++ stx sizehi + sta sizelo + } ;one_shot = 0 + } else { ;aligned_read = 1 + !if one_shot = 0 { + sta blefthi + } else { ;one_shot = 1 + sta sizehi + } ;one_shot = 0 + } ;aligned_read = 0 + } else { ;enable_write = 0 and aligned_read = 0 + !if one_shot = 0 { + sta blefthi + } else { ;one_shot = 1 + sta sizehi + } ;one_shot = 0 + dey ;EOF_LO + lda (scratchlo), y + !if one_shot = 0 { + sta bleftlo + } else { ;one_shot = 1 + sta sizelo + } ;one_shot = 0 + } ;enable_write = 1 or aligned_read = 1 + } ;bounds_check = 1 or return_size = 1 or one_shot = 1 + ;cache AUX_TYPE (load offset for binary files) + + !if override_adr = 0 { + ldy #AUX_TYPE + jsr fetchscratch + stx ldrlo + sta ldrhi + } ;override_adr = 0 + + ;cache KEY_POINTER + + ldy #KEY_POINTER + jsr fetchscratch + !if (allow_subdir + allow_saplings + allow_trees) > 0 { + stx dirbuf + !if (allow_trees + (fast_trees xor 1)) > 1 { + stx treeblklo + } ;allow_trees = 1 and fast_trees = 0 + sta dirbuf + 256 + !if (allow_trees + (fast_trees xor 1)) > 1 { + sta treeblkhi + } ;allow_trees = 1 and fast_trees = 0 + + !if always_trees = 0 { + plp + bpl ++ + !if allow_subdir = 1 { + php + } ;allow_subdir = 1 + !if allow_trees = 1 { + ldy #>dirbuf + bvc + + !if fast_trees = 1 { + ldy #>treebuf + } ;fast_trees = 1 + sty istree ++ + } ;allow_trees = 1 + } else { ;always_trees = 1 + ldy #>treebuf + } ;always_trees = 0 + } else { ;allow_subdir = 0 and allow_saplings = 0 and allow_trees = 0 + iny + lda (scratchlo), y + } ;allow_subdir = 1 or allow_saplings = 1 or allow_trees = 1 + + ;read index block in case of sapling or tree + + jsr readdirsect + + !if allow_subdir = 1 { + plp + } ;allow_subdir = 1 +++ + ;skip some stuff + ;drive is on already + ;and interrupt control is in place + + jmp rdwrfilei + +rdwrfile +unrdrvon2 = unrelocdsk + (* - reloc) + lda MOTORON + !if allow_subdir = 1 { + clc + } ;allow_subdir = 1 + !if no_interrupts = 1 { + !if detect_err = 1 { + !if allow_subdir = 0 { + clc + } ;allow_subdir = 0 + } ;detect_err = 1 + php + sei + jsr + + !if detect_err = 1 { + pla + adc #0 + pha + } ;detect_err = 1 + plp + rts ++ + } ;no_interrupts = 1 + +rdwrfilei + !if (override_adr + allow_subdir + allow_saplings + allow_trees + (aligned_read xor 1)) > 0 { + ;restore load offset + + ldx ldrhi + lda ldrlo + !if allow_subdir = 1 { + ;check file type and fake size and load address for subdirectories + + bcc + + ldy #2 + sty sizehi + ldx #>dirbuf + lda #0 + !if aligned_read = 0 { + sta sizelo + } ;aligned_read = 0 ++ + } ;allow_subdir = 1 + sta adrlo + stx adrhi + } else { ;override_adr = 0 and allow_subdir = 0 and allow_saplings = 0 and allow_trees = 0 and aligned_read = 1 + pla + sta adrhi + pla + sta adrlo + } ;override_adr = 1 or allow_subdir = 1 or allow_saplings = 1 or allow_trees = 1 or aligned_read = 0 + + ;set requested size to min(length, requested size) + + !if aligned_read = 0 { + !if bounds_check = 1 { + ldy bleftlo + cpy sizelo + lda blefthi + tax + sbc sizehi + bcs copyblock + sty sizelo + stx sizehi + } ;bounds_check = 1 + +copyblock + !if allow_aux = 1 { + ldx auxreq + jsr setaux + } ;allow_aux = 1 + !if one_shot = 0 { + !if enable_write = 1 { + lda reqcmd + lsr + bne rdwrloop + } ;enable_write = 1 + + ;if offset is non-zero then we return from cache + + lda blkofflo + tax + ora blkoffhi + beq rdwrloop + lda sizehi + pha + lda sizelo + pha + lda adrhi + sta scratchhi + lda adrlo + sta scratchlo + stx adrlo + lda #>encbuf + clc + adc blkoffhi + sta adrhi + + ;determine bytes left in block + + lda #1 + sbc blkofflo + tay + lda #2 + sbc blkoffhi + tax + + ;set requested size to min(bytes left, requested size) + + cpy sizelo + sbc sizehi + bcs + + sty sizelo + stx sizehi ++ + !if enable_seek = 1 { + lda sizehi + } else { ;enable_seek = 0 + ldy sizehi + } ;enable_seek = 1 + jsr copycache +unrdrvon3 = unrelocdsk + (* - reloc) + lda MOTORON ;copycache turns it off + + ;align to next block and resume read + + lda ldrlo + adc sizelo + sta ldrlo + lda ldrhi + adc sizehi + sta ldrhi + sec + pla + sbc sizelo + sta sizelo + pla + sbc sizehi + sta sizehi + ora sizelo + !if allow_subdir = 1 { + !if no_interrupts = 1 { + clc + bne rdwrfilei + } else { ;no_interrupts = 0 + bne rdwrfile + } ;no_interrupts = 1 + } else { ;allow_subdir = 0 + bne rdwrfilei + } ;allow_subdir = 1 + !if allow_aux = 0 { +unrdrvoff3 = unrelocdsk + (* - reloc) + lda MOTOROFF + rts + } else { ;allow_aux = 1 + beq rdwrdonedrv + } ;allow_aux = 0 + } ;one_shot = 0 + } else { ;aligned_read = 1 + !if bounds_check = 1 { + lda blefthi + cmp sizehi + bcs + + sta sizehi ++ + } ;bounds_check = 1 + !if allow_aux = 1 { + ldx auxreq + jsr setaux + } ;allow_aux = 1 + } ;aligned_read = 0 + +rdwrloop + !if aligned_read = 0 { + !if (enable_write + enable_seek) > 0 { + ldx reqcmd + } ;enable_write = 1 or enable_seek = 1 + + ;set read/write size to min(length, $200) + + lda sizehi + cmp #2 + bcs + + pha + + ;redirect read to private buffer for partial copy + + lda adrhi + pha + lda adrlo + pha + lda #>encbuf + sta adrhi + !if ver_02 = 1 { + ldx #0 + stx adrlo + !if (enable_write + enable_seek) > 0 { + inx ;ldx #cmdread + } ;enable_write = 1 or enable_seek = 1 + } else { ;ver_02 = 0 + stz adrlo + !if (enable_write + enable_seek) > 0 { + ldx #cmdread + } ;enable_write = 1 or enable_seek = 1 + } ;ver_02 = 1 ++ + } ;aligned_read = 0 + + !if allow_trees = 1 { + ;read tree data block only if tree and not read already + ;the indication of having read already is that at least one sapling/seed block entry has been read, too + + ldy blkidx + bne + + !if always_trees = 0 { + lda istree + beq + + } ;always_trees = 0 + lda adrhi + pha + lda adrlo + pha + !if ((aligned_read xor 1) + (enable_write or enable_seek)) > 1 { + !if ver_02 = 1 { + txa + pha + } else { ;ver_02 = 0 + phx + } ;ver_02 = 1 + } ;aligned_read = 0 and (enable_write = 1 or enable_seek = 1) + !if aligned_read = 0 { + php + } ;aligned_read = 0 + lda #>dirbuf + sta adrhi + sty adrlo + + ;fetch tree data block and read it + + !if fast_trees = 0 { + ldx treeblklo + lda treeblkhi + jsr readdirsel + } ;fast_trees = 0 + ldy treeidx + inc treeidx + ldx treebuf, y + lda treebuf + 256, y + !if detect_treof = 1 { + bne noteof1 + tay + txa + bne fixy1 + !if aligned_read = 0 { + plp + bcs fewpop + pla + pla + pla +fewpop + } ;aligned_read = 0 + pla + pla + sec + rts +fixy1 tya +noteof1 + } ;detect_treof = 1 + + !if fast_trees = 0 { + jsr seekrd + } else { ;fast_trees = 1 + jsr readdirsel + } ;fast_trees = 0 + + !if aligned_read = 0 { + plp + } ;aligned_read = 0 + !if ((aligned_read xor 1) + (enable_write or enable_seek)) > 1 { + !if ver_02 = 1 { + pla + tax + } else { ;ver_02 = 0 + plx + } ;ver_02 = 1 + } ;aligned_read = 0 and (enable_write = 1 or enable_seek = 1) + pla + sta adrlo + pla + sta adrhi + } ;allow_trees = 1 + + ;fetch data block and read/write it + +skiptree ldy blkidx ++ inc blkidx + !if aligned_read = 0 { + !if enable_seek = 1 { + txa ;cpx #cmdseek, but that would require php at top + beq + + } ;enable_seek = 1 + !if enable_write = 1 { + stx command + } ;enable_write = 1 + } ;aligned_read = 0 + + ldx dirbuf, y + lda dirbuf + 256, y + !if detect_treof = 1 { + bne noteof2 + tay + txa + bne fixy2 + sec + rts +fixy2 tya +noteof2 + } ;detect_treof = 1 + !if allow_sparse = 1 { + pha + ora dirbuf, y + tay + pla + dey + iny ;don't affect carry + } ;allow_sparse = 1 + !if aligned_read = 0 { + php + } ;aligned_read = 0 + !if allow_sparse = 1 { + beq issparse + } ;allow_sparse = 1 + !if (aligned_read and (enable_write or enable_seek)) = 1 { + ldy reqcmd + !if enable_seek = 1 { + beq + + } ;enable_seek = 1 + } ;aligned_read = 1 and (enable_write = 1 or enable_seek = 1) + !if enable_write = 1 { + jsr seekrdwr + } else { ;enable_write = 0 + jsr seekrd + } ;enable_write = 1 + +resparse + !if aligned_read = 0 { + plp ++ bcc + + !if bounds_check = 1 { + dec blefthi + dec blefthi + } ;bounds_check = 1 + } ;aligned_read = 0 + dec sizehi + dec sizehi + bne rdwrloop + +rdwrdonedrv +unrdrvoff4 = unrelocdsk + (* - reloc) + lda MOTOROFF + !if aligned_read = 0 { + lda sizelo + bne rdwrloop + } ;aligned_read = 0 +rdwrdone + !if allow_aux = 1 { + ldx #0 +setaux sta CLRAUXRD, x + sta CLRAUXWR, x + } ;allow_aux = 1 + rts + + !if allow_sparse = 1 { +issparse +- sta (adrlo), y + iny + bne - + inc adrhi +- sta (adrlo), y + iny + bne - + dec adrhi + bne resparse + } ;allow_sparse = 1 + + !if aligned_read = 0 { + ;cache partial block offset + ++ pla + sta scratchlo + pla + sta scratchhi + pla + !if one_shot = 0 { + sta sizehi + } ;one_shot = 0 + dec adrhi + dec adrhi + + !if enable_seek = 1 { +copycache + ldy reqcmd + ;cpy #cmdseek + beq ++ + tay + } else { ;enable_seek = 0 + tay +copycache + } ;enable_seek = 1 + beq + + dey +- lda (adrlo), y + sta (scratchlo), y + iny + bne - + inc scratchhi + inc adrhi + bne + +- lda (adrlo), y + sta (scratchlo), y + iny ++ cpy sizelo + bne - +++ + !if one_shot = 0 { + !if bounds_check = 1 { + lda bleftlo + sec + sbc sizelo + sta bleftlo + lda blefthi + sbc sizehi + sta blefthi + } ;bounds_check = 1 + clc + !if enable_seek = 1 { + lda sizelo + } else { ;enable_seek = 0 + tya + } ;enable_seek = 1 + adc blkofflo + sta blkofflo + lda sizehi + adc blkoffhi + and #$fd + sta blkoffhi + bcc rdwrdone ;always + } else { ;one_shot = 1 + rts + } ;one_shot = 0 + } ;aligned_read = 0 + +spinup ldy #6 +- jsr delay + dey + bpl - + +delay +-- ldx #$11 +- dex + bne - + sec + sbc #1 + bne -- + rts + + ;no tricks here, just the regular stuff + +seek ldy #0 + sty step + asl phase + txa + asl +copy_cur tax + sta tmptrk + sec + sbc phase + beq +++ + bcs + + !if ver_02 = 1 { + eor #$ff + } else { ;ver_02 = 0 + inc + } ;ver_02 = 1 + inx + bcc ++ ++ + !if ver_02 = 1 { + sbc #1 + } else { ;ver_02 = 0 + dec + } ;ver_02 = 1 + dex +++ cmp step + bcc + + lda step ++ cmp #8 + bcs + + tay + sec ++ + !if ver_02 = 1 { + txa + pha + } else { ;ver_02 = 0 + phx + } ;ver_02 = 1 + ldx step1, y ++++ php + bne + +--- clc + lda tmptrk + ldx step2, y ++ stx tmpsec + and #3 + rol + tax + lsr +unrseek = unrelocdsk + (* - reloc) + lda PHASEOFF, x +-- ldx #$12 +- dex + bpl - + dec tmpsec + bne -- + bcs --- + plp + beq seekret + pla + inc step + bne copy_cur + +step1 !byte 1, $30, $28, $24, $20, $1e, $1d, $1c +step2 !byte $70, $2c, $26, $22, $1f, $1e, $1d, $1c + +readadr +- jsr readd5aa + cmp #$96 + bne - + ldy #3 +- sta curtrk + jsr readnib + rol + sta tmpsec + jsr readnib + and tmpsec + dey + bne - +seekret rts + +readd5aa +-- jsr readnib +- cmp #$d5 + bne -- + jsr readnib + cmp #$aa + bne - + tay ;we need Y=#$AA later + +readnib +unrread1 = unrelocdsk + (* - reloc) +- lda Q6L + bpl - + rts + + !if (poll_drive + allow_multi) > 0 { +poll ldy #0 +unrread2 = unrelocdsk + (* - reloc) +- lda Q6L + jsr seekret + pha + pla +unrread3 = unrelocdsk + (* - reloc) + cmp Q6L + clc + bne + + dey + bne - + sec ++ rts + } ;poll_drive = 1 or allow_multi = 1 + +readdirsel + !if ver_02 = 1 { + pha + txa + pha + } else { ;ver_02 + pha + phx + } ;ver_02 = 1 + +unrdrvon4 = unrelocdsk + (* - reloc) + lda MOTORON + !if (ver_02 + allow_multi) > 0 { + ldy #0 + sty adrlo + !if poll_drive = 1 { + sty status + } ;poll_drive = 1 + } else { ;ver_02 = 0 and allow_multi = 0 + stz adrlo + !if poll_drive = 1 { + stz status + } ;poll_drive = 1 + } ;ver_02 = 1 or allow_multi = 1 + !if allow_multi = 1 { + asl reqcmd + bcc seldrive +twodrives nop ;replace with INY if drive exists +seldrive lsr reqcmd +unrdrvsel2 = unrelocdsk + (* - reloc) + lda DRV0EN, y + cpy driveind + 1 + sty driveind + 1 + beq nodelay + jsr spinup + +nodelay + } ;allow_multi = 1 + !if poll_drive = 1 { + jsr poll + bcc + + pla + pla + pla + pla + jmp nodisk ++ + } ;poll_drive = 1 + !if ver_02 = 1 { + pla + tax + pla + } else { ;ver_02 + plx + pla + } ;ver_02 = 1 + +readdirsec + !if allow_trees = 0 { +readdirsect ldy #>dirbuf + } else { ;allow_trees = 1 + ldy #>dirbuf +readdirsect + } ;allow_trees = 1 + sty adrhi +seekrd ldy #cmdread + !if (aligned_read + enable_write) > 1 { +seekrdwr sty command + } else { ;aligned_read = 0 or enable_write = 0 + sty command +seekrdwr + } ;aligned_read = 1 and enable_write = 1 + + ;convert block number to track/sector + + lsr + txa + ror + lsr + lsr + sta phase + txa + and #3 + php + asl + plp + rol + sta reqsec + +driveind ldy #0 + ldx trackd1, y + + ;if track does not match, then seek + + cpx phase + beq checksec + lda phase + sta trackd1, y + jsr seek + + ;match or read/write sector + +checksec jsr cmpsecrd + inc reqsec + inc reqsec + +cmpsecrd jsr readadr + + !if enable_write = 1 { + ldy command + cpy #cmdwrite ;we need Y=2 below + beq encsec + } ;enable_write = 1 + cmp reqsec + bne cmpsecrd + + ;read sector data + + jsr readd5aa + eor #$ad ;zero A if match + bne cmpsecrd +unrread4 = unrelocdsk + (* - reloc) +- ldx Q6L + bpl - + eor nibtbl - $96, x + sta bit2tbl - $aa, y + iny + bne - +unrread5 = unrelocdsk + (* - reloc) +- ldx Q6L + bpl - + eor nibtbl - $96, x + sta (adrlo), y ;the real address + iny + bne - + !if check_chksum = 1 { +unrread6 = unrelocdsk + (* - reloc) +- ldx Q6L + bpl - + eor nibtbl - $96, x + bne cmpsecrd + } ;check_chksum = 1 +-- ldx #$a9 +- inx + beq -- + lda (adrlo), y + lsr bit2tbl - $aa, x + rol + lsr bit2tbl - $aa, x + rol + sta (adrlo), y + iny + bne - + inc adrhi + rts + + !if enable_write = 1 { +encsec +-- ldx #$aa +- dey + lda (adrlo), y + lsr + rol bit2tbl - $aa, x + lsr + rol bit2tbl - $aa, x + sta encbuf, y + lda bit2tbl - $aa, x + and #$3f + sta bit2tbl - $aa, x + inx + bne - + tya + bne -- + +cmpsecwr jsr readadr + cmp reqsec + bne cmpsecwr + + ;skip tail #$DE #$AA #$EB some #$FFs ... + + ldy #6 +- jsr readnib + dey + bpl - + + ;write sector data + +unrslot1 = unrelocdsk + (* - reloc) + ldx #$d1 + lda Q6H, x ;prime drive + lda Q7L, x ;required by Unidisk + tya + sta Q7H, x + ora Q6L, x + pha ;3 cycles + pla ;4 cycles + nop ;2 cycles + + ;40 cycles + + ldy #4 ;2 cycles + pha ;3 cycles + pla ;4 cycles + nop ;2 cycles +loopchk1 +- jsr writenib1 ;(29 cycles) + + ;+6 cycles + dey ;2 cycles + bne - ;3 cycles if taken, 2 if not + + ;36 cycles + ;+10 cycles + ldy #(prolog_e - prolog) + ;2 cycles + !if >loopchk1 != >* { + !serious "loop1 crosses a page" + } + cmp $ea ;3 cycles +loopchk2 +- lda prolog - 1, y ;4 cycles + jsr writenib2 ;(17 cycles) + + ;32 cycles if branch taken + ;+6 cycles + dey ;2 cycles + bne - ;3 cycles if taken, 2 if not + + ;36 cycles on first pass + ;+10 cycles + tya ;2 cycles + !if >loopchk2 != >* { + !serious "loop2 crosses a page" + } + ldy #$56 ;2 cycles +loopchk3 +- eor bit2tbl - 1, y ;5 cycles + tax ;2 cycles + lda xlattbl, x ;4 cycles +unrslot2 = unrelocdsk + (* - reloc) + ldx #$d1 ;2 cycles + sta Q6H, x ;5 cycles + lda Q6L, x ;4 cycles + + ;32 cycles if branch taken + + lda bit2tbl - 1, y ;5 cycles + dey ;2 cycles + bne - ;3 cycles if taken, 2 if not + + ;32 cycles + ;+9 cycles + clc ;2 cycles + !if >loopchk3 != >* { + !serious "loop3 crosses a page" + } +loopchk4 +-- eor encbuf, y ;4 cycles +loopchk5 +- tax ;2 cycles + lda xlattbl, x ;4 cycles +unrslot3 = unrelocdsk + (* - reloc) + ldx #$d1 ;2 cycles + sta Q6H, x ;5 cycles + lda Q6L, x ;4 cycles + bcs + ;3 cycles if taken, 2 if not + + ;32 cycles if branch taken + + lda encbuf, y ;4 cycles +loopchk6 ;belongs to the "bcs +" above + iny ;2 cycles + bne -- ;3 cycles if taken, 2 if not + + ;32 cycles + ;+10 cycles + sec ;2 cycles + !if >loopchk4 != >* { + !serious "loop4 crosses a page" + } + bcs - ;3 cycles + + ;32 cycles + ;+3 cycles + !if >loopchk6 != >* { + !serious "loop6 crosses a page" + } ++ ldy #(epilog_e - epilog) + ;2 cycles + !if >loopchk5 != >* { + !serious "loop5 crosses a page" + } + nop ;2 cycles + nop ;2 cycles + nop ;2 cycles +loopchk7 +- lda epilog - 1, y ;4 cycles + jsr writenib2 ;(17 cycles) + + ;32 cycles if branch taken + ;+6 cycles + dey ;2 cycles + bne - ;3 cycles if branch taken, 2 if not + + lda Q7L, x + !if >loopchk7 != >* { + !serious "loop7 crosses a page" + } + lda Q6L, x ;flush final value + inc adrhi + rts + +writenib1 jsr writeret ;6 cycles +writenib2 +unrslot4=unrelocdsk+(*-reloc) + ldx #$d1 ;2 cycles + sta Q6H, x ;5 cycles + ora Q6L, x ;4 cycles +writeret rts ;6 cycles + +prolog !byte $ad, $aa, $d5 +prolog_e + !if >(prolog - 1) != >prolog_e { + !serious "prologue crosses a page" + } +epilog !byte $ff, $eb, $aa, $de +epilog_e + !if >(epilog - 1) != >epilog_e { + !serious "epilogue crosses a page" + } + } ;enable_write = 1 +codeend +trackd1 !byte 0 +trackd2 !byte 0 + +bit2tbl = (* + 255) & -256 +nibtbl = bit2tbl + 86 + !if enable_write = 1 { +xlattbl = nibtbl + 106 +dataend = xlattbl + 64 + } else { ;enable_write = 0 +dataend = nibtbl + 106 + } ;enable_write = 1 +} ;enable_floppy = 1 +} ;reloc + +unrelochdd +!pseudopc reloc { +!if rwts_mode = 1 { + !if no_interrupts = 1 { + php + sei + jsr + + plp + rts ++ + } ;no_interrupts = 1 + !if swap_zp = 1 { + jsr swap_zpg + } ;swap_zp = 1 + sta namhi + sty namlo + !if ver_02 = 1 { + lda #0 + sta sizehi + } else { ;ver_02 + stz sizehi + } ;ver_02 = 1 + !if enable_format = 1 { + ldy #$0c ;command + lda (namlo),y + cmp #2 ;write (or format if greater) + php + bcc skipinit ;read + beq skipinit ;write + ldy #5 ;sector + !if ver_02 = 1 { + txa + } else { ;ver_02 + lda #0 + } ;ver_02 = 1 + sta (namlo),y + dey ;track + sta (namlo),y +skipinit + } ;enable_format = 1 + !if allow_multi = 1 { + ldy #3 ;volume + lda (namlo),y + !if allow_zerovol = 1 { + bne + +lastvol = * + 1 + lda #D1S1 ++ sta lastvol + } ;allow_zerovol = 1 + ldy #$0e ;returned volume + sta (namlo),y + ldx #vollist_e-vollist_b +- dex + cmp vollist_b,x + bne - + } ;allow_multi = 1 + ldy #4 ;track + lda (namlo),y + asl + asl + asl + rol sizehi + asl + rol sizehi + iny ;sector + ora (namlo),y + !if allow_multi = 1 { + ldy sizehi +- dex + bmi ++ + clc + adc #$30 + bcc + + iny ++ iny + iny + bne - +++ + } ;allow_multi = 1 + !if allow_trees = 1 { + tax + !if allow_multi = 1 { + tya + } else { ;allow_multi = 0 + lda sizehi + } ;allow_multi = 1 + lsr + sta treeidx + txa + } else { ;allow_trees = 0 + lsr sizehi + } ;allow_trees = 1 + ror + php + jsr seek1 + plp + !if fast_subindex = 0 { + lda #>hddencbuf + adc #0 + sta adrhi + } else { ;fast_subindex = 1 + bcc + + inc adrhi ++ + } ;fast_subindex = 0 + ldy #9 ;adrhi + lda (namlo),y + sta scratchhi + dey ;adrlo + lda (namlo),y + sta scratchlo + !if enable_format = 1 { + ldy #0 + ldx #0 + plp + bcs runinit + } else { ;enable_format = 0 + !if enable_write = 1 { + ldy #$0c ;command + lda (namlo),y + ldy #0 + lsr + bne runinit + } else { ;enable_write = 0 + ldy #0 + } ;enable_write = 1 + } ;enable_format = 1 + +- lda (adrlo),y + sta (scratchlo),y + iny + bne - + !if swap_zp = 0 { + clc + rts + } else { ;swap_zp = 1 + !if enable_write = 1 { + beq swap_zpg + } ;enable_write = 1 + } ;swap_zp = 0 + + !if enable_write = 1 { +runinit + !if enable_format = 1 { + bne format + } ;enable_format = 1 +- lda (scratchlo),y + sta (adrlo),y + iny + bne - + lda adrhi + and #$fe + sta adrhi + ldy #cmdwrite +unrcommand1 = unrelochdd + (* - reloc) + sty command + !if use_smartport = 1 { + nop ;allow replacing "sty command" with "sty pcommand" in extended SmartPort mode + } ;use_smartport = 1 + !if swap_zp = 1 { + jsr hddwriteimm + !if enable_format = 1 { + bcc swap_zpg ;always + } ;enable_format = 1 + } else { ;swap_zp = 0 + jmp hddwriteimm + } ;swap_zp = 1 + !if enable_format = 1 { +clrcarry clc + inc adrhi +format lda blanksec,x + sta (adrlo),y + inx + txa + and #7 + tax + iny + bne format + bcs clrcarry + dex + stx lasttree + iny + lda #$18 ;blocks + sta namlo + sty namhi + lda adrhi + and #$fe + sta adrhi + lda #cmdwrite + sta reqcmd + inc lastblk ;force mismatch +- jsr hddrdwrloop + inc blkidx + bne + + inc treeidx ++ dec namlo + bne - + dec namhi + bpl - + } ;enable_format = 1 + } ;enable_write = 1 + + !if swap_zp = 1 { +swap_zpg pha + tya + pha + ldx #(last_zp - first_zp) +- lda first_zp,x + ldy zp_array,x + sta zp_array,x + sty first_zp,x + dex + bpl - + pla + tay + pla + } ;swap_zp = 1 + + !if (enable_write + swap_zp) > 0 { + !if no_interrupts = 0 { + clc + } ;no_interrupts = 0 + rts + } ;enable_write = 1 or swap_zp = 1 + + !if enable_format = 1 { +blanksec !text "SAN INC." + } ;enable_format = 1 + +seek1 sta blkidx + !if enable_write = 1 { + lda #cmdread + sta reqcmd + } ;enable_write = 1 +} else { ;rwts_mode = 0 +hddopendir + !if no_interrupts = 1 { + !if detect_err = 1 { + clc + } ;detect_err = 1 + php + sei + jsr + + !if detect_err = 1 { + pla + adc #0 + pha + } ;detect_err = 1 + plp + rts ++ + } ;no_interrupts = 1 + + ;read volume directory key block + ;self-modified by init code + +unrhddblocklo = unrelochdd + (* - reloc) + ldx #2 +unrhddblockhi = unrelochdd + (* - reloc) + lda #0 + jsr hddreaddirsel + + !if enable_floppy = 1 { + !if (* - hddopendir) < (readdir - opendir) { + ;essential padding to match offset with floppy version + !fill (readdir - opendir) - (* - hddopendir), $ea + } + } ;enable_floppy = 1 + +hddreaddir ;note that calling this location directly limits subdirectories to 14 entries! + lda #NAME_LENGTH + ENTRY_SIZE +hddfirstent sta scratchlo +dirbufpatch1 + lda #>(hdddirbuf - 1) + sta scratchhi + + !if might_exist = 1 { + lda hdddirbuf + FILE_COUNT ;assuming only 256 files per subdirectory + sta entries + !if many_files = 1 { + lda hdddirbuf + FILE_COUNT + 1 + sta entrieshi + } ;many_files = 1 + } ;might_exist = 1 + + ;there can be only one page crossed, so we can increment here + +hddnextent1 inc scratchhi +hddnextent ldy #0 + !if (might_exist + allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + lda (scratchlo), y + !if might_exist = 1 { + sty status + + ;skip deleted entries without counting + + and #MASK_ALL + beq + + } ;might_exist = 1 + + !if (allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + ;remember type + ;now bits 5-4 are represented by carry (subdirectory), sign (sapling) + + asl + asl + + !if allow_trees = 1 { + ;now bits 5-3 are represented by carry (subdirectory), sign (sapling), + ;overflow (seedling), and sign+overflow (tree) + + sta treeidx + bit treeidx + } ;allow_trees = 1 + php + } ;allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + } ;might_exist = 1 or allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + + ;match name lengths before attempting to match names + + lda (scratchlo), y + and #$0f + tax + inx +- eor (namlo), y + asl + beq hddfoundname + + ;match failed, check if any directory entries remain + + !if (allow_subdir + allow_saplings + (always_trees xor 1)) > 0 { + plp + } ;allow_subdir = 1 or allow_saplings = 1 or always_trees = 0 + !if might_exist = 1 { + dec entries + bne + + !if many_files = 1 { + lda entrieshi + bne ++ + } ;many_files = 1 + inc status + rts + + !if many_files = 1 { +++ dec entrieshi + } ;many_files = 1 + } ;might_exist = 1 + + ;move to next entry in this block, if possible + ++ clc + lda scratchlo + adc #ENTRY_SIZE + sta scratchlo + bcs hddnextent1 + cmp #$ff ;4 + ($27 * $0d) + bne hddnextent + + ;read next directory block when we reach the end of this block + +dirbufpatch2 + ldx hdddirbuf + NEXT_BLOCK_LO +dirbufpatch3 + lda hdddirbuf + NEXT_BLOCK_HI + jsr hddreaddirsec + lda #NAME_LENGTH + bne hddfirstent + +hddfoundname iny + lda (scratchlo), y + dex + bne - + + ;initialise essential variables + + !if allow_trees = 1 { + stx treeidx + !if always_trees = 0 { + stx istree + } ;always_trees = 0 + } ;allow_trees = 1 + stx blkidx + !if (aligned_read + one_shot) = 0 { + stx blkofflo + stx blkoffhi + } ;aligned_read = 0 and one_shot = 0 + !if enable_write = 1 { + !if aligned_read = 0 { + ldy reqcmd + cpy #cmdwrite ;control carry instead of zero + bne + + } ;aligned_read = 0 + !if one_shot = 0 { + + ;round requested size up to nearest block if writing + + lda sizelo + adc #$fe + lda sizehi + adc #1 + and #$fe + sta sizehi + !if aligned_read = 0 { + stx sizelo + !if bounds_check = 1 { + sec + } ;bounds_check = 1 + } ;aligned_read = 0 + } ;one_shot = 0 ++ + } ;enable_write = 1 + + !if (bounds_check + return_size + one_shot) > 0 { + ;cache EOF (file size, loaded backwards) + + ldy #EOF_HI + lda (scratchlo), y + !if (enable_write + aligned_read) > 0 { + tax + dey ;EOF_LO + lda (scratchlo), y + + ;round file size up to nearest block if writing without aligned reads + ;or always if using aligned reads + + !if aligned_read = 0 { + bcc + + } else { ;aligned_read = 1 + !if enable_write = 1 { + sec + } ;enable_write = 1 + } ;aligned_read = 0 + adc #$fe + txa + adc #1 + and #$fe + !if aligned_read = 0 { + tax + lda #0 + !if one_shot = 0 { ++ stx blefthi + sta bleftlo + } else { ;one_shot = 1 ++ stx sizehi + sta sizelo + } ;one_shot = 0 + } else { ;aligned_read = 1 + !if one_shot = 0 { + sta blefthi + } else { ;one_shot = 1 + sta sizehi + } ;one_shot = 0 + } ;aligned_read = 0 + } else { ;enable_write = 0 and aligned_read = 0 + !if one_shot = 0 { + sta blefthi + } else { ;one_shot = 1 + sta sizehi + } ;one_shot = 0 + dey ;EOF_LO + lda (scratchlo), y + !if one_shot = 0 { + sta bleftlo + } else { ;one_shot = 1 + sta sizelo + } ;one_shot = 0 + } ;enable_write = 1 or aligned_read = 1 + } ;bounds_check = 1 or return_size = 1 or one_shot = 1 + ;cache AUX_TYPE (load offset for binary files) + + !if override_adr = 0 { + ldy #AUX_TYPE + lda (scratchlo), y + !if (allow_subdir + allow_saplings + allow_trees + (aligned_read xor 1)) > 0 { + sta ldrlo + iny + lda (scratchlo), y + sta ldrhi + } else { ;allow_subdir = 0 and allow_saplings = 0 and allow_trees = 0 and aligned_read = 1 + pha + iny + lda (scratchlo), y + pha + } ;allow_subdir = 1 or allow_saplings = 1 or allow_trees = 1 or aligned_read = 0 + } ;override_adr = 0 + +;;allow query even in override mode + ldy #AUX_TYPE + lda (scratchlo), y + sta ldrlo2 + iny + lda (scratchlo), y + sta ldrhi2 + + ;cache KEY_POINTER + + ldy #KEY_POINTER + lda (scratchlo), y + tax + !if (allow_subdir + allow_saplings + allow_trees) > 0 { +dirbufpatch4 + sta hdddirbuf + !if (allow_trees + (fast_trees xor 1)) > 1 { + sta treeblklo + } ;allow_trees = 1 and fast_trees = 0 + iny + lda (scratchlo), y +dirbufpatch5 + sta hdddirbuf + 256 + !if (allow_trees + (fast_trees xor 1)) > 1 { + sta treeblkhi + } ;allow_trees = 1 and fast_trees = 0 + !if always_trees = 0 { + plp +attribpatch + bpl ++ + !if allow_subdir = 1 { + php + } ;allow_subdir = 1 + !if allow_trees = 1 { + ldy #>hdddirbuf + bvc + + !if fast_trees = 1 { + ldy #>hddtreebuf + } ;fast_trees = 1 + sty istree ++ + } ;allow_trees = 1 + } else { ;always_trees = 1 + ldy #>hddtreebuf + } ;always_trees = 0 + } else { ;allow_subdir = 0 and allow_saplings = 0 and allow_trees = 0 + iny + lda (scratchlo), y + } ;allow_subdir = 1 or allow_saplings = 1 or allow_trees = 1 + + ;read index block in case of sapling or tree + + jsr hddreaddirsect + + !if allow_subdir = 1 { + plp + bcs hddrdwrfilei + } ;allow_subdir = 1 +++ +} ;rwts_mode = 1 + +hddrdwrpart +hddrdfile +hddrdwrfile + lda #$ff + sta sizehi2 +hddrdwrfilex +!if allow_subdir = 1 { + clc +} ;allow_subdir = 1 +!if (no_interrupts + (rwts_mode xor 1)) > 1 { + !if detect_err = 1 { + !if allow_subdir = 0 { + clc + } ;allow_subdir = 0 + } ;detect_err = 1 + php + sei + jsr + + !if detect_err = 1 { + pla + adc #0 + pha + } ;detect_err = 1 + plp + rts ++ +} ;no_interrupts = 1 and rwts_mode = 0 + +hddrdwrfilei +!if rwts_mode = 0 { + !if (override_adr + allow_subdir + allow_saplings + allow_trees + (aligned_read xor 1)) > 0 { + ;restore load offset + + ldx ldrhi + lda ldrlo + !if allow_subdir = 1 { + ;check file type and fake size and load address for subdirectories + + bcc + + ldy #2 + sty sizehi +dirbufpatch6 + ldx #>hdddirbuf + lda #0 + !if aligned_read = 0 { + sta sizelo + } ;aligned_read = 0 ++ + } ;allow_subdir = 1 + sta adrlo + stx adrhi + } else { ;override_adr = 0 and allow_subdir = 0 and allow_saplings = 0 and allow_trees = 0 and aligned_read = 1 + pla + sta adrhi + pla + sta adrlo + } ;override_adr = 1 or allow_subdir = 1 or allow_saplings = 1 or allow_trees = 1 or aligned_read = 0 + + ;set requested size to min(length, requested size) + + !if aligned_read = 0 { + !if bounds_check = 1 { + ldy bleftlo + cpy sizelo + lda blefthi + tax + sbc sizehi + bcs hddcopyblock + sty sizelo + stx sizehi + } ;bounds_check = 1 + +hddcopyblock + ldx sizehi2 + inx + bne + + lda sizehi + sta sizehi2 + lda sizelo + sta sizelo2 ++ + !if allow_aux = 1 { + ldx auxreq + jsr hddsetaux + } ;allow_aux = 1 + !if one_shot = 0 { + !if enable_write = 1 { + lda reqcmd + lsr + bne hddrdwrloop + } ;enable_write = 1 + + ;if offset is non-zero then we return from cache + + lda blkofflo + tax + ora blkoffhi + beq hddrdwrloop + lda sizehi + pha + lda sizelo + pha + lda adrhi + sta scratchhi + lda adrlo + sta scratchlo + stx adrlo +encbufpatch1 + lda #>hddencbuf + clc + adc blkoffhi + sta adrhi + + ;determine bytes left in block + + lda #1 + sbc blkofflo + tay + lda #2 + sbc blkoffhi + tax + + ;set requested size to min(bytes left, requested size) + + cpy sizelo + sbc sizehi + bcs + + sty sizelo + stx sizehi ++ + !if enable_seek = 1 { + lda sizehi + } else { ;enable_seek = 0 + ldy sizehi + } ;enable_seek = 1 + jsr hddcopycache + + ;align to next block and resume read + + lda ldrlo + adc sizelo + sta ldrlo + lda ldrhi + adc sizehi + sta ldrhi + sec + pla + sbc sizelo + sta sizelo + pla + sbc sizehi + sta sizehi + ora sizelo + !if allow_subdir = 1 { + !if no_interrupts = 1 { + clc + bne hddrdwrfilei + } else { ;no_interrupts = 0 + beq hddrdwrdone + jmp hddrdwrfilex + } ;no_interrupts = 1 + } else { ;allow_subdir = 0 + bne hddrdwrfilei + } ;allow_subdir = 1 + !if allow_aux = 0 { + rts + } ;allow_aux = 0 + } ;one_shot = 0 + } else { ;aligned_read = 1 + !if bounds_check = 1 { + lda blefthi + cmp sizehi + bcs + + sta sizehi ++ + } ;bounds_check = 1 + !if allow_aux = 1 { + ldx auxreq + jsr hddsetaux + } ;allow_aux = 1 + } ;aligned_read = 0 +} ;rwts_mode = 0 + +hddrdwrloop +!if (aligned_read + rwts_mode) = 0 { + !if (enable_write + enable_seek) > 0 { + ldx reqcmd + } ;enable_write = 1 or enable_seek = 1 + + ;set read/write size to min(length, $200) + + lda sizehi + cmp #2 + bcs + + pha + + ;redirect read to private buffer for partial copy + + lda adrhi + pha + lda adrlo + pha +encbufpatch2 + lda #>hddencbuf + sta adrhi + !if ver_02 = 1 { + ldx #0 + stx adrlo + !if (enable_write + enable_seek) > 0 { + inx ;ldx #cmdread + } ;enable_write = 1 or enable_seek = 1 + } else { ;ver_02 = 0 + stz adrlo + !if (enable_write + enable_seek) > 0 { + ldx #cmdread + } ;enable_write = 1 or enable_seek = 1 + } ;ver_02 = 1 ++ +} ;aligned_read = 0 and rwts_mode = 0 + +!if allow_trees = 1 { + ;read tree data block only if tree and not read already + ;the indication of having read already is that at least one sapling/seed block entry has been read, too + + !if rwts_mode = 0 { + ldy blkidx + bne + + !if always_trees = 0 { + lda istree + beq + + } ;always_trees = 0 + lda adrhi + pha + lda adrlo + pha + !if ((aligned_read xor 1) + (enable_write or enable_seek)) > 1 { + !if ver_02 = 1 { + txa + pha + } else { ;ver_02 = 0 + phx + } ;ver_02 = 1 + } ;aligned_read = 0 and (enable_write = 1 or enable_seek = 1) + !if aligned_read = 0 { + php + } ;aligned_read = 0 + lda #>hdddirbuf + sta adrhi + sty adrlo + } else { ;rwts_mode = 1 + !if fast_subindex = 0 { + ;read whenever block index changes + + !if mem_swap = 0 { + ldy blkidx + cpy lastblk + } else { ;mem_swap = 1 +blkidx = * + 1 + ldy #$d1 +lastblk = * + 1 + cpy #$d1 + } ;mem_swap = 0 + sty lastblk + php + pla + !if mem_swap = 0 { + ;read whenever tree index changes + + ldy treeidx + cpy lasttree + } else { ;mem_swap = 1 +treeidx = * + 1 + ldy #$d1 +lasttree = * + 1 + cpy #$d1 + } ;mem_swap = 0 + + sty lasttree + bne readtree + pha + plp + beq skipblk + +readtree + } else { ;fast_subindex = 1 + ;read whenever tree index changes + + !if mem_swap = 0 { + ldy treeidx + cpy lasttree + beq hddskiptree + sty lasttree + ldx blkidx + } else { ;mem_swap = 1 +treeidx = * + 1 + ldy #$d1 +lasttree = * + 1 + cpy #$d1 + beq hddskiptree + sty lasttree +blkidx = * + 1 + ldx #$d1 + } ;mem_swap = 0 + inx + stx lastblk + } ;fast_subindex = 0 + } ;rwts_mode = 0 + + ;fetch tree data block and read it + + !if fast_trees = 0 { + ldx treeblklo + lda treeblkhi + jsr hddreaddirsel + ldy treeidx + !if rwts_mode = 0 { + inc treeidx + } ;rwts_mode = 0 + ldx hdddirbuf, y + lda hdddirbuf + 256, y + } else { ;fast_trees = 1 + ldy treeidx + !if rwts_mode = 0 { + inc treeidx + } ;rwts_mode = 0 + ldx hddtreebuf, y + lda hddtreebuf + 256, y + } ;fast_trees = 0 + !if detect_treof = 1 { + bne hddnoteof1 + tay + txa + bne hddfixy1 + !if aligned_read = 0 { + plp + bcs hddfewpop + pla + pla + pla +hddfewpop + } ;aligned_read = 0 + pla + pla + sec + rts +hddfixy1 tya +hddnoteof1 + } ;detect_treof = 1 + + !if fast_trees = 0 { + jsr hddseekrd + } else { ;fast_trees = 1 + jsr hddreaddirsel + } ;fast_trees = 0 + + !if rwts_mode = 0 { + !if aligned_read = 0 { + plp + } ;aligned_read = 0 + !if ((aligned_read xor 1) + (enable_write or enable_seek)) > 1 { + !if ver_02 = 1 { + pla + tax + } else { ;ver_02 = 0 + plx + } ;ver_02 = 1 + } ;aligned_read = 0 and (enable_write = 1 or enable_seek = 1) + pla + sta adrlo + pla + sta adrhi + } ;rwts_mode = 0 +} ;allow_trees = 1 + + ;fetch data block and read/write it + +hddskiptree ldy blkidx +!if rwts_mode = 0 { ++ inc blkidx + !if aligned_read = 0 { + !if enable_seek = 1 { + txa ;cpx #cmdseek, but that would require php at top + beq + + } ;enable_seek = 1 + !if enable_write = 1 { +unrcommand2 = unrelochdd + (* - reloc) + stx command + !if use_smartport = 1 { + nop ;allow replacing "stx command" with "stx pcommand" in extended SmartPort mode + } ;use_smartport = 1 + } ;enable_write = 1 + } ;aligned_read = 0 +} else { ;rwts_mode = 1 + !if fast_subindex = 1 { + lda #>hddencbuf + sta adrhi + + ;read whenever block index changes + + !if mem_swap = 0 { + cpy lastblk + } else { ;mem_swap = 1 +lastblk = * + 1 + cpy #$d1 + } ;mem_swap = 0 + beq skipblk + sty lastblk + } ;fast_subindex = 1 +} ;rwts_mode = 0 + +dirbufpatch7 + ldx hdddirbuf, y +dirbufpatch8 + lda hdddirbuf + 256, y +!if detect_treof = 1 { + bne hddnoteof2 + tay + txa + bne hddfixy2 + sec + rts +hddfixy2 tya +hddnoteof2 +} ;detect_treof = 1 +!if allow_sparse = 0 { + !if rwts_mode = 1 { + !if enable_write = 0 { + jmp hddseekrd + } else { ;enable_write = 1 + ldy reqcmd + jmp hddseekrdwr + } ;enable_write = 0 + } ;rwts_mode = 1 +} else { ;allow_sparse = 1 + pha +dirbufpatch9 + ora hdddirbuf, y + tay + pla + !if rwts_mode = 0 { + dey + iny ;don't affect carry + } else { ;rwts_mode = 1 + !if enable_write = 1 { + cpy #1 + ldy reqcmd + bcs hddseekrdwr + tay + } else { ;enable_write = 0 + dey + iny ;don't affect carry + bne hddseekrd + } ;enable_write = 1 + } ;rwts_mode = 0 +} ;allow_sparse = 0 +!if rwts_mode = 0 { + !if aligned_read = 0 { + php + } ;aligned_read = 0 + !if allow_sparse = 1 { + beq hddissparse + } ;allow_sparse = 1 + !if (aligned_read and (enable_write or enable_seek)) = 1 { + ldy reqcmd + !if enable_seek = 1 { + beq + + } ;enable_seek = 1 + } ;aligned_read = 1 and (enable_write = 1 or enable_seek = 1) + !if enable_write = 1 { + jsr hddseekrdwr + } else { ;enable_write = 0 + jsr hddseekrd + } ;enable_write = 1 + +hddresparse + !if aligned_read = 0 { + plp ++ bcc + + !if bounds_check = 1 { + dec blefthi + dec blefthi + } ;bounds_check = 1 + } ;aligned_read = 0 + inc adrhi + inc adrhi + dec sizehi + dec sizehi + bne hddrdwrloop + !if aligned_read = 0 { + lda sizelo + bne hddrdwrloop + } ;aligned_read = 0 +hddrdwrdone + !if allow_aux = 1 { + ldx #0 +hddsetaux sta CLRAUXRD, x + sta CLRAUXWR, x + } ;allow_aux = 1 + rts +} ;rwts_mode = 0 + +!if allow_sparse = 1 { +hddissparse +- sta (adrlo), y + inc adrhi + sta (adrlo), y + dec adrhi + iny + bne - + !if rwts_mode = 0 { + beq hddresparse + } else { ;rwts_mode = 1 +skipblk rts + } ;rwts_mode = 0 +} ;allow_sparse = 1 +!if rwts_mode = 0 { + !if aligned_read = 0 { + ;cache partial block offset + ++ pla + sta scratchlo + pla + sta scratchhi + pla + !if one_shot = 0 { + sta sizehi + } ;one_shot = 0 + + !if enable_seek = 1 { +hddcopycache + ldy reqcmd + ;cpy #cmdseek + beq ++ + tay + } else { ;enable_seek = 0 + tay +hddcopycache + } ;enable_seek = 1 + beq + + dey +- lda (adrlo), y + sta (scratchlo), y + iny + bne - + inc scratchhi + inc adrhi + bne + +- lda (adrlo), y + sta (scratchlo), y + iny ++ cpy sizelo + bne - +++ + !if one_shot = 0 { + !if bounds_check = 1 { + lda bleftlo + sec + sbc sizelo + sta bleftlo + lda blefthi + sbc sizehi + sta blefthi + } ;bounds_check = 1 + clc + !if enable_seek = 1 { + lda sizelo + } else { ;enable_seek = 0 + tya + } ;enable_seek = 1 + adc blkofflo + sta blkofflo + lda sizehi + adc blkoffhi + and #$fd + sta blkoffhi + bcc hddrdwrdone ;always + } else { ;one_shot = 1 + !if allow_aux = 1 { + beq hddrdwrdone + } else { ;allow_aux = 0 + rts + } ;allow_aux = 1 + } ;one_shot = 0 + } ;aligned_read = 0 +} else { ;rwts_mode = 1 + !if allow_sparse = 0 { +skipblk rts + } ;allow_sparse = 0 +} ;rwts_mode = 0 + +hddreaddirsel +!if ver_02 = 1 { + ldy #0 + sty adrlo + !if might_exist = 1 { + sty status + } ;might_exist = 1 +} else { ;ver_02 = 0 + stz adrlo + !if might_exist = 1 { + stz status + } ;might_exist = 1 +} ;ver_02 = 1 + +!if (enable_floppy + allow_multi) > 1 { + asl reqcmd + lsr reqcmd +} ;enable_floppy = 1 and allow_multi = 1 + +hddreaddirsec +!if allow_trees = 0 { +dirbufpatch10 +hddreaddirsect ldy #>hdddirbuf +} else { ;allow_trees = 1 + ldy #>hdddirbuf +hddreaddirsect +} ;allow_trees = 0 + sty adrhi +hddseekrd ldy #cmdread +!if ((rwts_mode or aligned_read) + enable_write) > 1 { +hddseekrdwr +} ;(rwts_mode = 1 or aligned_read = 1) and enable_write = 1 +unrcommand3 = unrelochdd + (* - reloc) + sty command +!if use_smartport = 1 { + nop ;allow replacing "sty command" with "sty pcommand" in extended SmartPort mode +} ;use_smartport = 1 +!if (aligned_read and enable_write) = 0 { +hddseekrdwr +} ;aligned_read = 0 or enable_write = 0 + +unrbloklo = unrelochdd + (* - reloc) + stx bloklo +!if use_smartport = 1 { + nop ;allow replacing "stx bloklo" with "stx pblock" in extended SmartPort mode +} ;use_smartport = 1 +unrblokhi = unrelochdd + (* - reloc) + sta blokhi +!if use_smartport = 1 { + nop ;allow replacing "sta blokhi" with "sta pblock + 1" in extended SmartPort mode +} ;use_smartport = 1 +unrunit1 = unrelochdd + (* - reloc) + lda #$d1 + sta unit +!if use_smartport = 1 { + nop ;allow replacing "lda #$d1/sta unit" with "lda adrlo/sta paddr" in extended SmartPort mode +} ;use_smartport = 1 +hddwriteimm lda adrhi ;for Trackstar support + pha +!if use_smartport = 1 { + sta paddr + 1 +} ;use_smartport = 1 +!if swap_scrn = 1 { + jsr saveslot +} ;swap_scrn = 1 + +unrentrysei = unrelochdd + (* - reloc) + php + sei +unrentry = unrelochdd + (* - reloc) + jsr $d1d1 +!if use_smartport = 1 { +unrpcommand = unrelochdd + (* - reloc) +pcommand !byte $2c ;hide packet in non-SmartPort mode +unrppacket = unrelochdd + (* - reloc) + !word unrelochdd + (packet - reloc) +} ;use_smartport = 1 + plp +hackstar = unrelochdd + (* - reloc) + pla + sta adrhi ;Trackstar does not preserve adrhi + +!if swap_scrn = 1 { +saveslot + lda #4 + sta $49 + ldx #0 + stx $48 + sta $4a +-- ldy #$78 +- lda ($48), y + pha + lda scrn_array, x +initpatch lda ($48), y + pla + +!ifdef PASS2 { +} else { ;PASS2 + !if * != launchpatch { + !error "launchpatch=",*, ", fix constants.a" + } +} + sta scrn_array, x + inx + tya + eor #$80 + tay + bmi - + iny + bpl - + inc $49 + dec $4a + bne -- +} ;swap_scrn = 1 + rts + +fetchscratch + lda (scratchlo), y + tax + iny + lda (scratchlo), y + rts + +!if use_smartport = 1 { +unrpacket = unrelochdd + (* - reloc) +packet !byte 3 +unrunit2 = unrelochdd + (* - reloc) + !byte 0 +paddr !word readbuff + $200 +pblock !byte 2, 0, 0 +} ;use_smartport = 1 + +!if (rwts_mode + allow_multi) > 1 { +vollist_b +!byte D1S1 +vollist_e +} ;rwts_mode = 1 and allow_multi = 1 +hddcodeend +!if swap_scrn = 1 { +scrn_array + !if swap_zp = 1 { +zp_array = scrn_array + 64 +hdddataend = zp_array + last_zp - first_zp + } else { ;swap_zp = 0 +hdddataend = scrn_array + 64 + } ;swap_zp = 1 +} else { ;swap_scrn = 0 + !if swap_zp = 1 { +zp_array +hdddataend = zp_array + last_zp - first_zp + } else { ;swap_zp = 0 +hdddataend + } ;swap_zp = 1 +} ;swap_scrn = 1 +} ;reloc + +;[music] you can't touch this [music] +;math magic to determine ideal loading address, and information dump +!ifdef PASS2 { +} else { ;PASS2 not defined + !if enable_floppy = 1 { + !if reloc < $c000 { + !if ((dataend + $ff) & -256) > $c000 { + !serious "initial reloc too high, adjust to ", $c000 - (((dataend + $ff) & -256) - reloc) + } ;dataend + !if load_high = 1 { + !if ((dataend + $ff) & -256) != $c000 { + !warn "initial reloc too low, adjust to ", $c000 - (((dataend + $ff) & -256) - reloc) + } ;dataend + dirbuf = reloc - $200 + !if ((aligned_read xor 1) + enable_write) > 0 { + encbuf = dirbuf - $200 + } ;aligned_read = 0 or enable_write = 1 + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + treebuf = encbuf - $200 + } else { ;aligned_read = 1 and enable_write = 0 + treebuf = dirbuf - $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + treebuf = dirbuf + } ;fast_trees + } ;allow_trees + } else { ;load_high = 0 + !pseudopc ((dataend + $ff) & -256) { + dirbuf = * + !if (dirbuf + $200) > $c000 { + !if dirbuf < $d000 { + !set dirbuf = reloc - $200 + } ;dirbuf + } ;dirbuf + } + !if ((aligned_read xor 1) + enable_write) > 0 { + !if fast_subindex = 0 { + encbuf = dirbuf ;writes come from cache + } else { ;fast_subindex = 1 + !if dirbuf < reloc { + encbuf = dirbuf - $200 + } else { ;dirbuf + encbuf = dirbuf + $200 + !if (encbuf + $200) > $c000 { + !if encbuf < $d000 { + !set encbuf = reloc - $200 + } ;encbuf + } ;encbuf + } ;dirbuf + } ;fast_subindex + } ;aligned_read = 0 or enable_write = 1 + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + rwts_mode) > 0 { + !if encbuf < reloc { + treebuf = encbuf - $200 + } else { ;encbuf + treebuf = encbuf + $200 + !if (treebuf + $200) > $c000 { + !if treebuf < $d000 { + !set treebuf = reloc - $200 + } ;treebuf + } ;treebuf + } ;encbuf + } else { ;aligned_read = 1 and rwts_mode = 0 + !if dirbuf < reloc { + treebuf = dirbuf - $200 + } else { ;dirbuf + treebuf = dirbuf + $200 + !if (treebuf + $200) > $c000 { + !if treebuf < $d000 { + !set treebuf = reloc - $200 + } ;treebuf + } ;treebuf + } ;dirbuf + } ;aligned_read = 0 or rwts_mode = 1 + } else { ;fast_trees = 0 + treebuf = dirbuf + } ;fast_trees + } ;allow_trees + } ;load_high + } else { ;reloc > $c000 + !if ((dataend + $ff) & -256) != 0 { + !if ((dataend + $ff) & -256) < reloc { + !serious "initial reloc too high, adjust to ", (0 - (((dataend + $ff) & -256) - reloc)) & $ffff + } ;dataend + } ;dataend + !if load_high = 1 { + !if (((dataend + $ff) & -256) & $ffff) != 0 { + !warn "initial reloc too low, adjust to ", (0 - (((dataend + $ff) & -256) - reloc)) & $ffff + } ;dataend + dirbuf = reloc - $200 + !if aligned_read = 0 { + encbuf = dirbuf - $200 + } ;aligned_read + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + treebuf = encbuf - $200 + } else { ;aligned_read = 1 and enable_write = 0 + treebuf = dirbuf - $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + treebuf = dirbuf + } ;fast_trees + } ;allow_trees + } else { ;load_high = 0 + !pseudopc ((dataend + $ff) & -256) { + dirbuf = * + } + !if aligned_read = 0 { + encbuf = dirbuf + $200 + } ;aligned_read + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + treebuf = encbuf + $200 + } else { ;aligned_read = 1 and enable_write = 0 + treebuf = dirbuf + $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + treebuf = dirbuf + } ;fast_trees + } ;allow_trees + } ;load_high + } ;reloc + !if verbose_info = 1 { + !warn "floppy code: ", reloc, "-", codeend - 1 + !warn "floppy data: ", bit2tbl, "-", dataend - 1 + !warn "floppy dirbuf: ", dirbuf, "-", dirbuf + $1ff + !if aligned_read = 0 { + !warn "floppy encbuf: ", encbuf, "-", encbuf + $1ff + } ;aligned_read + !if allow_trees = 1 { + !warn "floppy treebuf: ", treebuf, "-", treebuf + $1ff + } ;allow_trees + !warn "floppy driver start: ", unrelocdsk - init + } ;verbose_info + } ;enable_floppy + !if reloc < $c000 { + !if ((hdddataend + $ff) & -256) > $c000 { + !serious "initial reloc too high, adjust to ", $c000 - (((hdddataend + $ff) & -256) - reloc) + } ;hdddataend + !if load_high = 1 { + !if ((hdddataend + $ff) & -256) != $c000 { + !warn "initial reloc too low, adjust to ", $c000 - (((hdddataend + $ff) & -256) - reloc) + } ;hdddataend + hdddirbuf = reloc - $200 + !if aligned_read = 0 { + hddencbuf = hdddirbuf - $200 + } ;aligned_read + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + hddtreebuf = hddencbuf - $200 + } else { ;aligned_read = 1 and enable_write = 0 + hddtreebuf = hdddirbuf - $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + hddtreebuf = hdddirbuf + } ;fast_trees + } ;allow_trees + } else { ;load_high = 0 + !pseudopc ((hdddataend + $ff) & -256) { + hdddirbuf = * + !if (hdddirbuf + $200) > $c000 { + !if hdddirbuf < $d000 { + !set hdddirbuf = reloc - $200 + } ;hdddirbuf + } ;hdddirbuf + } + !if ((aligned_read xor 1) + rwts_mode) > 0 { + !if fast_subindex = 0 { + hddencbuf = hdddirbuf ;writes come from cache + } else { ;fast_subindex = 1 + !if hdddirbuf < reloc { + hddencbuf = hdddirbuf - $200 + } else { ;hdddirbuf + hddencbuf = hdddirbuf + $200 + !if (hddencbuf + $200) > $c000 { + !if hddencbuf < $d000 { + !set hddencbuf = reloc - $200 + } ;hddencbuf + } ;hddencbuf + } ;hdddirbuf + } ;fast_subindex + } ;aligned_read = 0 or rwts_mode = 1 + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + rwts_mode) > 0 { + !if hddencbuf < reloc { + hddtreebuf = hddencbuf - $200 + } else { ;hddencbuf + hddtreebuf = hddencbuf + $200 + !if (hddtreebuf + $200) > $c000 { + !if hddtreebuf < $d000 { + !set hddtreebuf = reloc - $200 + } ;hddtreebuf + } ;hddtreebuf + } ;hddencbuf + } else { ;aligned_read = 1 + !if hdddirbuf < reloc { + hddtreebuf = hdddirbuf - $200 + } else { ;hdddirbuf + hddtreebuf = hdddirbuf + $200 + !if (hddtreebuf + $200) > $c000 { + !if hddtreebuf < $d000 { + !set hddtreebuf = reloc - $200 + } ;hddtreebuf + } ;hddtreebuf + } ;hdddirbuf + } ;aligned_read + } else { ;fast_trees = 0 + hddtreebuf = hdddirbuf + } ;fast_trees + } ;allow_trees + } ;load_high + } else { ;reloc > $c000 + !if ((hdddataend + $ff) & -256) != 0 { + !if ((hdddataend + $ff) & -256) < reloc { + !serious "initial reloc too high, adjust to ", (0 - (((hdddataend + $ff) & -256) - reloc)) & $ffff + } ;hdddataend + } ;hdddataend + !if load_high = 1 { + !if enable_floppy = 0 { + !if (((hdddataend + $ff) & -256) & $ffff) != 0 { + !warn "initial reloc too low, adjust to ", (0 - (((hdddataend + $ff) & -256) - reloc)) & $ffff + } ;hdddataend + } ;enable_floppy + hdddirbuf = reloc - $200 + !if aligned_read = 0 { + hddencbuf = hdddirbuf - $200 + } ;aligned_read + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + hddtreebuf = hddencbuf - $200 + } else { ;aligned_read = 1 and enable_write = 0 + hddtreebuf = hdddirbuf - $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + hddtreebuf = hdddirbuf + } ;fast_trees + } ;allow_trees + } else { ;load_high = 0 + !pseudopc ((hdddataend + $ff) & -256) { + hdddirbuf = $d200 + } + !if aligned_read = 0 { + hddencbuf = hdddirbuf - $200 + } ;aligned_read + !if allow_trees = 1 { + !if fast_trees = 1 { + !if ((aligned_read xor 1) + enable_write) > 0 { + hddtreebuf = hddencbuf + $200 + } else { ;aligned_read = 1 and enable_write = 0 + hddtreebuf = hdddirbuf + $200 + } ;aligned_read = 0 or enable_write = 1 + } else { ;fast_trees = 0 + hddtreebuf = hdddirbuf + } ;fast_trees + } ;allow_trees + } ;load_high + } ;reloc + !if verbose_info = 1 { + !warn "hdd code: ", reloc, "-", hddcodeend - 1 + !if hddcodeend != hdddataend { + !warn "hdd data: ", hddcodeend, "-", hdddataend - 1 + } + !warn "hdd dirbuf: ", hdddirbuf, "-", hdddirbuf + $1ff + !if ((aligned_read xor 1) + rwts_mode) > 0 { + !warn "hdd encbuf: ", hddencbuf, "-", hddencbuf + $1ff + } ;aligned_read = 0 or rwts_mode = 1 + !if allow_trees = 1 { + !warn "hdd treebuf: ", hddtreebuf, "-", hddtreebuf + $1ff + } ;allow_trees + !warn "hdd driver start: ", unrelochdd - init + !if (one_page + enable_floppy) = 0 { + !if ((hddcodeend - reloc) < $100) { + !warn "one_page can be enabled, code is small enough" + } ;hddcodeend + } ;not one_page and not enable_floppy + } ;verbose_info +} ;PASS2 + +readbuff = $800 +!byte $D3,$C1,$CE,$A0,$C9,$CE,$C3,$AE diff --git a/src/textrank.a b/src/textrank.a new file mode 100644 index 0000000..61ebe76 --- /dev/null +++ b/src/textrank.a @@ -0,0 +1,218 @@ +;license:MIT +;(c) 2018-2020 by 4am & qkumba +; +; text rank - an implementation of the Quicksilver search rank algorithm +; +; Public functions +; - BuildSearchStore +; - ResetTextRank +; - TextRankCallback (as okvs_iter_values callback) +; +; Public variables +; - InputLength ; [byte] number of characters typed in search mode +; - InputBuffer ; [25 bytes] characters typed in search mode +; +; Zero page variables +; - SelectedIndex ; [byte] index in gSearchStore of currently selected game in search mode +; - MatchCount ; [byte] number of games that match InputBuffer +; - BestMatchScore ; [byte] raw ranking score (0-100) of current best match (updated during TextRankCallback) +; - BestMatchIndex ; [byte] index in gSearchStore of current best match (updated during TextRankCallback) + +MaxInputLength = 26 +InputLength + !byte 0 +InputBuffer + !text " " + +;------------------------------------------------------------------------------ +; BuildSearchStore +; Build a temporary data structure in main memory to support search UI. +; Now that gGamesListStore no longer contains full game display names, we call +; this to build a store that does. It's built in main memory and will be +; clobbered as soon as we enter attract mode (mega- or mini-), run a game, +; run a demo, or sneeze. +; +; in: none +; out: gSearchStore populated +;------------------------------------------------------------------------------ +BuildSearchStore + jsr SwitchToBank2 + jsr EnableAcceleratorAndSwitchToBank1 + +LDADDR gSearchStore + jsr okvs_init + + jsr okvs_iter + !word gGamesListStore + !word @callback + + jsr SwitchToBank2 + jmp DisableAcceleratorAndSwitchToBank1 +@callback +; callback called by okvs_iter on gGamesListStore + +; in: A/Y contains address of filename +; $WINDEX contains 0-based index of the current record in gGamesListStore (word) +; out: all registers and flags clobbered + +ST16 @key + jsr GetGameDisplayName + +ST16 @value +@append + jsr okvs_append + !word gSearchStore +@key !word $FDFD ; SMC +@value !word $FDFD ; SMC + !byte 0 + rts + +;------------------------------------------------------------------------------ +; ResetTextRank +; reset the Match variables to allow re-scanning (e.g. because of backspace) + +; in: nothing +; out: X, MatchCount, BestMatchScore, BestMatchIndex zeroed +;------------------------------------------------------------------------------ +ResetTextRank + ldx #0 + stx MatchCount + stx BestMatchScore + dex + stx BestMatchIndex + stx BestMatchIndex+1 + rts + +;------------------------------------------------------------------------------ +; TextRankCallback +; callback called by okvs_iter_values on gSearchStore +; to calculate a ranking score for a single game display name +; against the current InputBuffer + +; in: A/Y contains address of game display name +; $WINDEX contains 0-based index of the current record in gSearchStore (word) +; out: all registers and flags clobbered +; MatchCount possibly incremented (if this game was a match at all) +; BestMatchScore and BestMatchIndex possibly updated (if this game +; was the best match so far) +;------------------------------------------------------------------------------ +TextRankCallback + +ST16 zpstring ; A/Y = address of this game display name + +LDADDR InputLength + +ST16 zpword + ldy #0 + lda (zpstring),y + tax + dex + cpx InputLength + bcc ++ + sta gamelength + sty runningscore + sty runningscore+1 + iny + sty startat +- sty i + lda (zpword),y + jsr tolower + sta tmp + ldy startat +-- lda (zpstring),y + jsr tolower + cmp tmp + beq + + cpy gamelength + iny + bcc -- +++ rts ; no match :( ++ ldx #80 + cpy startat + beq + + ldx #10 + cpy #1 + beq + + dey + lda (zpstring),y + iny + cmp #' ' + bne + + ldx #90 ++ txa + clc + adc runningscore + sta runningscore + bcc + + inc runningscore+1 ++ tya + ldy i + cpy InputLength + bcs + + iny + sta startat + inc startat + cmp gamelength + bcc - + rts ; no match :( ++ lda runningscore + ldx runningscore+1 + ldy gamelength + jsr @div + sta tmp + lda runningscore + ldx runningscore+1 + ldy InputLength + jsr @div + clc + adc tmp + lsr + adc #0 ; round fractions up + pha + ldy #1 + lda (zpstring),y + jsr tolower + sta firstletter + pla + ldx InputBuffer + cpx firstletter + bne + + cmp #85 + bcs + + adc #15 ++ cmp BestMatchScore + bcc + + beq + + sta BestMatchScore + lda WINDEX + sta BestMatchIndex + lda WINDEX+1 + sta BestMatchIndex+1 + inc MatchCount ++ rts + +@div + sta num1 + stx num1+1 + sty num2 + lda #0 + sta remainder + sta remainder+1 + ldx #16 +- asl num1 + rol num1+1 + rol remainder + rol remainder+1 + lda remainder + sec + sbc num2 + bcc + + sta remainder + dec remainder+1 + inc num1 ++ dex + bne - + lda num1 + rts + +tolower + cmp #$41 + bcc + + cmp #$5B + bcs + + ora #$20 ++ rts diff --git a/src/ui.animation.a b/src/ui.animation.a new file mode 100644 index 0000000..67b3caa --- /dev/null +++ b/src/ui.animation.a @@ -0,0 +1,75 @@ +;License:MIT +;(c) 2018-2020 by 4am +; +; functions for animated title screens +; +; Public functions: +; - MaybeAnimateTitle +; + + ; /!\ execution falls through from ui.search.mode/FindMatchingTitle +;------------------------------------------------------------------------------ +; MaybeAnimateTitle +; slow down to 1 Mhz (always), then check if there is an animation for the +; title screenshot we just displayed, and if so, load it and call it +; +; in: none +; out: C clear +; all other flags clobbered +; all registers clobbered +;------------------------------------------------------------------------------ +MaybeAnimateTitle + jsr SwitchToBank2 + jsr DisableAcceleratorAndSwitchToBank1 + + lda #$3F + ldy OffscreenPage + bne + + eor #$60 ++ sta DEST+1 + and #$60 + sta PageFrom+2 + eor #$60 + tax + lda #$FD + sta DEST + ldy #0 + lda (DEST),y ; see if there is a hidden JMP to an + cmp #$4C ; animation routine for this screen + ; at +$1FFD (after the graphics data, + ; in the last 3 bytes of a $2000 byte + ; file -- this area part of a 'screen + ; hole' and is not displayed on screen) + bne @exit ; if not, we're done here + txa + jsr CopyHGR + + ; load the animation routine, which is stored in a subdirectory by filename + jsr GetGameToLaunch + +ST16 + + jsr LoadFile + !word kAnimatedTitleDirectory ++ !word $FDFD + !word 0 + + ldx #5 ; copy prelaunch code +- lda @titleAnimPrelaunch,x + sta $106,x + dex + bpl - + + bit $c050 ; turn on graphics mode (Home set text mode) + jsr Launch ; execute the animation + + jsr BuildSearchStore + jsr ResyncPage ; we don't know which HGR page is showing + ; when the animation returns, so resync + ; the current one with our OffscreenPage + ; variable + +@exit clc ; tell caller not to refresh screen + rts + +@titleAnimPrelaunch ; this is executed from $106/main by |Launch| + bit $C082 + jmp (DEST) diff --git a/src/ui.attract.dhgr.a b/src/ui.attract.dhgr.a new file mode 100644 index 0000000..29306f7 --- /dev/null +++ b/src/ui.attract.dhgr.a @@ -0,0 +1,332 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Double hi-res slideshows +; +; Public functions +; - DHGRTitleSlideshow +; - DHGRActionSlideshow +; - DHGRSingle +; - BlankHGR +; - HGRMode +; - GRMode +; - ForceHGRMode +; - DrawGameTitleInActionSlideshow +; - RedrawForDHGR +; + +;------------------------------------------------------------------------------ +; DHGRTitleSlideshow +; execute a slideshow of double hi-res title screenshots +; +; safe to call if machine only has 64K (does nothing and exits) +; +; in: none +; out: everything clobbered +; graphics mode reset to display hi-res screen, which is blank +;------------------------------------------------------------------------------ +DHGRTitleSlideshow + bit MachineStatus ; only run DHGR slideshow if we have 128K + bvc DHGRRTS + jsr LoadDHGRTransition ; load transition effect code at $6000 + jsr BlankDHGR ; switch to DHGR mode with initial blank screen + jsr okvs_iter ; cycle through all listed DHGR files + !word gSlideshowStore + !word DHGRTitleCallback ; address of callback (called on each file) + beq BlankHGR ; switch back to HGR mode with initial blank screen on exit + ; (always branches because Z=1 on exit of okvs_iter) + +;------------------------------------------------------------------------------ +; DHGRActionSlideshow +; execute a slideshow of double hi-res action screenshots +; +; safe to call if machine only has 64K (does nothing and exits) +; +; in: none +; out: everything clobbered +; graphics mode reset to display hi-res screen, which is blank +;------------------------------------------------------------------------------ +DHGRActionSlideshow + bit MachineStatus ; only run DHGR slideshow if we have 128K + bvc DHGRRTS + jsr LoadDHGRTransition ; load transition effect code at $6000 + jsr BlankDHGR ; switch to DHGR mode with initial blank screen + jsr okvs_iter ; cycle through all listed DHGR files + !word gSlideshowStore + !word DHGRActionCallback ; address of callback (called on each file) + beq BlankHGR ; switch back to HGR mode with initial blank screen on exit + ; (always branches because Z=1 on exit of okvs_iter) + +;------------------------------------------------------------------------------ +; DHGRSingle +; display a single double hi-res screenshot, with transition effect +; +; safe to call if machine only has 64K (does nothing and exits) +; +; in: none +; out: everything clobbered +; graphics mode reset to display hi-res screen, which is blank +;------------------------------------------------------------------------------ +DHGRSingle + bit MachineStatus ; only show DHGR screenshots if we have 128K + bvc DHGRRTS + +ST16 @fname + jsr BlankDHGR ; switch to DHGR mode with initial blank screen + jsr LoadAuxFile ; load compressed DHGR screenshot at aux $3FF8 + !word kRootDirectory +@fname !word $FDFD ; SMC + !word $3FF8 + jsr DecompressDHGR + jsr LoadDHGRTransition ; load transition effect code at $6000 + jsr ExecuteTransitionAt6000AndWait + ; switch back to HGR mode with initial blank screen on exit + ; /!\ execution falls through here to BlankHGR +;------------------------------------------------------------------------------ +; BlankHGR +; clear and show HGR page 1 without flickering +; +; in: none +; out: text page clobbered (but screen holes preserved) +; A/X/Y=0 (guaranteed by ClearHGR1) +; $2000..$3FFF cleared +;------------------------------------------------------------------------------ +BlankHGR + jsr Home + jsr ClearHGR1 ; clear hi-res screen 1 + bit PAGE1 ; show hi-res screen 1 (now blank) + lda #1 + sta OffscreenPage + ; /!\ execution falls through here to HGRMode +;------------------------------------------------------------------------------ +; HGRMode / GRMode +; twiddles softswitches to set (H)GR mode (does not set page 1 or 2) +; +; in: none +; out: all registers preserved +;------------------------------------------------------------------------------ +HGRMode + bit $C057 +GRMode + bit $C052 + bit $C050 +DHGRRTS rts + +;------------------------------------------------------------------------------ +; ForceHGRMode +; if machine is in DHGR mode, switch it back to HGR mode +; otherwise do nothing +; +; in: none +; out: see BlankHGR +;------------------------------------------------------------------------------ +ForceHGRMode +gMachineInDHGRMode=*+1 + lda #$00 ; SMC + bne BlankHGR + beq DHGRRTS + +;------------------------------------------------------------------------------ +; LoadDHGRTransition [private] +; looks up name of next DHGR transition effect in DFX.CONF and loads that file +; at $6000 + +; in: gDFXStore has been initialized +; gGlobalPrefsStore has been initialized +; out: all registers and flags clobbered +; $6000..$BFFF/main contains transition effect code +;------------------------------------------------------------------------------ +LoadDHGRTransition + jsr LoadFile ; load DHGR transition effects list into $8000 + !word kRootDirectory + !word kDFXConfFile +- !word $8000 + jsr ParseKeyValueList ; parse DHGR transition effects list into $6000 + !word gDFXStore + !word - + !byte 0 + + jsr pref_get ; get DHGR transition effect from prefs + !word kNextDFX + !word gDFXStore + +ST16 ++ ; A/Y = filename (don't load file yet) + ; $WINDEX = index of the transition in DFX store + +LDADDR gDFXStore + jsr okvs_next ; get transition after this one + +ST16 + + + jsr pref_set ; update prefs store and save to disk + !word kNextDFX ++ !word $FDFD ; SMC + + jsr LoadFile ; now load transition effect code into $6000 + !word kFXDirectory +++ !word $FDFD ; SMC + !word $6000 + rts + +;------------------------------------------------------------------------------ +; DHGRTitleCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single DHGR title screenshot + +; in: A/Y contains address of filename (name only, path is always /TITLE.DHGR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +; $2000..$5FFF/aux clobbered +;------------------------------------------------------------------------------ +DHGRTitleCallback + bit KBD + bmi DHGRRTS + + +ST16 + + + jsr FindGame + ; if game is not found (C will be set here), it means it can't be played on + ; this machine due to memory or joystick requirements, so we don't display + ; it in slideshows + bcs DHGRRTS + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + ; load DHGR screenshot at $4000/main and $4000/aux + jsr LoadDHRFile + !word kDHGRTitleDirectory ++ !word $FDFD + + jmp ExecuteTransitionAt6000AndWait + +;------------------------------------------------------------------------------ +; DHGRActionCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single DHGR action screenshot + +; in: A/Y contains address of filename (name only, path is always /ACTION.DHGR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +; $2000..$5FFF/aux clobbered +;------------------------------------------------------------------------------ +DHGRActionCallback + bit KBD + bmi DHGRRTS + + +ST16 + + + jsr FindGameInActionSlideshow + ; if game name is not found (C will be set here), it means the game + ; can't be played due to memory or joystick requirements, so we hide + ; it from slideshows + bcs DHGRRTS + +ST16 SAVE ; (SAVE) -> game display name + game info bitfield + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + jsr LoadAuxFile ; load compressed DHGR screenshot at aux $3FF8 + !word kDHGRActionDirectory ++ !word $FDFD + !word $3FF8 + jsr DecompressDHGR + + lda #$EA ; NOP + +HIDE_NEXT_2_BYTES + ; /!\ execution falls through here to DrawGameTitleInActionSlideshowHGR +;------------------------------------------------------------------------------ +; DrawGameTitleInActionSlideshow +; draw the game title in the lower left corner of the screen +; +; /!\ exits via ExecuteTransitionAt6000AndWait, and the transition code must +; already be loaded at $6000 +; +; in: none +; out: exits via ExecuteTransitionAt6000AndWait +;------------------------------------------------------------------------------ +DrawGameTitleInActionSlideshow + lda #$60 ; RTS + sta @fallthroughForDHGR + + ; display game name in the bottom-left corner + lda #22 + sta VTAB + lda #0 ; solid horizontal bar character + jsr @resetline + lda (SAVE),y ; (SAVE) -> game display name, Y = 0, so A = display length + 1 + clc + adc #$02 + sta gPathname + lda #7 ; top-right rounded corner character + jsr @drawline + + inc VTAB + lda #" " + jsr @resetline + lda (SAVE),y ; A = display length + 1 + tay + dey +- lda (SAVE),y + sta gPathname+1,y + dey + bne - + lda #3 ; solid vertical bar character + jsr @drawline + + jmp ExecuteTransitionAt6000AndWait +@resetline + ldy #40 +- sta gPathname,y + dey + bne - + sty HTAB + rts +@drawline + ldy gPathname + sta gPathname,y + +LDADDR gPathname + sec + jsr DrawString +@fallthroughForDHGR + nop ; SMC + ; /!\ execution sometimes falls through here to RedrawForDHGR + +;------------------------------------------------------------------------------ +; RedrawForDHGR +; After drawing text on HGR screen, this will transform the low-level bytes +; to display properly on the DHGR screen. +; +; /!\ must be called immediately after calling one of the font drawing routines +; (Draw40Chars, DrawCenteredString, DrawString, DrawBuffer) +; +; in: gPathname contains number of bytes to transform +; DBIRow0/LC2 contains address of first byte of first row to transform +; (this will be true if you just called DrawBufferInternal or +; something that calls it, see above) +; out: clobbers zero page $00,$01,$02,$26,$27,$F7 +;------------------------------------------------------------------------------ +RedrawForDHGR + jsr SwitchToBank2 + +LD16 DBIRow0+1 + +ST16 $26 + lda #8 + sta i +-- ldy gPathname + dey +- lda ($26),y + +HGR_BYTE_TO_DHGR_BYTES + sta ($26),y + txa + sta WRITEAUXMEM + sta ($26),y + sta WRITEMAINMEM + dey + bpl - + lda $27 + clc + adc #$04 + sta $27 + dec i + bne -- + jmp SwitchToBank1 diff --git a/src/ui.attract.gr.a b/src/ui.attract.gr.a new file mode 100644 index 0000000..bfdbeff --- /dev/null +++ b/src/ui.attract.gr.a @@ -0,0 +1,112 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; GR action slideshows +; +; Public functions +; - GRActionSlideshow +; - GRSingle +; + +;------------------------------------------------------------------------------ +; GRActionSlideshow +; display a slideshow of lo-res action screenshots +; +; in: none +; out: everything clobbered +; graphics mode set to display hi-res screen +;------------------------------------------------------------------------------ +GRActionSlideshow + jsr LoadGRTransition ; load transition effect code at $6000 + jsr BlankGR ; switch GR mode with initial blank screen + jsr okvs_iter ; cycle through all listed GR files + !word gSlideshowStore + !word GRActionCallback ; address of callback (called on each file) + jmp BlankHGR ; switch back to HGR mode with initial blank screen on exit + +;------------------------------------------------------------------------------ +; GRSingle +; display a single lo-res screenshot, with transition effect +; +; in: none +; out: everything clobbered +; graphics mode set to display hi-res screen +;------------------------------------------------------------------------------ +GRSingle + +ST16 @fname + jsr BlankGR ; switch to GR mode with initial blank screen + jsr LoadFile ; load GR screenshot into $6000 + !word kRootDirectory +@fname !word $FDFD ; SMC + !word $6000 + jsr LoadGRTransition ; load transition effect code at $6400 + jsr ExecuteTransitionAt6400AndWait + jmp BlankHGR ; switch back to HGR mode with initial blank screen on exit + +;------------------------------------------------------------------------------ +; BlankGR [private] +; clear and show GR page 1 without flickering +; +; in: none +; out: text page clobbered +; graphics mode set to display lo-res screen +;------------------------------------------------------------------------------ +BlankGR + ldy #$2C ; BIT + sty PageFrom + ldx #$04 + stx PageTo+2 + lda #0 + jsr ClearGR + bit PAGE1 + bit $C056 ; set GR mode + jmp GRMode + +;------------------------------------------------------------------------------ +; LoadGRTransition [private] +; +; in: none +; out: all registers and flags clobbered +; $6400..$BFFF/main contains transition effect code (probably not all +; of that, but no promises) +;------------------------------------------------------------------------------ +LoadGRTransition + jsr LoadFile + !word kFXDirectory + !word kGRFizzleFile + !word $6400 +GRRTS rts + +;------------------------------------------------------------------------------ +; GRActionCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single GR action screenshot + +; in: A/Y contains address of filename (name only, path is always /ACTION.GR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; gGamesListStore must be initialized +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +;------------------------------------------------------------------------------ +GRActionCallback + bit KBD + bmi GRRTS + + +ST16 + + + jsr FindGameInActionSlideshow + ; if game name is not found (C will be set here), it means the game + ; can't be played due to memory or joystick requirements, so we hide + ; it from slideshows + bcs GRRTS + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + jsr LoadFile ; load GR screenshot into $6000 + !word kGRActionDirectory ++ !word $FDFD ; SMC + !word $6000 + + jmp ExecuteTransitionAt6400AndWait diff --git a/src/ui.attract.hgr.a b/src/ui.attract.hgr.a new file mode 100644 index 0000000..b177dd6 --- /dev/null +++ b/src/ui.attract.hgr.a @@ -0,0 +1,166 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; HGR title and action slideshows +; +; Public functions +; - HGRTitleSlideshow +; - HGRActionSlideshow +; - HGRSingle +; + +;------------------------------------------------------------------------------ +; HGRTitleSlideshow +; execute a slideshow of hi-res title screenshots +; +; in: none +; out: everything clobbered +; graphics mode still displaying hi-res screen with last picture visible +;------------------------------------------------------------------------------ +HGRTitleSlideshow + jsr LoadHGRTransition ; load transition effect code at $6000 + jsr okvs_iter ; cycle through all listed HGR files + !word gSlideshowStore + !word HGRTitleCallback ; address of callback (called on each file) + rts ; exit with last picture still visible + +;------------------------------------------------------------------------------ +; HGRActionSlideshow +; execute a slideshow of hi-res action screenshots +; +; in: none +; out: everything clobbered +; graphics mode still displaying hi-res screen with last picture visible +;------------------------------------------------------------------------------ +HGRActionSlideshow + jsr LoadHGRTransition ; load transition effect code at $6000 + jsr okvs_iter ; cycle through all listed HGR files + !word gSlideshowStore + !word HGRActionCallback ; address of callback (called on each file) + rts ; exit with last picture still visible + +;------------------------------------------------------------------------------ +; HGRSingle +; display a single hi-res screenshot, with transition effect +; +; in: none +; out: everything clobbered +; graphics mode still displaying hi-res screen with last picture visible +;------------------------------------------------------------------------------ +HGRSingle + +ST16 @fname + jsr LoadFile ; load compressed HGR screenshot at $3FF8 + !word kRootDirectory +@fname !word $FDFD ; SMC + !word $3FF8 + jsr DecompressHGR + jsr LoadHGRTransition ; load transition effect code at $6000 + jmp ExecuteTransitionAt6000AndWait + +;------------------------------------------------------------------------------ +; LoadHGRTransition [private] +; looks up name of next HGR transition effect in FX.CONF and loads that file +; at $6000 + +; in: gGlobalPrefsStore has been initialized +; out: all registers and flags clobbered +; $6000..$BFFF contains transition effect code +;------------------------------------------------------------------------------ +LoadHGRTransition + jsr LoadFile ; load HGR transition effects list into $8000 + !word kRootDirectory + !word kFXConfFile +- !word $8000 + jsr ParseKeyValueList ; parse HGR transition effects list into $6000 + !word gFXStore + !word - + !byte 0 + + jsr pref_get ; get HGR transition effect from prefs + !word kNextFX + !word gFXStore + +ST16 ++ ; A/Y = filename (don't load file yet) + ; $WINDEX = index of the transition in FX store + +LDADDR gFXStore + jsr okvs_next ; get transition after this one + +ST16 + + + jsr pref_set ; update prefs store and save to disk + !word kNextFX ++ !word $FDFD ; SMC + + jsr LoadFile ; now load transition effect code into $6000 + !word kFXDirectory +++ !word $FDFD ; SMC + !word $6000 +HGRRTS rts + +;------------------------------------------------------------------------------ +; HGRTitleCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single HGR title screenshot + +; in: A/Y contains address of filename (name only, path is always /TITLE.HGR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +;------------------------------------------------------------------------------ +HGRTitleCallback + bit KBD + bmi HGRRTS + + +ST16 + + + jsr FindGame + ; if game is not found (C will be set here), it means it can't be played on + ; this machine due to memory or joystick requirements, so we don't display + ; it in slideshows + bcs HGRRTS + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + jsr LoadFile ; load HGR screenshot at $4000 + !word kHGRTitleDirectory ++ !word $FDFD ; SMC + !word $4000 + + jmp ExecuteTransitionAt6000AndWait + +;------------------------------------------------------------------------------ +; HGRActionCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single HGR action screenshot + +; in: A/Y contains address of filename (name only, path is always /ACTION.HGR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; gGamesListStore must be initialized +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +;------------------------------------------------------------------------------ +HGRActionCallback + bit KBD + bmi HGRRTS + + +ST16 + + + jsr FindGameInActionSlideshow + ; if game name is not found (C will be set here), it means the game + ; can't be played due to memory or joystick requirements, so we hide + ; it from slideshows + bcs HGRRTS + + ; found the game + +ST16 SAVE ; (SAVE) -> game display name + game info bitfield + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + jsr LoadFile ; load compressed HGR screenshot at $3FF8 + !word kHGRActionDirectory ++ !word $FDFD ; SMC + !word $3FF8 + jsr DecompressHGR + jmp DrawGameTitleInActionSlideshow diff --git a/src/ui.attract.mode.a b/src/ui.attract.mode.a new file mode 100644 index 0000000..923bb0b --- /dev/null +++ b/src/ui.attract.mode.a @@ -0,0 +1,227 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; Attract Mode - cycle through slideshows and self-running demos +; +; Public functions +; - MegaAttractMode +; - MiniAttractMode +; - RunAttractModule + +;------------------------------------------------------------------------------ +; MegaAttractMode +; main entry point for Mega Attract Mode, which endlessly cycles through +; modules listed in ATTRACT.CONF to display title pages, action screenshots, +; super hi-res box art (on supporting platforms), and self-running game demos +; +; in: gGlobalPrefsStore must be initialized +; out: never returns to caller (may JMP to other major modes) +;------------------------------------------------------------------------------ +MegaAttractMode + jsr SwitchToBank1 + ldx #$FF + txs + + jsr BlankHGR ; switch to HGR page 1 (once cleared) + + jsr LoadFile ; load attract-mode configuration file into $8000 + !word kRootDirectory + !word kAttractModeConfFile +- !word $8000 + jsr ParseKeyValueList ; parse attract-mode configuration into OKVS data structure at $6000 + !word gAttractModeStore + !word - + !byte 0 + + jsr pref_get ; get attract mode module from prefs + !word kNextAttract + !word gAttractModeStore + +ST16 @mname ; A/Y = module name + ; $WINDEX = index of module in attract store + +LDADDR gAttractModeStore + jsr okvs_next ; get module after this one + +ST16 + + + jsr pref_set ; update prefs store and save to disk + !word kNextAttract ++ !word $FDFD ; SMC + + jsr okvs_get + !word gAttractModeStore +@mname !word $FDFD ; SMC + +ST16 PTR + ldy #1 + lda (PTR),y + tax ; X = module type + +LD16 @mname ; A/Y = address of module name + jsr RunAttractModule + lda KBD + bpl MegaAttractMode + cmp #$8D ; Enter plays the game shown on screen. + bne + ; Any other key switches to Search Mode. + jsr PlayGame ; (might return if user hits Ctrl-Reset) ++ jmp SearchMode + +;------------------------------------------------------------------------------ +; MiniAttractMode +; run attract modules related to one game +; +; in: gGameToLaunch = index in gGamesListStore (word) +; out: all flags and registers clobbered +; assume all of main memory has been clobbered +;------------------------------------------------------------------------------ +MiniAttractMode + jsr GetGameToLaunch + +ST16 + + + jsr BlankHGR + ; X = 0 + stx MiniAttractIndex + stx MiniAttractIndex+1 +@loop + jsr LoadFile ; load mini attract mode configuration file into $8000 + !word kMiniAttractDirectory ++ !word $FDFD ; SMC +- !word $8000 + + jsr ParseKeyValueList ; parse configuration into OKVS data structure at $6000 + !word gAttractModeStore + !word - + !byte 0 + + +LDADDR gAttractModeStore + jsr okvs_len + lda WCOUNT + cmp MiniAttractIndex + bne + + lda WCOUNT+1 + cmp MiniAttractIndex+1 + beq ATTRTS ; we've run through all modules, so exit to caller ++ + +LD16 MiniAttractIndex + +ST16 WINDEX + +LDADDR gAttractModeStore + jsr okvs_nth ; get the next module on the list + +ST16 SAVE + jsr okvs_get_current ; get module type + ldy #1 + lda (PTR),y + tax ; X = module type + +LD16 SAVE ; A/Y = address of module name + jsr RunAttractModule ; execute the module + + inc MiniAttractIndex + bne + + inc MiniAttractIndex+1 ++ + lda KBD + bpl @loop +ATTRTS rts +MiniAttractIndex + !word 0 ; SMC + +;------------------------------------------------------------------------------ +; RunAttractModule +; run a single attract module of any type and return to caller +; +; in: X = module type as ASCII char (1-6,A-C, see attract.conf) +; A/Y = address of module name +; for demos, this is the filename of an executable in /demo/ +; for slideshows, this is the filename of a .conf file in /ss/ +; for singles, this is a pathname of the graphic to load +; gGlobalPrefsStore must be initialized (if we load a transition effect +; of any kind, we will update the global prefs with the next one) +; out: all flags and registers clobbered +; assume all of main memory has been clobbered +;------------------------------------------------------------------------------ +RunAttractModule + +ST16 @key + +ST16 @key2 + cpx #$30 + bne @NotDemo + +; Self-running demos are loaded into main memory and executed. +; Each binary has been patched to quit on any key and jump back +; to the |Reenter| entry point. +; All demos are strictly 48K / main memory. No demo uses the +; language card or auxiliary memory. + + +LD16 @key + jsr FindGame + bcs ATTRTS ; if game doesn't exist, skip the demo + +LD16 WINDEX + +CMP16 $FFFF + beq + + +ST16 gGameToLaunch ; if this demo corresponds to a game, save its index + ; in case user presses RETURN during the demo (we will launch the game) ++ + jsr ClearScreens ; avoid seeing code load into the HGR page + ; (clobbers $106, must do now before loading prelaunch code) + + jsr LoadFile ; load standard prelaunch code (|Launch| will call it) + !word kPrelaunchDirectory + !word kStandardPrelaunch + !word $0106 + + jsr LoadFile ; load self-running demo into its default address (varies) + !word kDemoDirectory +@key !word $FDFD + !word 0 + + jmp Launch ; will return to caller via |Reenter| + +; not a demo, so maybe a slideshow or single screenshot +@NotDemo + txa + cmp #$41 ; numbers are slideshow modules, + bcs @dispatchSingle ; letters are single files + +; it's a slideshow, so load and parse slideshow configuration file + pha ; save module type + jsr LoadFile ; load slideshow configuration file into $4000 + !word kAttractModeSlideshowDirectory +@key2 !word $FDFD ; SMC +- !word $4000 + jsr ParseKeyValueList ; parse into an OKVS data structure at $0800 + !word gSlideshowStore + !word - + !byte 0 + pla ; restore module type + +- and #$0F ; convert ASCII digit to int + tax + lda @slideshowslo-1,x + sta @jmp+1 + lda @slideshowshi-1,x + sta @jmp+2 + +LD16 @key ; pass in module name +@jmp jmp $FDFD ; SMC + +@dispatchSingle + adc #(@singleslo-@slideshowslo)-1 + bne - ; always branches + +@slideshowslo + !byte HGRTitleSlideshow + !byte >HGRActionSlideshow + !byte >DHGRTitleSlideshow + !byte >DHGRActionSlideshow + !byte >SHRSlideshow + !byte >GRActionSlideshow +@singleshi + !byte >HGRSingle + !byte >DHGRSingle + !byte >SHRSingle + !byte >GRSingle diff --git a/src/ui.attract.shr.a b/src/ui.attract.shr.a new file mode 100644 index 0000000..4c74d85 --- /dev/null +++ b/src/ui.attract.shr.a @@ -0,0 +1,153 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Super hi-res slideshows +; +; Public functions +; - SHRSlideshow +; - SHRSingle +; + +;------------------------------------------------------------------------------ +; SHRSlideshow +; execute a slideshow of super hi-res artwork +; +; safe to call if machine can not display super hi-res graphics (does nothing +; and exits) +; +; in: none +; out: everything clobbered +; graphics mode reset to display hi-res screen, which is blank +;------------------------------------------------------------------------------ +SHRSlideshow + lda MachineStatus ; only show SHR on IIgs or if we have a VidHD card + and #SUPPORTS_SHR + bne + +SHRRTS rts ++ jsr LoadSHRTransition + jsr okvs_iter + !word gSlideshowStore + !word SHRArtworkCallback + jmp BlankHGR + +;------------------------------------------------------------------------------ +; SHRSlideshow +; display a single super hi-res artwork +; +; safe to call if machine can not display super hi-res graphics (does nothing +; and exits) +; +; in: none +; out: everything clobbered +; graphics mode reset to display hi-res screen, which is blank +;------------------------------------------------------------------------------ +SHRSingle + +ST16 + + lda MachineStatus ; only show SHR on IIgs or if we have a VidHD card + and #SUPPORTS_SHR + beq SHRRTS + jsr BlankSHR + jsr LoadFile + !word kRootDirectory ++ !word $FDFD ; SMC + !word $1FF8 + jsr DecompressSHR + jsr LoadSHRTransition + jsr ExecuteTransitionAtA000AndWait + jmp BlankHGR + +;------------------------------------------------------------------------------ +; LoadSHGRTransition [private] +; load the SHR transition effect code (currently always the same file) +; +; in: none +; out: all registers and flags clobbered +; $A000..$BFFF/main contains transition effect code +;------------------------------------------------------------------------------ +LoadSHRTransition + jsr LoadFile + !word kFXDirectory + !word kSFXFizzleFile + !word $A000 + rts + +;------------------------------------------------------------------------------ +; SHRArtworkCallback [private] +; callback called by okvs_iter on gSlideshowStore +; to load and display a single SHR graphic + +; in: A/Y contains address of filename (name only, path is always /ARTWORK.SHR/) +; $WINDEX contains 0-based index of the current record in gSlideshowStore (word) +; out: all registers and flags clobbered +; $0800..$1EFF preserved (this contains the gSlideshowStore OKVS data) +; $2000..$BFFF clobbered by graphics data and transition code +; $2000..$5FFF/aux clobbered +;------------------------------------------------------------------------------ +SHRArtworkCallback + bit KBD + bmi SHRRTS + + +ST16 @sfname + + jsr FindGame + ; if game is not found (C will be set here), it means it can't be played on + ; this machine due to memory or joystick requirements, so we don't display + ; it in slideshows + bcs SHRRTS + + +LD16 WINDEX ; save game index in case user hits RETURN + +ST16 gGameToLaunch ; while it's visible (we'll launch it) + + jsr BlankSHR + + ; load compressed SHR artwork at $1FF0/main (not aux) + jsr LoadFile + !word kSHRArtworkDirectory +@sfname !word $FDFD + !word $1FF8 + jsr DecompressSHR + jmp ExecuteTransitionAtA000AndWait + +;------------------------------------------------------------------------------ +; BlankSHR [private] +; clear and show SHR mode without flickering +; +; in: Machine is a IIgs or has a VidHD card that responds appropriately to +; IIgs-specific softswitches for graphics and memory modes. +; NOTE: THIS ROUTINE WILL CRASH ON AN APPLE //C due to writing to $C029, +; so it is imperative that the caller ensures the machine type. +; Thanks to John Brooks for explaining all of this to me. Twice. +; out: text page clobbered (but screen holes preserved) +; $2000..$9FFF/aux cleared +;------------------------------------------------------------------------------ +BlankSHR + jsr Home + + lda #%01000001 ; set GS NEWVIDEO mode to turn on linearize + sta NEWVIDEO + + sta WRITEAUXMEM ; writes go to auxmem + + ldx #$00 ; enable auxmem-to-bank-E1 shadowing on IIgs + stx SHADOW + +; VIDHD-SPECIFIC HACK HERE! +; On the II/II+/IIe, all $C03x addresses are aliases for $C030, i.e. the speaker. +; Any single access of the speaker register requires a second access within a short +; time to balance the level if we want to avoid an audible click, which we do here. +; Since we can't read from SHADOW before writing to it (it returns random values on +; 8-bit machines, which VidHD interprets as invalid graphic modes and crashes hard), +; we instead balance the speaker access with a second write to the same speaker- +; aliased softswitch. Do not remove. + stx SHADOW + + lsr ; clear $2000..$9FFF in auxmem + ldx #$80 + jsr ClearMem + + sta WRITEMAINMEM ; writes go to main memory + + lda #%11000001 ; set GS NEWVIDEO mode to turn on SHR mode + sta NEWVIDEO + + rts diff --git a/src/ui.browse.mode.a b/src/ui.browse.mode.a new file mode 100644 index 0000000..5ce427d --- /dev/null +++ b/src/ui.browse.mode.a @@ -0,0 +1,182 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Browse Mode - main UI +; +; Public functions +; - BrowseMode +; + +;------------------------------------------------------------------------------ +; BrowseMode +; main entry point for Browse Mode, which allows the user to browse the game +; catalog in alphabetical order and launch games +; +; in: none +; out: never returns to caller (may JMP to other major modes) +;------------------------------------------------------------------------------ +BrowseMode + ldx #$FF + txs + +@BrowseModeInputLoop + jsr WaitForKeyFor30Seconds + bit CLEARKBD + +; indices into BrowseDispatchTable below +kBrowseSearch = 0 +kBrowsePrevious = 1 +kBrowseNext = 2 +kBrowseExitToSearch = 3 +kBrowseTab = 4 +kBrowseLaunch = 5 +kBrowseHelp = 6 +kBrowseCredits = 7 +kBrowseCheat = 8 +kSoftBell = 9 ; must match kInputError +kBrowseJoystick = 10 +kBrowseQuit = 11 + + ldy #kNumBrowseKeys +- dey + bmi @noKeyMatch + cmp BrowseKeys,y + bne - + ldx BrowseKeyDispatch,y + bne @BrowseDispatch ; always branches + +@noKeyMatch + jsr IsSearchKey + bne @BrowseDispatch + ldx #kBrowseSearch + + ; execution falls through here +@BrowseDispatch + ldy BrowseDispatchTableLo,x + sty @j+1 + ldy BrowseDispatchTableHi,x + sty @j+2 +@j jsr $FDFD ; SMC + jmp @BrowseModeInputLoop + +OnBrowseSearch + sta InputBuffer + lda #$01 + sta InputLength + jmp SearchMode + +OnBrowsePrevious + +LDX16 gGameToLaunch + +CPX16_0 + bne @notFirstGame + +LDX16 GameCount +@notFirstGame + +DEX16 + jmp notLastGame + +OnBrowseNext + +LDX16 gGameToLaunch + +INX16 + +CPX16ADDR GameCount + bne notLastGame + ldx #0 + ldy #0 +notLastGame + +STX16 gGameToLaunch + jmp OnBrowseChanged + +OnBrowseLaunch + jsr PlayGame + jsr BlankHGR + jmp ForceBrowseChanged + +OnBrowseCheat + jsr ToggleCheat + beq ForceBrowseChanged ; always branches because Z=1 on exit from ToggleCheat + +OnBrowseTab + jsr MiniAttractMode + cmp #$8D + beq OnBrowseLaunch + ; execution falls through here +ForceBrowseChanged + bit CLEARKBD + ; execution falls through here +OnBrowseChanged +; in: gGameToLaunch = game index (word) + jsr SwitchToBank2 + jsr EnableAcceleratorAndSwitchToBank1 + jsr LoadGameTitleOffscreen + jsr DrawUIWithoutDots + jmp MaybeAnimateTitle +BrowseCreditsWrapper + jsr Credits + jmp ForceBrowseChanged +BrowseHelpWrapper + jsr Help + jmp ForceBrowseChanged + +;------------------------------------------------------------------------------ + +BrowseDispatchTableLo + !byte OnBrowseSearch + !byte >OnBrowsePrevious + !byte >OnBrowseNext + !byte >SearchMode + !byte >OnBrowseTab + !byte >OnBrowseLaunch + !byte >BrowseHelpWrapper + !byte >BrowseCreditsWrapper + !byte >OnBrowseCheat + !byte >SoftBell + !byte >Joystick + !byte >OnQuit + +kNumBrowseKeys = 14 + ; number of entries in next 2 tables (each) +BrowseKeys + !byte $83 ; Ctrl-C = toggle cheat mode + !byte $81 ; Ctrl-A = about + !byte $AF ; '/' = help + !byte $BF ; '?' = help + !byte $A0 ; Space = mini attract mode + !byte $89 ; TAB = mini attract mode + !byte $8D ; ENTER = launch current game + !byte $9B ; Esc = switch to search mode + !byte $8A ; down arrow = next + !byte $95 ; right arrow = next + !byte $8B ; up arrow = previous + !byte $88 ; left arrow = previous + !byte $90 ; Ctrl-P = launch joystick calibration program + !byte $91 ; Ctrl-Q = quit +BrowseKeyDispatch + !byte kBrowseCheat + !byte kBrowseCredits + !byte kBrowseHelp + !byte kBrowseHelp + !byte kBrowseTab + !byte kBrowseTab + !byte kBrowseLaunch + !byte kBrowseExitToSearch + !byte kBrowseNext + !byte kBrowseNext + !byte kBrowsePrevious + !byte kBrowsePrevious + !byte kBrowseJoystick + !byte kBrowseQuit + +GameCount + !word 0 diff --git a/src/ui.cheats.a b/src/ui.cheats.a new file mode 100644 index 0000000..ee7a817 --- /dev/null +++ b/src/ui.cheats.a @@ -0,0 +1,37 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; cheat-related UI functions +; +; Public functions: +; - ToggleCheat +; + +;------------------------------------------------------------------------------ +; ToggleCheat +; toggle whether cheats are enabled (global flag) and update the preferences +; file with the new status +; +; does not update UI +; +; in: none +; out: X = 0 +; Z = 1 +; all other registers and flags clobbered +;------------------------------------------------------------------------------ +ToggleCheat + ldx #$B0 + lda MachineStatus + eor #CHEATS_ENABLED + sta MachineStatus + and #CHEATS_ENABLED + beq + + inx ++ stx @val + jsr pref_set + !word kCheat + !word @pref + ; X = 0, Z = 1 + rts +@pref !byte 1 +@val !byte $FD diff --git a/src/ui.common.a b/src/ui.common.a new file mode 100755 index 0000000..4b0a3e9 --- /dev/null +++ b/src/ui.common.a @@ -0,0 +1,153 @@ +;License:MIT +;(c) 2018-2020 by 4am +; +; miscellaneous UI functions +; +; Public functions +; - Home +; - BlankDHGR +; - DHGRMode +; - IsSearchKey +; - IsUpDownOrRightArrow +; + +;------------------------------------------------------------------------------ +; Home +; clear and display text screen (HARDER THAN IT SOUNDS) +; +; in: none +; out: none +;------------------------------------------------------------------------------ +Home + lda MachineStatus + and #SUPPORTS_SHR + beq @noSHR + lda #%00000001 ; bit 7 = 0 -> IIgs Apple II-compatible video modes + ; bit 6 = 0 -> IIgs 128K memory map is the same as the Apple IIe + ; bit 5 = 0 -> IIgs DHGR is color, not monochrome + ; bits 1-4 reserved + ; bit 0 = 1 -> disable bank latch + sta NEWVIDEO + ldy #$F0 + sty TBCOLOR ; white text on black background + lsr + sta CLOCKCTL ; black border + sta CLOCKCTL ; set twice for VidHD +@noSHR + sta gMachineInDHGRMode ; A=0 here + ldy #$2C ; BIT + sty PageFrom + ldx #$04 + stx PageTo+2 + lda #$A0 ; clear text screen page 1 + jsr ClearGR + sta WRITEAUXMEM + ldx #$04 + stx PageTo+2 + jsr ClearGR + sta WRITEMAINMEM + + jsr WaitForVBL + sta DHIRESOFF ; get out of DHGR mode + sta CLR80VID ; /!\ order of operations matters for RGB card + lda PAGE1 + lda TEXTMODE + jmp UnwaitForVBL + +;------------------------------------------------------------------------------ +; BlankDHGR +; clear and show DHGR page 1 without flickering +; +; in: none +; out: text page clobbered (but screen holes preserved) +; $2000..$3FFF/main and /aux cleared +;------------------------------------------------------------------------------ +BlankDHGR + jsr Home + jsr ClearHGR1 ; clear hi-res screen 1 + sta WRITEAUXMEM + jsr ClearHGR1 ; clear hi-res screen 1 in auxmem + sta WRITEMAINMEM + + ; /!\ execution falls through here to DHGRMode +;------------------------------------------------------------------------------ +; DHGRMode +; switch to DHGR mode (HARDER THAN IT SOUNDS) +; +; in: none +; out: none +;------------------------------------------------------------------------------ +DHGRMode + ; magic sequence to set colour mode on an RGB card + ; SET80VID clears the RGB-card shift-register + ; DHIRESON/OFF shifts that bit into the mode register + ; we do that twice because the mode register is two bits wide + ; we need mode 00 for colour + + jsr WaitForVBL + sta SET80VID + sta DHIRESON + sta DHIRESOFF + sta DHIRESON + sta DHIRESOFF + + sta DHIRESON ; then turn DHGR on + bit PAGE1 + lda #1 + sta OffscreenPage + sta gMachineInDHGRMode + jsr UnwaitForVBL + jmp HGRMode + +;------------------------------------------------------------------------------ +; IsSearchKey +; test whether accumulator contains a key that might trigger a new textrank +; search +; +; in: A = key +; out: A &= 0x7F +; Y preserved +; X clobbered +; Z = 1 and C = 0 if this is a search key +; Z = 0 if this is not a search key +;------------------------------------------------------------------------------ +IsSearchKey + and #$7F ; strip high bit for search characters + cmp #$30 ; control keys and punctuation ignored + bcc @badkey + cmp #$3A ; numbers are good input + bcc @goodkey + cmp #$41 ; more punctuation (also ignored) + bcc @badkey + cmp #$5B ; uppercase letters are good input + bcs + + ora #$20 ; convert uppercase letters to lowercase +@goodkey + ldx #0 + rts + ++ cmp #$61 ; more punctuation (also ignored) + bcc @badkey + cmp #$7B ; lowercase letters are good input + bcc @goodkey +@badkey + ldx #kInputError ; also #kSoftBell + rts + +;------------------------------------------------------------------------------ +; IsUpDownOrRightArrow +; test whether accumulator contains ASCII code for up, down, or right arrow +; search +; +; in: A = key +; out: all registers preserved +; Z = 1 if accumulator was one of those 3 keys +; Z = 0 otherwise +;------------------------------------------------------------------------------ +IsUpDownOrRightArrow + cmp #$8B ; up arrow + beq @done + cmp #$95 ; right arrow + beq @done + cmp #$8A ; down arrow +@done rts diff --git a/src/ui.credits.a b/src/ui.credits.a new file mode 100644 index 0000000..5a40b56 --- /dev/null +++ b/src/ui.credits.a @@ -0,0 +1,68 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; credits page +; +; Public functions +; - Credits +; - Help +; + +;------------------------------------------------------------------------------ +; Credits +; display credits page and wait +; +; in: none +; out: C clear +; all other flags and registers clobbered +;------------------------------------------------------------------------------ +Credits + jsr LoadFile ; load credits text into $8000 + !word kRootDirectory + !word kCreditsFile + !word $8000 +-- jsr ForceHGRMode + jsr ClearOffscreen + ldx #0 +- lda OffscreenPage + ror ; draw on offscreen page + +LDADDR $8000 + jsr DrawPage ; draw credits + jsr ShowOtherPage ; show credits + jsr WaitForKeyFor30Seconds; wait + bit CLEARKBD ; don't care about key + cmp #$81 ; Ctrl-A = about + beq Credits + cmp #$90 ; Ctrl-P = launch joystick calibration program + bne + + jmp Joystick ++ cmp #$83 ; Ctrl-C = toggle cheat mode + bne + + jsr ToggleCheat ++ sec ; if called from search mode, tell caller to refresh + rts + +;------------------------------------------------------------------------------ +; Help +; display per-game or global help page and wait +; +; in: none +; out: see above +;------------------------------------------------------------------------------ +Help + jsr GetGameToLaunch + bcs @global + +ST16 @fname + jsr LoadFile + !word kGameHelpDirectory +@fname !word $FDFD ; SMC + !word $8000 + clc + bcc -- ; always branches +@global jsr LoadFile ; load help text into $8000 + !word kRootDirectory + !word kHelpTextFile + !word $8000 + jsr LoadHelpOffscreen ; load fancy backdrop + ldx #7 + bne - ; always branches diff --git a/src/ui.font.a b/src/ui.font.a new file mode 100644 index 0000000..5d28cbc --- /dev/null +++ b/src/ui.font.a @@ -0,0 +1,42 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; hi-res font drawing routines +; +; Glue functions that handle bank switching and calling the real font drawing routines +; that live in LC RAM 2 now. +; +; Public functions +; - DrawPage +; - Draw40Chars +; - DrawCenteredString +; - DrawString +; - DrawBuffer +; + +DrawString + jsr SwitchToBank2 + jsr DrawStringInternal + bmi JmpSwitch ; always + +DrawPage + jsr SwitchToBank2 + jsr DrawPageInternal + +JmpSwitch + jmp SwitchToBank1 + +Draw40Chars + jsr SwitchToBank2 + jsr Draw40CharsInternal + beq JmpSwitch ; always + +DrawCenteredString + jsr SwitchToBank2 + jsr DrawCenteredStringInternal + bmi JmpSwitch ; always + +DrawBuffer + jsr SwitchToBank2 + jsr DrawBufferInternal + bmi JmpSwitch ; always diff --git a/src/ui.font.data.lc2.a b/src/ui.font.data.lc2.a new file mode 100644 index 0000000..86eb670 --- /dev/null +++ b/src/ui.font.data.lc2.a @@ -0,0 +1,1038 @@ +;license:MIT +;(c) 2018-9 by 4am +; +; 'Circuitous' hi-res font data +; + +FontDataRow0 + !byte $80 ; 00 + !byte $80 ; 01 + !byte $80 ; 02 + !byte $9C ; 03 + !byte $80 ; 04 + !byte $9C ; 05 + !byte $80 ; 06 + !byte $80 ; 07 + !byte $00 ; 08 + !byte $9C ; 09 + !byte $00 ; 0A + !byte $80 ; 0B + !byte $9C ; 0C + !byte $E0 ; 0D + !byte $B0 ; 0E + !byte $B0 ; 0F + !byte $80 ; 10 + !byte $80 ; 11 + !byte $80 ; 12 + !byte $80 ; 13 + !byte $B6 ; 14 + !byte $80 ; 15 + !byte %10011100 ; 16 + !byte $80 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $80 ; 1A + !byte $EC ; 1B + !byte $B0 ; 1C + !byte $B0 ; 1D + !byte $8C ; 1E + !byte $98 ; 1F + !byte $80 ; 20 + !byte $98 ; 21 + !byte $B6 ; 22 + !byte $B6 ; 23 + !byte $98 + !byte $E7 + !byte $BE + !byte $98 + !byte $98 + !byte $8C + !byte $E3 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $E0 + !byte $BC + !byte $98 + !byte $BE + !byte $BE + !byte $E6 + !byte $FE + !byte $BC + !byte $FE + !byte $BC + !byte $BC + !byte $80 + !byte $80 + !byte $F0 + !byte $80 + !byte $8E + !byte $BC + !byte $BE + !byte $BE + !byte $BF + !byte $FE + !byte $BF + !byte $FF + !byte $FF + !byte $FE + !byte $E3 + !byte $BE + !byte $F0 + !byte $E3 + !byte $83 + !byte $E3 + !byte $E3 + !byte $BE + !byte $BF + !byte $BE + !byte $BF + !byte $FE + !byte $FF + !byte $E3 + !byte $E3 + !byte $E3 + !byte $C1 + !byte $E3 + !byte $FF + !byte $9C + !byte $83 + !byte $9C + !byte $98 + !byte $80 + !byte $8E + !byte $80 + !byte $86 + !byte $80 + !byte $E0 + !byte $80 + !byte $F8 + !byte $80 + !byte $86 + !byte $98 + !byte $80 + !byte $86 + !byte $9C + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $8C + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $B0 + !byte $9C + !byte $86 + !byte $80 + !byte $FE +FontDataRow1 + !byte $80 ; 00 + !byte $9C ; 01 + !byte $9C ; 02 + !byte $9C ; 03 + !byte $9C ; 04 + !byte $9C ; 05 + !byte $80 ; 06 + !byte $80 ; 07 + !byte $8C ; 08 + !byte $9E ; 09 + !byte $00 ; 0A + !byte $98 ; 0B + !byte $BC ; 0C + !byte $E0 ; 0D + !byte $98 ; 0E + !byte $98 ; 0F + !byte $80 ; 10 + !byte $80 ; 11 + !byte $80 ; 12 + !byte $9C ; 13 + !byte $FF ; 14 + !byte $98 ; 15 + !byte %10110110 ; 16 + !byte $E6 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $98 ; 1A + !byte $80 ; 1B + !byte $98 ; 1C + !byte $98 ; 1D + !byte $98 ; 1E + !byte $8C ; 1F + !byte $80 ; 20 + !byte $BC ; 21 + !byte $B6 ; 22 + !byte $FF ; 23 + !byte $FE + !byte $F3 + !byte $E3 + !byte $98 + !byte $8C + !byte $98 + !byte $B6 + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $F0 + !byte $E6 + !byte $9C + !byte $E0 + !byte $E0 + !byte $E6 + !byte $86 + !byte $86 + !byte $E0 + !byte $E6 + !byte $E6 + !byte $98 + !byte $98 + !byte $B8 + !byte $BE + !byte $9C + !byte $E6 + !byte $E3 + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $E3 + !byte $BE + !byte $F0 + !byte $F3 + !byte $83 + !byte $F7 + !byte $E7 + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $FF + !byte $E3 + !byte $E3 + !byte $E3 + !byte $E3 + !byte $E3 + !byte $FF + !byte $8C + !byte $87 + !byte $98 + !byte $BC + !byte $80 + !byte $9B + !byte $80 + !byte $86 + !byte $80 + !byte $E0 + !byte $80 + !byte $8C + !byte $80 + !byte $86 + !byte $98 + !byte $B0 + !byte $86 + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $8C + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $98 + !byte $9C + !byte $8C + !byte $80 + !byte $FE +FontDataRow2 + !byte $FF ; 00 + !byte $FE ; 01 + !byte $BF ; 02 + !byte $9C ; 03 + !byte $BE ; 04 + !byte $9C ; 05 + !byte $F0 ; 06 + !byte $87 ; 07 + !byte $86 ; 08 + !byte $9F ; 09 + !byte $00 ; 0A + !byte $BC ; 0B + !byte $FC ; 0C + !byte $EC ; 0D + !byte $B6 ; 0E + !byte $BE ; 0F + !byte $80 ; 10 + !byte $88 ; 11 + !byte $9C ; 12 + !byte $BE ; 13 + !byte $FF ; 14 + !byte $B0 ; 15 + !byte %10000110 ; 16 + !byte $BC ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $98 ; 1A + !byte $FC ; 1B + !byte $BC ; 1C + !byte $80 ; 1D + !byte $BC ; 1E + !byte $BE ; 1F + !byte $80 ; 20 + !byte $BC ; 21 + !byte $A4 ; 22 + !byte $FF ; 23 + !byte $9B + !byte $F8 + !byte $87 + !byte $88 + !byte $8C + !byte $98 + !byte $9C + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $B8 + !byte $F6 + !byte $9C + !byte $FC + !byte $FC + !byte $E6 + !byte $BE + !byte $BE + !byte $B0 + !byte $FE + !byte $FE + !byte $98 + !byte $98 + !byte $9C + !byte $BE + !byte $B8 + !byte $E0 + !byte $FB + !byte $E3 + !byte $E3 + !byte $83 + !byte $E3 + !byte $83 + !byte $83 + !byte $83 + !byte $E3 + !byte $9C + !byte $E0 + !byte $B3 + !byte $83 + !byte $FF + !byte $EF + !byte $E3 + !byte $E3 + !byte $E3 + !byte $E3 + !byte $83 + !byte $9C + !byte $E3 + !byte $E3 + !byte $E3 + !byte $E7 + !byte $E3 + !byte $F0 + !byte $8C + !byte $8E + !byte $98 + !byte $E6 + !byte $80 + !byte $B8 + !byte $FC + !byte $B6 + !byte $BC + !byte $EC + !byte $BC + !byte $BE + !byte $FC + !byte $B6 + !byte $80 + !byte $B0 + !byte $E6 + !byte $98 + !byte $E6 + !byte $BE + !byte $BC + !byte $BE + !byte $FC + !byte $BC + !byte $F8 + !byte $FE + !byte $E6 + !byte $E6 + !byte $E6 + !byte $E6 + !byte $E6 + !byte $FE + !byte $98 + !byte $9C + !byte $8C + !byte $EC + !byte $FE +FontDataRow3 + !byte $FF ; 00 + !byte $FE ; 01 + !byte $BF ; 02 + !byte $9C ; 03 + !byte $BE ; 04 + !byte $BE ; 05 + !byte $F8 ; 06 + !byte $8F ; 07 + !byte $FF ; 08 + !byte $8F ; 09 + !byte $00 ; 0A + !byte $FE ; 0B + !byte $F8 ; 0C + !byte $E6 ; 0D + !byte $C3 ; 0E + !byte $FF ; 0F + !byte $88 ; 10 + !byte $9C ; 11 + !byte $BE ; 12 + !byte $BE ; 13 + !byte $FF ; 14 + !byte $FF ; 15 + !byte %10111110 ; 16 + !byte $98 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $98 ; 1A + !byte $E6 ; 1B + !byte $E6 ; 1C + !byte $9C ; 1D + !byte $E0 ; 1E + !byte $FF ; 1F + !byte $80 ; 20 + !byte $98 ; 21 + !byte $80 ; 22 + !byte $B6 ; 23 + !byte $BE + !byte $BC + !byte $F6 + !byte $80 + !byte $8C + !byte $98 + !byte $FC + !byte $FE + !byte $80 + !byte $BE + !byte $80 + !byte $9C + !byte $EE + !byte $98 + !byte $BE + !byte $BC + !byte $FE + !byte $FE + !byte $FE + !byte $98 + !byte $BC + !byte $FC + !byte $80 + !byte $80 + !byte $8E + !byte $80 + !byte $F0 + !byte $F8 + !byte $FB + !byte $E3 + !byte $BB + !byte $83 + !byte $E3 + !byte $BB + !byte $BB + !byte $FB + !byte $FB + !byte $9C + !byte $E0 + !byte $9B + !byte $83 + !byte $FF + !byte $FF + !byte $E3 + !byte $E3 + !byte $E3 + !byte $E3 + !byte $BF + !byte $9C + !byte $E3 + !byte $E3 + !byte $E3 + !byte $BE + !byte $B6 + !byte $B8 + !byte $8C + !byte $9C + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $E6 + !byte $E6 + !byte $86 + !byte $E6 + !byte $E6 + !byte $8C + !byte $E6 + !byte $E6 + !byte $9C + !byte $80 + !byte $B6 + !byte $98 + !byte $FE + !byte $E6 + !byte $E6 + !byte $E6 + !byte $E6 + !byte $86 + !byte $9C + !byte $8C + !byte $E6 + !byte $E6 + !byte $E6 + !byte $BC + !byte $E6 + !byte $B0 + !byte $8E + !byte $9C + !byte $B8 + !byte $FE + !byte $FE +FontDataRow4 + !byte $FF ; 00 + !byte $FE ; 01 + !byte $BF ; 02 + !byte $9C ; 03 + !byte $BE ; 04 + !byte $BE ; 05 + !byte $FC ; 06 + !byte $9F ; 07 + !byte $FF ; 08 + !byte $87 ; 09 + !byte $00 ; 0A + !byte $98 ; 0B + !byte $F0 ; 0C + !byte $FF ; 0D + !byte $A3 ; 0E + !byte $BF ; 0F + !byte $80 ; 10 + !byte $9C ; 11 + !byte $BE ; 12 + !byte $BE ; 13 + !byte $BE ; 14 + !byte $FF ; 15 + !byte %11111111 ; 16 + !byte $BC ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $FE ; 1A + !byte $E6 ; 1B + !byte $B6 ; 1C + !byte $98 ; 1D + !byte $E6 ; 1E + !byte $E3 ; 1F + !byte $80 ; 20 + !byte $98 ; 21 + !byte $80 ; 22 + !byte $FF ; 23 + !byte $F8 + !byte $9E + !byte $E3 + !byte $80 + !byte $8C + !byte $98 + !byte $9F + !byte $FE + !byte $80 + !byte $BE + !byte $80 + !byte $8E + !byte $E6 + !byte $98 + !byte $86 + !byte $E0 + !byte $FC + !byte $E0 + !byte $E6 + !byte $9C + !byte $E6 + !byte $E0 + !byte $98 + !byte $98 + !byte $9C + !byte $BE + !byte $B8 + !byte $BC + !byte $BB + !byte $FB + !byte $BB + !byte $83 + !byte $E3 + !byte $BB + !byte $BB + !byte $FB + !byte $FB + !byte $9C + !byte $E0 + !byte $9B + !byte $83 + !byte $EB + !byte $FB + !byte $E3 + !byte $FB + !byte $E3 + !byte $BB + !byte $BE + !byte $9C + !byte $E3 + !byte $F7 + !byte $EB + !byte $9C + !byte $BE + !byte $9C + !byte $8C + !byte $B8 + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $E6 + !byte $E6 + !byte $86 + !byte $E6 + !byte $B6 + !byte $8C + !byte $FC + !byte $E6 + !byte $98 + !byte $B0 + !byte $9E + !byte $98 + !byte $FE + !byte $E6 + !byte $E6 + !byte $E6 + !byte $E6 + !byte $86 + !byte $B0 + !byte $8C + !byte $E6 + !byte $BC + !byte $FE + !byte $98 + !byte $EC + !byte $8C + !byte $8E + !byte $9C + !byte $B8 + !byte $B6 + !byte $FE +FontDataRow5 + !byte $80 ; 00 + !byte $9C ; 01 + !byte $9C ; 02 + !byte $9C ; 03 + !byte $9C ; 04 + !byte $BE ; 05 + !byte $BC ; 06 + !byte $9E ; 07 + !byte $86 ; 08 + !byte $80 ; 09 + !byte $00 ; 0A + !byte $98 ; 0B + !byte $80 ; 0C + !byte $BF ; 0D + !byte $A3 ; 0E + !byte $BF ; 0F + !byte $80 ; 10 + !byte $88 ; 11 + !byte $9C ; 12 + !byte $BE ; 13 + !byte $9C ; 14 + !byte $B0 ; 15 + !byte %11110111 ; 16 + !byte $E6 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $BC ; 1A + !byte $EE ; 1B + !byte $9E ; 1C + !byte $B8 ; 1D + !byte $FE ; 1E + !byte $FB ; 1F + !byte $80 ; 20 + !byte $80 ; 21 + !byte $80 ; 22 + !byte $FF ; 23 + !byte $FF + !byte $8F + !byte $E3 + !byte $80 + !byte $8C + !byte $98 + !byte $9C + !byte $98 + !byte $98 + !byte $80 + !byte $98 + !byte $87 + !byte $FE + !byte $98 + !byte $FE + !byte $FE + !byte $E0 + !byte $FE + !byte $FE + !byte $9C + !byte $FE + !byte $FE + !byte $98 + !byte $98 + !byte $B8 + !byte $BE + !byte $9C + !byte $80 + !byte $83 + !byte $FB + !byte $E3 + !byte $83 + !byte $E3 + !byte $83 + !byte $83 + !byte $E3 + !byte $E3 + !byte $9C + !byte $E3 + !byte $B3 + !byte $83 + !byte $E3 + !byte $F3 + !byte $E3 + !byte $BB + !byte $FF + !byte $BB + !byte $E0 + !byte $9C + !byte $E3 + !byte $BE + !byte $FF + !byte $BE + !byte $9C + !byte $8E + !byte $8C + !byte $F0 + !byte $98 + !byte $80 + !byte $80 + !byte $80 + !byte $EE + !byte $FE + !byte $FE + !byte $FE + !byte $9E + !byte $8C + !byte $E0 + !byte $E6 + !byte $B8 + !byte $B0 + !byte $BE + !byte $B8 + !byte $E6 + !byte $E6 + !byte $FE + !byte $FE + !byte $EE + !byte $86 + !byte $FE + !byte $FC + !byte $EE + !byte $BC + !byte $FE + !byte $BC + !byte $E0 + !byte $FE + !byte $98 + !byte $9C + !byte $8C + !byte $80 + !byte $FE +FontDataRow6 + !byte $80 ; 00 + !byte $80 ; 01 + !byte $80 ; 02 + !byte $9C ; 03 + !byte $9C ; 04 + !byte $9C ; 05 + !byte $9C ; 06 + !byte $9C ; 07 + !byte $8C ; 08 + !byte $80 ; 09 + !byte $00 ; 0A + !byte $98 ; 0B + !byte $80 ; 0C + !byte $86 ; 0D + !byte $CA ; 0E + !byte $FF ; 0F + !byte $80 ; 10 + !byte $80 ; 11 + !byte $80 ; 12 + !byte $9C ; 13 + !byte $88 ; 14 + !byte $98 ; 15 + !byte %11110111 ; 16 + !byte $80 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $98 ; 1A + !byte $EC ; 1B + !byte $FC ; 1C + !byte $B8 ; 1D + !byte $BC ; 1E + !byte $FB ; 1F + !byte $80 ; 20 + !byte $98 ; 21 + !byte $80 ; 22 + !byte $B6 ; 23 + !byte $BE + !byte $E7 + !byte $FF + !byte $80 + !byte $8C + !byte $98 + !byte $B6 + !byte $98 + !byte $98 + !byte $80 + !byte $98 + !byte $83 + !byte $BC + !byte $98 + !byte $FE + !byte $BE + !byte $E0 + !byte $BE + !byte $BC + !byte $9C + !byte $BC + !byte $BE + !byte $80 + !byte $8C + !byte $F0 + !byte $80 + !byte $8E + !byte $98 + !byte $FF + !byte $E3 + !byte $FF + !byte $FF + !byte $FB + !byte $FF + !byte $83 + !byte $FF + !byte $E3 + !byte $BE + !byte $FF + !byte $F3 + !byte $FF + !byte $E3 + !byte $E3 + !byte $FF + !byte $83 + !byte $BE + !byte $F3 + !byte $FF + !byte $9C + !byte $FF + !byte $9C + !byte $F7 + !byte $F7 + !byte $9C + !byte $FF + !byte $8C + !byte $E0 + !byte $98 + !byte $80 + !byte $FF + !byte $80 + !byte $EC + !byte $BE + !byte $BC + !byte $FC + !byte $FC + !byte $8C + !byte $FE + !byte $E6 + !byte $B8 + !byte $BE + !byte $F6 + !byte $B8 + !byte $E6 + !byte $E6 + !byte $BC + !byte $BE + !byte $EC + !byte $86 + !byte $BC + !byte $B8 + !byte $EC + !byte $98 + !byte $E6 + !byte $E6 + !byte $FE + !byte $FE + !byte $98 + !byte $9C + !byte $8C + !byte $80 + !byte $FE +FontDataRow7 + !byte $00 ; 00 + !byte $80 ; 01 + !byte $80 ; 02 + !byte $9C ; 03 + !byte $9C ; 04 + !byte $80 ; 05 + !byte $9C ; 06 + !byte $9C ; 07 + !byte $80 ; 08 + !byte $80 ; 09 + !byte $00 ; 0A + !byte $80 ; 0B + !byte $00 ; 0C + !byte $8C ; 0D + !byte $B6 ; 0E + !byte $B6 ; 0F + !byte $80 ; 10 + !byte $80 ; 11 + !byte $80 ; 12 + !byte $80 ; 13 + !byte $80 ; 14 + !byte $80 ; 15 + !byte %11111111 ; 16 + !byte $80 ; 17 + !byte $00 ; 18 + !byte $00 ; 19 + !byte $80 ; 1A + !byte $80 ; 1B + !byte $80 ; 1C + !byte $80 ; 1D + !byte $80 ; 1E + !byte $E3 ; 1F + !byte $80 ; 20 + !byte $98 ; 21 + !byte $80 ; 22 + !byte $80 ; 23 + !byte $98 + !byte $F3 + !byte $BE + !byte $80 + !byte $98 + !byte $8C + !byte $E3 + !byte $80 + !byte $8C + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $8C + !byte $80 + !byte $80 + !byte $80 + !byte $98 + !byte $BE + !byte $E3 + !byte $BF + !byte $FE + !byte $BB + !byte $FF + !byte $83 + !byte $BE + !byte $E3 + !byte $BE + !byte $BE + !byte $E3 + !byte $FF + !byte $E3 + !byte $E3 + !byte $BE + !byte $83 + !byte $F0 + !byte $E3 + !byte $BF + !byte $9C + !byte $BE + !byte $88 + !byte $E3 + !byte $E3 + !byte $9C + !byte $FF + !byte $9C + !byte $80 + !byte $9C + !byte $80 + !byte $FF + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $BC + !byte $80 + !byte $80 + !byte $9C + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $86 + !byte $E0 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $80 + !byte $BC + !byte $80 + !byte $B0 + !byte $9C + !byte $86 + !byte $80 + !byte $FE diff --git a/src/ui.font.lc2.a b/src/ui.font.lc2.a new file mode 100644 index 0000000..0958ce0 --- /dev/null +++ b/src/ui.font.lc2.a @@ -0,0 +1,221 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; hi-res font drawing routines +; +; /!\ These live in LC RAM 2 and rely on the font data which is also in LC RAM 2. /!\ +; Code in LC RAM 1 (which is most program code) should call the functions in ui.font +; which handle bank switching for you. +; + +DrawPageInternal +; A/Y contains address of character buffer +; X contains 0-indexed left margin (HTAB) +; carry bit clear -> draw on page 1 +; carry bit set -> draw on page 2 +; drawing starts at VTAB 0 +; each line starts at column X which was passed in (0-indexed) +; clobbers PTR +; clobbers $FF +; clobbers A/X/Y +; preserves all flags, by a quirk of implementation + php + stx $FF + ldx #0 + stx VTAB + +ST16 PTR +@drawLine + lda $FF + sta HTAB + ldy #0 +@parseLine + lda (PTR),y + cmp #$5B ; '[' at beginning on line + bne + ; ends the parsing + tya + beq @donePage ++ cmp #$0A + beq @doneParsingLine + ldx #5 +- cmp @subs_a,x + bne @nosub + lda @subs_b,x + sta (PTR),y +@nosub + dex + bpl - + iny + bne @parseLine +@doneParsingLine + sty SAVE + tya + beq @skip + ldx SAVE + +LD16 PTR + plp + php + jsr DrawBufferInternal +@skip inc SAVE ; skip carriage return + lda SAVE ; advance PTR to start of next line + clc + adc PTR + sta PTR + bcc + + inc PTR+1 ++ inc VTAB ; this will print 255 lines if you give it + bne @drawLine ; 255 lines, so don't do that +@donePage + plp + rts +@subs_a + !byte $2A,$7E,$3C,$3E,$24,$25 +@subs_b + !byte $10,$11,$08,$15,$0E,$0F + +Draw40CharsInternal +; A/Y contains address of character buffer +; carry bit clear -> draw on page 1 +;v carry bit set -> draw on page 2 +; $25 contains textpage line (0..23) (this is the standard VTAB address) +; drawing starts at HTAB 0 +; increments VTAB +; sets HTAB to 0 on exit +; clobbers A/X/Y + jsr + + ldx #40 + jsr DrawBufferInternal + inc VTAB ++ ldx #0 + stx HTAB + rts + +DrawCenteredStringInternal +; A/Y contains address of length-prefixed string +; carry bit clear -> draw on page 1 +; carry bit set -> draw on page 2 +; $25 contains textpage line (0..23) (this is the standard VTAB address) +; clobbers A/X/Y +; clobbers PTR/PTR+1 + +ST16 PTR + + ldy #0 + php + lda #40 + sec + sbc (PTR),y + lsr + sta HTAB + plp + beq + + +DrawStringInternal +; A/Y contains address of length-prefixed string +; carry bit clear -> draw on page 1 +; carry bit set -> draw on page 2 +; $24 contains starting column (0..39) (this is the standard HTAB address) +; $25 contains textpage line (0..23) (this is the standard VTAB address) +; clobbers A/X/Y +; clobbers PTR/PTR+1 + +ST16 PTR + + ldy #0 ++ lda (PTR),y + tax + inc PTR + bne + + inc PTR+1 ++ + +LD16 PTR + ; /!\ execution falls through here to DrawBufferInternal + +DrawBufferInternal +; A/Y contains address of character buffer +; X contains buffer length (1..40) +; carry bit clear -> draw on page 1 +; carry bit set -> draw on page 2 +; characters MUST have high bit off (0x00..0x7F) +; special characters (0x00..0x1F) will be drawn +; $24 contains starting column (0..39) (this is the standard HTAB address) +; $25 contains textpage line (0..23) (this is the standard VTAB address) +; all characters are drawn on the same line +; HTAB is incremented for each character +; VTAB is NOT incremented +; clobbers A/X/Y + +ST16 DBISrc+1 + php + dex + lda VTAB + asl + asl + asl +; routine to calculate memory address within HGR page +; and self-modify addresses within draw loop that follows +; (routine clobbers A and Y but preserves X) + asl + tay + and #$F0 + bpl @calc1 + ora #$05 +@calc1 bcc @calc2 + ora #$0A +@calc2 asl + asl + sta @hgrlo+1 + tya + and #$0E + adc #$10 + asl @hgrlo+1 + rol + plp + bcc + + eor #$60 + clc ++ + sta DBIRow0+2 + adc #$04 + sta DBIRow1+2 + adc #$04 + sta DBIRow2+2 + adc #$04 + sta DBIRow3+2 + adc #$04 + sta DBIRow4+2 + adc #$04 + sta DBIRow5+2 + adc #$04 + sta DBIRow6+2 + adc #$04 + sta DBIRow7+2 +@hgrlo lda #$FD + clc + adc HTAB + sta DBIRow0+1 + sta DBIRow1+1 + sta DBIRow2+1 + sta DBIRow3+1 + sta DBIRow4+1 + sta DBIRow5+1 + sta DBIRow6+1 + sta DBIRow7+1 +DBILoop +DBISrc ldy $FDFD,x + lda FontDataRow0,y +DBIRow0 sta $FDFD,x + lda FontDataRow1,y +DBIRow1 sta $FDFD,x + lda FontDataRow2,y +DBIRow2 sta $FDFD,x + lda FontDataRow3,y +DBIRow3 sta $FDFD,x + lda FontDataRow4,y +DBIRow4 sta $FDFD,x + lda FontDataRow5,y +DBIRow5 sta $FDFD,x + lda FontDataRow6,y +DBIRow6 sta $FDFD,x + lda FontDataRow7,y +DBIRow7 sta $FDFD,x + inc HTAB + dex + bpl DBILoop + rts diff --git a/src/ui.offscreen.a b/src/ui.offscreen.a new file mode 100644 index 0000000..b117260 --- /dev/null +++ b/src/ui.offscreen.a @@ -0,0 +1,214 @@ +;License:MIT +;(c) 2018-2020 by 4am +; +; functions for managing which HGR page is showing, and doing things on the other one +; +; - GetOffscreenAddress +; - LoadTitleOffscreen +; - LoadCoverOffscreen +; - LoadHelpOffscreen +; - LoadGameTitleOffscreen +; - ResyncPage +; - ShowOtherPage +; - ToggleOffscreenPage +; - ClearScreens +; - ClearOffscreen +; - ClearHGR1 +; - ClearMem +; +; Public variables +; - OffscreenPage +; + +;------------------------------------------------------------------------------ +; GetOffscreenAddress +; get high byte of HGR page that is currently not showing +; +; in: none +; out: A = high byte of offscreen HGR page (#$20 or #$40) +; preserves X/Y +;------------------------------------------------------------------------------ +GetOffscreenAddress +Ignore = * + 1 ; discard IRQs, particularly on the IIc + lda #$40 +OffscreenPage = * + 1 + bne + ; SMC + ; 0 = currently showing HGR page 2 + ; (so offscreen is page 1 @ $2000) + ; 1 = currently showing HGR page 1 + ; (so offscreen is page 2 @ $4000) ++ lsr + rts + +;------------------------------------------------------------------------------ +; LoadTitleOffscreen +; load title screen in the HGR page that is currently not showing +; +; in: none +; out: all flags and registers clobbered +;------------------------------------------------------------------------------ +LoadTitleOffscreen + lda #kCoverFile ; all of these are on the same page + !byte $00 ++ !byte $FD ; SMC + rts + +LoadGameTitleOffscreen +; in: gGameToLaunch = index into gGamesListStore (word) + jsr GetGameToLaunch + +ST16 @fname + bit MachineStatus ; if < 128K, don't bother checking for DHGR title + bvc @hgr + jsr okvs_get_current + ; (PTR) -> game display name + bitfield of game info + ; Y = 0 + lda (PTR),y ; A = game display name length + 1 + sta SAVE + tay + lda (PTR),y ; A = game info bitfield + ;;and #HAS_DHGR_TITLE + bmi @dhgr +@hgr + jsr ForceHGRMode + jsr GetOffscreenAddress + sta @addrhi + jsr LoadFile + !word kHGRTitleDirectory +@fname !word $FDFD ; SMC + !byte $00 +@addrhi !byte $FD ; SMC + rts +@dhgr + jsr BlankDHGR + +LD16 @fname + +ST16 + + jsr LoadDHRFile + !word kDHGRTitleDirectory ++ !word $FDFD + rts + +;------------------------------------------------------------------------------ +; ClearScreens +; clear and display text screen and then clear both hires screens +; (in this order so that the erasing isn't visible) +; +; in: none +; out: $400..$7FF and $2000..$5FFF cleared +;------------------------------------------------------------------------------ +ClearScreens + jsr Home + lda #$20 ; clear both hi-res pages + ldx #$40 ; to flash previous bits of the launcher UI) + bne ClearMem ; always + +;------------------------------------------------------------------------------ +; ClearOffscreen +; clear $2000..$3FFF or $4000..$5FFF, depending on which HGR page is not +; visible right now +; does not change HGR mode +; +; in: none +; out: $2000..$3FFF or $4000..$5FFF cleared +; A = #$80 +; X = #$00 +; Y = #$00 +; Z = 1 +;------------------------------------------------------------------------------ +ClearOffscreen + jsr GetOffscreenAddress + +HIDE_NEXT_2_BYTES +ClearHGR1 + lda #$20 ; note to self: LDX #$20 can't move here + ldx #$20 +ClearMem + ldy #$2C ; BIT + bne + ; always + +;------------------------------------------------------------------------------ +; CopyHGR +; +; in: source and destination page pointers set +; out: all registers clobbered +; 8kb memory region duplicated +;------------------------------------------------------------------------------ +CopyHGR + ldx #$20 + ldy #$B9 ; LDY ++ sty PageFrom + sta PageTo+2 + lda #$00 +ClearGR + ldy #0 +PageFrom lda $FD00,y ; SMC +PageTo sta $FD00,y ; SMC + iny + bne PageFrom + inc PageFrom+2 + inc PageTo+2 + dex + bne PageFrom + sta READMAINMEM + rts + +ResyncPage + jsr ToggleOffscreenPage + ; /!\ execution falls through here to ShowOtherPage +;------------------------------------------------------------------------------ +; ShowOtherPage +; switch to the HGR page that is not currently showing +; +; in: none +; out: A = new value of OffscreenPage +; preserves X/Y +;------------------------------------------------------------------------------ +ShowOtherPage + jsr ToggleOffscreenPage + bne + + bit PAGE2 ; show page 2 + rts ++ bit PAGE1 ; show page 1 + rts + +;------------------------------------------------------------------------------ +; ToggleOffscreenPage +; switch the internal variable that tracks which HGR page is showing +; (does not affect screen) +; +; in: none +; out: A = new value of OffscreenPage +; preserves X/Y +;------------------------------------------------------------------------------ +ToggleOffscreenPage + lda OffscreenPage + eor #$01 + sta OffscreenPage + rts diff --git a/src/ui.overlay.a b/src/ui.overlay.a new file mode 100644 index 0000000..8ded1f8 --- /dev/null +++ b/src/ui.overlay.a @@ -0,0 +1,286 @@ +;License:MIT +;(c) 2018-2020 by 4am +; +; routines for drawing the UI overlay (search bar, browse bar, instructions, cheat mode) +; on top of whatever else is on the screen +; +; Public functions +; - DrawUIWithoutDots +; - DrawUI +; +; Public variables +; - VisibleGameCount (set during init) +; + +Instructions + !text "[Type to search, ? for help ] " +VisibleGameCount + !text "000 games" +ReturnToPlay + !byte $0D + !text " to play" + +kCheatsEnabled = 6 ; index of 'cheats enabled' string in following table +kCheatDescriptionLo + !byte sNoCheats + !byte >sInfiniteLives + !byte >sInfiniteWeapons + !byte >sInfiniteLivesAndWeapons + !byte >sInvincibility + !byte >sInGame + !byte >sCheatsEnabled +sNoCheats + !byte 8 ; length + !text "no cheat" +sInfiniteLives + !byte 18 ; length + !byte $16 ; bolt character + !text " " + !text "infinite lives" + !text " " + !byte $16 ; bolt character +sInfiniteWeapons + !byte 20 ; length + !byte $16 ; bolt character + !text " " + !text "infinite weapons" + !text " " + !byte $16 ; bolt character +sInfiniteLivesAndWeapons + !byte 28 ; length + !byte $16 ; bolt character + !text " " + !text "infinite lives & weapons" + !text " " + !byte $16 ; bolt character +sInvincibility + !byte 14 ; length + !byte $16 ; bolt character + !text " " + !text "invincible" + !text " " + !byte $16 ; bolt character +sInGame + !byte 18 ; length + !byte $16 ; bolt character + !text " " + !text "in-game cheats" + !text " " + !byte $16 ; bolt character +sCheatsEnabled + !byte 18 ; length + !byte $16 ; bolt character + !text " " + !text "cheats enabled" + !text " " + !byte $16 ; bolt character +sCheatDescriptionPrefix + !byte 2 ; length + !byte $03 ; vertical line character + !text " " +sCheatDescriptionSuffix + !byte 2 ; length + !text " " + !byte $03 ; vertical line character + +;------------------------------------------------------------------------------ +; DrawUIWithoutDots/DrawUI +; draw 2- or 4-line UI on the HGR page that is not currently showing, then +; show that HGR page +; +; in: gGameToLaunch = game index (word), or #$FFFF if no game is selected +; out: all flags and registers clobbered +;------------------------------------------------------------------------------ +DrawUIWithoutDots + lda #$40 ; " " * 2 + +HIDE_NEXT_2_BYTES +DrawUI + lda #$FF ; #$7F * 2 + lsr + sta @printCursor+1 ; set up cursor printing based on entry point + php + + ldy #39 +- + lda Instructions,y + sta UILine2,y ; copy instructions to UI line 2 + lda #$00 ; horizontal bar character + sta UILine1,y ; reset UI line 1 to solid bar + sta gPathname,y ; reset cheat UI line 1 to solid bar + dey + bpl - + sta gGameToLaunchInfo ; reset gGameToLaunchInfo + lda #40 + sta gPathname ; hack, used by first RedrawForDHGR which follows + ; Draw40Chars which doesn't set gPathname + + jsr GetGameToLaunch ; get current game, if any + bcs @doneWithLine2 ; if no game, nothing more to do on UI line 2 + jsr GetGameDisplayName + ; A/Y -> game display name + bitfield of game info + +ST16 PTR + ldy #0 + lda (PTR),y ; A = game display name length + 1 + sta SAVE + tay + lda (PTR),y ; A = game info bitfield + sta gGameToLaunchInfo + ldy #0 +- iny +@printCursor + lda #$FD ; SMC + cpy SAVE + bcc @printTitleChar + beq @printChar + lda #" " + +HIDE_NEXT_2_BYTES +@printTitleChar + lda (PTR),y +@printChar + sta UILine2,y + cpy #MaxInputLength+1 + bcc - + + ldx #8 ; replace games count with 'to play' label +- lda ReturnToPlay,x + sta UI_ToPlay,x + dex + bpl - + +@doneWithLine2 + lda MachineStatus + and #CHEATS_ENABLED + beq @maybeDrawDots ; if cheat mode is disabled, we don't need + ; any curves or spaces on UI line 1 + jsr CheckCheats + ; (SAVE) -> length-prefixed string + ; (game-specific description or 'cheats enabled' message) + ldy #0 + lda (SAVE),y ; A = string length + clc + adc #4 ; extra padding (2 on each side) + sta @len + lda #40 + sec + sbc @len + lsr + tax + lda #$09 ; rounded bottom-right character + sta UILine1,x + iny ; fill the proper width with spaces + lda #$20 ; space character +- inx + sta UILine1,x + iny +@len=*+1 + cpy #$FD ; SMC + bne - + lda #$0C ; rounded bottom-left character + sta UILine1,x + +@maybeDrawDots + plp + bcc @doneHighlight ; if caller asked for no dots, then we're done building UI line 1 + + ldx #0 + ldy #0 +@dotloop + iny + lda (PTR),y ; (PTR) still points to game display name + game info bitfield + ora #$20 ; force lower-case always + cmp InputBuffer,x + bne + + lda #$11 ; dot character + sta UILine1,y + inx + cpx InputLength ; if input buffer is exhausted, we're done drawing dots + beq @doneHighlight ++ inc HTAB + cpy SAVE ; if game name is exhausted, we're done drawing dots + bne @dotloop +@doneHighlight + lda #22 + sta VTAB + lda OffscreenPage + ror + php + +LDADDR UILine1 + jsr Draw40Chars ; draw UI line 1 on offscreen page + jsr MaybeRedrawUIForDHGR ; transform for DHGR if this is a DHGR title screen + plp +gDrawingOnscreen=*+1 + lda #$00 ; SMC, might be 1 + bne @uidone + +LDADDR UILine2 + jsr Draw40Chars ; draw UI line 2 on offscreen page + jsr MaybeRedrawUIForDHGR ; transform for DHGR if this is a DHGR title screen + lda MachineStatus + and #CHEATS_ENABLED + beq @uidone ; if cheats are disabled, then we're done drawing UI + + ; (SAVE) still points to length-prefixed cheat description + ldy #0 + lda (SAVE),y ; A = length of cheat description + clc + adc #4 ; extra padding (2 on each side) + sta gPathname ; gPathname = length + tax + lda #$07 ; gPathname+length = top-right rounded corner character + sta gPathname,x + lda #$06 ; gPathname+1 = top-left rounded corner character + sta gPathname+1 + lda #20 + sta VTAB + lda OffscreenPage + ror + php + +LDADDR gPathname + jsr DrawCenteredString ; draw cheat UI line 1 + jsr MaybeRedrawUIForDHGR ; transform for DHGR if this is a DHGR title screen + jsr CheckCheats + ; (SAVE) -> length-prefixed cheat description + +LDADDR sCheatDescriptionPrefix + jsr SetPath + +LD16 SAVE + jsr AddToPath + +LDADDR sCheatDescriptionSuffix + jsr AddToPath + inc VTAB + plp + +LDADDR gPathname + jsr DrawCenteredString ; draw cheat UI line 2 + jsr MaybeRedrawUIForDHGR ; transform for DHGR if this is a DHGR title screen +@uidone lda #0 + sta gDrawingOnscreen + clc + jmp ShowOtherPage + +CheckCheats + ldx #kCheatsEnabled + jsr AnyGameSelected + bcs + +gGameToLaunchInfo=*+1 + lda #$FD ; SMC + and #CHEAT_CATEGORY + tax ++ + lda kCheatDescriptionLo,x + sta SAVE + lda kCheatDescriptionHi,x + sta SAVE+1 +- rts + +MaybeRedrawUIForDHGR + bit MachineStatus + bvc - + bit gGameToLaunchInfo + bpl - + jmp RedrawForDHGR diff --git a/src/ui.reboot.a b/src/ui.reboot.a new file mode 100644 index 0000000..7dc4b78 --- /dev/null +++ b/src/ui.reboot.a @@ -0,0 +1,24 @@ +;license:MIT +;(c) 2020 by qkumba/4am +; +; reboot system +; +; Public functions +; - OnQuit +; + +;------------------------------------------------------------------------------ +; OnQuit +; reboot system +; +; in: none +; out: nothing +;------------------------------------------------------------------------------ +OnQuit + jsr SwitchToBank2 + jsr EnableAcceleratorAndSwitchToBank1 +PatchQuit + inc $101 ; bank in ROM + +LDADDR ROM_REBOOT + +ST16 $104 + jmp $100 diff --git a/src/ui.search.mode.a b/src/ui.search.mode.a new file mode 100644 index 0000000..cf69fde --- /dev/null +++ b/src/ui.search.mode.a @@ -0,0 +1,263 @@ +;license:MIT +;(c) 2018-2020 by 4am +; +; Search Mode - main UI +; +; Public functions +; - SearchMode +; - SoftBell +; + +; indices into InputDispatchTable +kInputSearch = 0 +kInputClear = 1 +kInputBack = 2 +kInputBrowse = 3 +kInputTab = 4 +kInputLaunch = 5 +kInputHelp = 6 +kInputCredits = 7 +kInputCheat = 8 +kInputError = 9 +kInputJoystick = 10 +kInputQuit = 11 + +InputDispatchTableLo + !byte OnSearch + !byte >OnClear + !byte >OnBack + !byte >BrowseMode + !byte >OnTab + !byte >OnLaunch + !byte >Help + !byte >Credits + !byte >OnCheat + !byte >OnError + !byte >Joystick + !byte >OnQuit + +kNumInputKeys = 12 + ; number of entries in next 2 tables (each) +InputKeys + !byte $83 ; Ctrl-C = toggle cheat mode + !byte $81 ; Ctrl-A = about + !byte $AF ; '/' = help + !byte $BF ; '?' = help + !byte $A0 ; Space = mini attract mode + !byte $89 ; TAB = mini attract mode + !byte $88 ; left arrow = delete (may as well, since + ; popular emulators remap this anyway) + !byte $FF ; backspace = delete + !byte $8D ; ENTER = launch current game (if any) + !byte $9B ; Esc = clear input buffer (if any) + ; or switch to mega attract mode + !byte $90 ; Ctrl-P = launch joystick calibration program + !byte $91 ; Ctrl-Q = quit +InputKeyDispatch + !byte kInputCheat + !byte kInputCredits + !byte kInputHelp + !byte kInputHelp + !byte kInputTab + !byte kInputTab + !byte kInputBack + !byte kInputBack + !byte kInputLaunch + !byte kInputClear + !byte kInputJoystick + !byte kInputQuit + +.noKeyMatch + jsr IsSearchKey +!if kInputSearch > 0 { + +HIDE_NEXT_2_BYTES +.foundSearchKey + ldx #kInputSearch +} else { +.foundSearchKey +} + ; execution falls through here to .InputDispatch +.InputDispatch + ldy InputDispatchTableLo,x + sty .j+1 + ldy InputDispatchTableHi,x + sty .j+2 +.j jsr $FDFD ; SMC + bcc .SearchModeInputLoop ; if carry is clear, we're done + ; fall through to force full redraw + +;------------------------------------------------------------------------------ +; SearchMode +; main entry point for Search Mode, which allows the user to search the game +; catalog and launch games +; +; in: none +; out: never returns to caller (may JMP to other major modes) +;------------------------------------------------------------------------------ +SearchMode + ldx #$FF + txs + stx gGameToLaunch ; $FFFF = no game selected + stx gGameToLaunch+1 + jsr BuildSearchStore + jsr Home ; clear screen (switches to text mode) + stx OffscreenPage ; don't show text page 2 by accident + jsr OnInputChanged ; draw UI offscreen + jsr HGRMode ; show HGR screen + jsr ResyncPage + lda KBD + jsr IsSearchKey + lda CLEARKBD - kInputError,X + ; clear strobe if key was bad + +.SearchModeInputLoop + jsr WaitForKeyFor30Seconds + + ; Don't clear keyboard strobe yet. If the user pressed an arrow key, + ; we want to switch to Browse Mode with the keyboard still hot so + ; that mode finds and dispatches the arrow key. + + ldx #kInputBrowse + jsr IsUpDownOrRightArrow + beq .InputDispatch + bit CLEARKBD + + ldy #kNumBrowseKeys +- dey + bmi .noKeyMatch + cmp InputKeys,y + bne - + ldx InputKeyDispatch,y + bne .InputDispatch ; always branches + +OnClear + ldx #1 ; Esc with input clears the input + ldy InputLength + bne + + jmp CoverFade ; Esc with no input transitions to + ; mega attract mode +OnBack + ldx InputLength + beq OnError ++ dex + stx InputLength + bpl OnInputChanged ; always branches + +OnTab + jsr AnyGameSelected + bcs OnError + jsr MiniAttractMode + cmp #$8D ; if we exited mini attract mode + bne .req_redraw ; by pressing Enter, launch the game + +OnLaunch + ldx gGameToLaunch+1 + inx + beq OnError + jsr PlayGame + +.req_redraw + sec ; tell caller to redraw UI + rts + +OnCheat + dec gGameToLaunch ; force reload (will be reset to correct value in OnInputChanged) + jsr ToggleCheat + beq OnInputChanged ; always branches because Z=1 on exit from ToggleCheat + +OnSearch + ldx InputLength + cpx #MaxInputLength + beq OnError + sta InputBuffer,x + inc InputLength + ; execution falls through here to OnInputChanged +OnInputChanged + ldx InputLength + bne FindMatchingTitle + ; no input, reset params and UI + dex + stx gGameToLaunch ; $FFFF = no game selected + stx gGameToLaunch+1 + jsr LoadTitleOffscreen + jmp DrawUIWithoutDots + +FindMatchingTitle + jsr SwitchToBank2 + jsr EnableAcceleratorAndSwitchToBank1 + + jsr ResetTextRank + + jsr okvs_iter_values ; iterate through all game display names + !word gSearchStore ; and rank them for the best match + !word TextRankCallback ; to the current input buffer + + lda MatchCount ; any matches at all? + bne + + ; no matches for this input buffer + dec InputLength ; ignore the last key typed + +OnError + jsr SwitchToBank2 + jsr DisableAcceleratorAndSwitchToBank1 + ; /!\ execution falls through to SoftBell +;------------------------------------------------------------------------------ +; SoftBell +; yell at the user, but, like, gently +; +; in: none +; out: C clear +; Y preserved +; A=0 +; X=0 +; all flags preserved +;------------------------------------------------------------------------------ +SoftBell + ldx #32 +- lda #2 + jsr WaitForKeyWithTimeout + bit SPEAKER + lda #33 + jsr WaitForKeyWithTimeout + bit SPEAKER + dex + bne - + clc + rts + ++ + lda BestMatchIndex ; check if the new best match is the same + cmp gGameToLaunch ; as the current best match + bne @load + lda BestMatchIndex+1 + cmp gGameToLaunch+1 + bne @load + + jsr ToggleOffscreenPage ; Since we're not loading a new screenshot + ; we fake switching the 'offscreen' page + ; in order to draw on the visible page. + lda #1 + bne @noload ; always branches +@load + +LD16 BestMatchIndex + +ST16 gGameToLaunch + jsr LoadGameTitleOffscreen + lda #0 +@noload + sta gDrawingOnscreen ; will minimize flicker in case we're + jsr DrawUI ; drawing directly onscreen + + ; /!\ execution falls through to ui.animation/MaybeAnimateTitle diff --git a/src/ui.wait.a b/src/ui.wait.a new file mode 100644 index 0000000..4a78aad --- /dev/null +++ b/src/ui.wait.a @@ -0,0 +1,96 @@ +;License:MIT +;(c) 2018-2020 by 4am +; +; UI functions for doing things then waiting, or waiting then doing things +; +; - ExecuteTransitionAt6000AndWait +; - ExecuteTransitionAt6400AndWait +; - ExecuteTransitionAtA000AndWait +; - ExecuteTransitionAndWait +; - WaitForKeyFor30Seconds +; - CoverFade + +ExecuteTransitionAt6000AndWait + ldy #$60 + +HIDE_NEXT_2_BYTES +ExecuteTransitionAt6400AndWait + ldy #$64 + +HIDE_NEXT_2_BYTES +ExecuteTransitionAtA000AndWait + ldy #$A0 + ; /!\ execution falls through here to ExecuteTransitionAndWait +;------------------------------------------------------------------------------ +; ExecuteTransitionAndWait +; call transition effect code (address passed in) and wait a period of time +; or until the user presses a key +; +; in: A/Y = address of transition effect code +; out: all flags and registers clobbered +;------------------------------------------------------------------------------ +ExecuteTransitionAndWait + lda #0 + +ST16 @j+1 +@j jsr $FDFD ; SMC call transition effect code + ldx #$20 ; picture is showing so now we wait +- lda #0 + jsr WaitForKeyWithTimeout + bmi + + dex + bpl - ++ lda KBD + cmp #$95 + bne WAITRTS + bit CLEARKBD +WAITRTS rts + +;------------------------------------------------------------------------------ +; WaitForKeyFor30Seconds +; does what it says on the tin +; +; in: none +; out: if user presses a key before the timer runs out, exits with A = key +; and X/Y preserved +; otherwise exits via MegaAttractMode and everything is clobbered +;------------------------------------------------------------------------------ +WaitForKeyFor30Seconds + lda #$16 ; initialize timeout counters + sta Timeout + sta Timeout+1 + sta Timeout+2 +@loop + lda KBD + bmi WAITRTS + + inc RNDSEED+1 ; these are only ever incremented, never + bne + ; reset (may be used as a pseudorandom + inc RNDSEED ; seed) ++ + dec Timeout + bne @loop + dec Timeout+1 + bne @loop + dec Timeout+2 + bne @loop + ; /!\ execution falls through here to CoverFade +;------------------------------------------------------------------------------ +; CoverFade +; load cover file and execute a specific transition effect on it +; +; in: none +; out: exits via MegaAttractMode and everything is clobbered +;------------------------------------------------------------------------------ +CoverFade + jsr ForceHGRMode + jsr LoadCoverOffscreen + jsr ShowOtherPage + lda OffscreenPage + beq CoverFade + jsr LoadFile ; load transition effect code at $6000 + !word kFXDirectory + !word kCoverFadeFile + !word $6000 + jsr $6000 ; call transition effect + jmp MegaAttractMode ; exit via mega attract mode +!if (RELBASE != $2000) and (>WaitForKeyFor30Seconds != >*) { + !error "WaitForKeyFor30Seconds crossed a page (", WaitForKeyFor30Seconds, " to ", * +} diff --git a/src/wait.a b/src/wait.a new file mode 100644 index 0000000..594834e --- /dev/null +++ b/src/wait.a @@ -0,0 +1,21 @@ +;license:MIT +;(c) 2018-9 by 4am +; + +; This file is included from multiple assembly targets, +; so it should only have 1 function. + +WaitForKeyWithTimeout +; in: A = timeout length (like standard $FCA8 wait routine) +; out: A clobbered +; X/Y preserved + sec +@wait1 pha +@wait2 sbc #1 + bne @wait2 + pla + bit $C000 + bmi @exit + sbc #1 + bne @wait1 +@exit rts