Merge of bugz-ansi.

We have our nice build_images.sh
We have ansi-to-src !
We have our graphic files.
We have our images.cpp to display
all the "in the binary" images.
We have the images that we used.
Still need to update ghost to latest BZ one.

CMakeLists.txt

@@ -78,7 +78,7 @@ add_subdirectory(zf_log)
 # )
 # add_executable(yourProj ${SOURCES})
 
-add_executable(mystic mystic.cpp lastseen.cpp terminal.cpp render.cpp)
+add_executable(mystic mystic.cpp lastseen.cpp terminal.cpp render.cpp utils.cpp)
 target_link_libraries(mystic util)
 target_link_libraries(mystic zf_log)
 target_compile_definitions(mystic PUBLIC ZF_LOG_DEF_LEVEL=ZF_LOG_VERBOSE)
@@ -86,5 +86,8 @@ target_compile_definitions(mystic PUBLIC ZF_LOG_DEF_LEVEL=ZF_LOG_VERBOSE)
 add_executable(try-re try-re.c)
 
 add_executable(ansi-color ansi-color.c)
-add_executable(ansi-to-src ansi-to-src.cpp)
+add_executable(ansi-to-src ansi-to-src.cpp utils.cpp)
+
+add_executable(images images.cpp render.cpp terminal.cpp utils.cpp)
+target_link_libraries(images zf_log)
 

ansi-to-src.cpp

@@ -4,97 +4,7 @@
 
 #define ZF_LOGD(...)
 
-/**
- * Display a repr of the given string.
- *
- * This converts most \n\r\v\f\t codes,
- * defaults to \xHH (hex value).
- */
-char *repr(const char *data) {
-  static char buffer[40960];
-  char *cp;
-
-  strcpy(buffer, data);
-  cp = buffer;
-  while (*cp != 0) {
-    char c = *cp;
-
-    if (c == ' ') {
-      cp++;
-      continue;
-    };
-    /* Ok, it's form-feed ('\f'), newline ('\n'), carriage return ('\r'),
-     * horizontal tab ('\t'), and vertical tab ('\v') */
-    if (strchr("\f\n\r\t\v\?", c) != NULL) {
-      memmove(cp + 1, cp, strlen(cp) + 1);
-      *cp = '\\';
-      cp++;
-      switch (c) {
-      case '\f':
-        *cp = 'f';
-        cp++;
-        break;
-      case '\n':
-        *cp = 'n';
-        cp++;
-        break;
-      case '\r':
-        *cp = 'r';
-        cp++;
-        break;
-      case '\t':
-        *cp = 't';
-        cp++;
-        break;
-      case '\v':
-        *cp = 'v';
-        cp++;
-        break;
-      default:
-        *cp = '?';
-        cp++;
-        break;
-      }
-      continue;
-    }
-
-    if (c == '\\') {
-      memmove(cp, cp + 1, strlen(cp) + 1);
-      *cp = '\\';
-      cp += 2;
-      continue;
-    }
-    if (c == '"') {
-      memmove(cp, cp + 1, strlen(cp) + 1);
-      *cp = '\\';
-      cp += 2;
-      continue;
-    }
-    if (strchr("[()]{}:;,.<>?!@#$%^&*", c) != NULL) {
-      cp++;
-      continue;
-    }
-    if (strchr("0123456789", c) != NULL) {
-      cp++;
-      continue;
-    }
-    if (strchr("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", c) !=
-        NULL) {
-      cp++;
-      continue;
-    }
-
-    // Ok, default to \xHH output.
-    memmove(cp + 3, cp, strlen(cp) + 1);
-    char buffer[10];
-    sprintf(buffer, "\\x%02x", (int)c & 0xff);
-    strncpy(cp, buffer, 4);
-    cp += 4;
-    continue;
-  }
-
-  return buffer;
-}
+#include "utils.h"
 
 int read_file(const char *filename) {
   FILE *fp;
@@ -119,7 +29,7 @@ int read_file(const char *filename) {
       memmove(cp, cp + 1, strlen(cp));
     cp++;
   }
-  printf("const char * %s[] = {\n", buffer);
+  printf("char * %s[] = {\n", buffer);
 
   if ((read = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
     char *nl;

bat.ans

@@ -0,0 +1,14 @@
+
+..=-..-=..
+._..-`()`-.._
+,/./'_'.]]]\\ú(\_/).//[[[.`-`\.\,
+ ..//'i]'.].]]]]]\\úú)o o(.ú//[[[[[.[.`[i`.\..
+./``,]]'.]]].]]]]]]\```````.'`ě``.'''''''/[[[[[[.[[[.`[[,``\,
+./`,]]]'.]]]]].]]]]]]]]]]]]]]( ^!^)[[[[[[[[[[[[[[.[[[[[.`[[[,`\.
+    /`,i]]]'.i]]]]]].]]]]]]]]]]]]]]{`:!:'}[[[[[[[[[[[[[[.[[[[[[i..[[[i,`\
+  /`.]]]]]'.]]]]]]]].]]]]]]]]]]]]]][;:!;'][[[[[[[[[[[[[[.[[[[[[[[.`[[[[[.`\
+,/`.]]]]]'i]]]]]]]]].]/'``\]]:`:!:':[[/''`\[.[[[[[[[[[i`[[[[[.`\`
+l`/'   `\:\'`\:\'\]]"@:[[/`\:/'`\:/'   `\'l
+l/Vv}='\:II/`={vV\l
+V``\I/`V
+`V`

build_images.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+./ansi-to-src skull.ans > images.h
+./ansi-to-src skull-blink.ans >> images.h
+./ansi-to-src ghead.ans >> images.h
+./ansi-to-src ghost.ans >> images.h
+./ansi-to-src wolf.ans >> images.h
+./ansi-to-src panther.ans >> images.h
+
+./ansi-to-src bat.ans >> images.h
+
+# ./ansi-to-src bat.ans > bat.h
+

ghead.ans

@@ -0,0 +1,23 @@
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾜﾜﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ ﾜﾛﾛﾟ ﾜﾜﾜﾜﾜﾟﾟﾛﾛﾛﾜ ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛ  ﾜﾛﾟ ﾜﾜﾜ  ﾟﾟﾛﾛﾜ  ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛ    ﾟﾛﾛﾛ  ﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛ  ﾜﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜ  ﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾜ   ﾜﾛﾛﾟ ﾜﾛﾛ  ﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾜ ﾟﾛﾛﾜﾜ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾛﾛﾛﾛﾛﾛﾛ  ﾟﾛﾛﾛﾜﾜﾜﾜﾜﾜﾛﾛﾟ  ﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾜ  ﾟﾛﾛﾛﾜﾜﾜﾜﾜﾜﾛﾛﾟﾟ  ﾜ  ﾟﾟﾛﾛﾛﾜ  ﾛﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾛﾛﾛﾟﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾟﾟﾟﾟﾟﾟ  ﾜﾛﾛﾛﾛﾛﾜ  ﾛﾛﾛﾜ  ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾟﾟ  ﾜﾜﾛﾛﾟﾟ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾜﾜﾛﾛﾛﾛﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟ  ﾜﾜﾜﾜﾜ  ﾟﾟﾟﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜ  ﾟﾟﾟﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾜ  ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛ  ﾜﾛﾛﾛﾛﾛﾛﾛﾟﾟ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛ  ﾟﾛﾛﾛﾛﾛ ﾜﾜ ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟ ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟ  ﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾜﾜ  ﾟﾟﾛﾛﾛﾛﾛﾛﾜﾜﾜ ﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟ  ﾜﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟ  ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜ  ﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜ  ﾟﾟﾟﾟﾟ ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟ  ﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜﾜ  ﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾜﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜ  ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜ  ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾟﾟ   ﾜﾛﾛﾛﾉﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍｻﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾛ  ﾛﾛﾛﾛｺ Screen: Pretty Please  ｺﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾛﾈﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍﾍｼﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ

ghost.ans

@@ -0,0 +1,23 @@
+[?7hﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+    ﾛ  ﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ  ﾛ  ﾛ
+   ﾛﾛ ﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛ ﾛﾛ
+   ﾛﾛ ﾛﾛ ﾛﾛﾛ ﾛﾛﾛﾛﾛﾛ  ﾛﾛﾛﾛ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ
+    ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ   ﾛﾛﾛ   ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ    ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ    ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛ   ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜ    ﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ

images.cpp

@@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "images.h"
+#include <iconv.h>
+
+class IConv {
+  iconv_t ic;
+
+public:
+  IConv(const char *to, const char *from) : ic(iconv_open(to, from)) {}
+  ~IConv() { iconv_close(ic); }
+
+  int convert(char *input, char *output, size_t outbufsize) {
+    size_t inbufsize = strlen(input);
+    size_t orig_size = outbufsize;
+    memset(output, 0, outbufsize);
+
+    return iconv(ic, &input, &inbufsize, &output, &outbufsize);
+  }
+};
+
+IConv converter("UTF-8", "CP437");
+
+#include "terminal.h"
+struct console_details console;
+
+char display_line(char *line) {
+  char output[1024];
+  int len;
+
+  converter.convert(line, output, sizeof(output));
+  printf("%s\n", output);
+}
+
+int main() {
+  int x;
+  int size = (sizeof(skull) / sizeof(char *));
+
+  for (x = 0; x < size; x++) {
+    display_line(skull[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(skullblink) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(skullblink[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(ghead) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(ghead[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(ghost) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(ghost[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(wolf) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(wolf[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(panther) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(panther[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+  size = (sizeof(bat) / sizeof(char *));
+  for (x = 0; x < size; x++) {
+    display_line(bat[x]);
+  }
+
+  fflush(stdout);
+  getchar();
+  printf("\n\n");
+
+
+  return 0;
+}

mystic.cpp

@@ -76,115 +76,13 @@ static void file_output_open(const char *const log_path) {
 
 struct console_details console;
 
-/**
- * Display a repr of the given string.
- *
- * This converts most \n\r\v\f\t codes,
- * defaults to \xHH (hex value).
- */
-const char *repr(const char *data) {
-  static char buffer[4096];
-  char *cp;
-
-  strcpy(buffer, data);
-  cp = buffer;
-  while (*cp != 0) {
-    char c = *cp;
-
-    if (isspace(c)) {
-      if (c == ' ') {
-        cp++;
-        continue;
-      };
-      /* Ok, it's form-feed ('\f'), newline ('\n'), carriage return ('\r'),
-       * horizontal tab ('\t'), and vertical tab ('\v') */
-      memmove(cp + 1, cp, strlen(cp) + 1);
-      *cp = '\\';
-      cp++;
-      switch (c) {
-      case '\f':
-        *cp = 'f';
-        cp++;
-        break;
-      case '\n':
-        *cp = 'n';
-        cp++;
-        break;
-      case '\r':
-        *cp = 'r';
-        cp++;
-        break;
-      case '\t':
-        *cp = 't';
-        cp++;
-        break;
-      case '\v':
-        *cp = 'v';
-        cp++;
-        break;
-      default:
-        *cp = '?';
-        cp++;
-        break;
-      }
-      continue;
-    }
+#include "utils.h"
 
-    if (isprint(c)) {
-      cp++;
-      continue;
-    };
-
-    // Ok, default to \xHH output.
-    memmove(cp + 3, cp, strlen(cp) + 1);
-    *cp = '\\';
-    cp++;
-    *cp = 'x';
-    cp++;
-    char buffer[3];
-    sprintf(buffer, "%02x", (int)c & 0xff);
-    *cp = buffer[0];
-    cp++;
-    *cp = buffer[1];
-    cp++;
-    continue;
-  }
-
-  return buffer;
-}
 
 // END LOGGING
 
 #include "lastseen.h"
 
-// http://c-faq.com/lib/randrange.html
-int randint(int N) { return rand() / (RAND_MAX / N + 1); }
-
-// http://c-faq.com/lib/randrange.html
-// numbers in the range [M, N] could be generated with something like
-
-int randrange(int M, int N) {
-  return M + rand() / (RAND_MAX / (N - M + 1) + 1);
-}
-
-/*
- * strnstr()
- *
- * buffer safe version that looks for a string.
- */
-const char *strnstr(const char *source, int len, const char *needle) {
-  int pos;
-
-  for (pos = 0; pos < len; pos++) {
-    if (source[pos] == needle[0]) {
-      if (strncmp(source + pos, needle, strlen(needle)) == 0) {
-        return source + pos;
-      }
-    }
-  }
-  return NULL;
-}
-
 /*
 What is the name of the actual, real Mystic executable
 that we'll be executing and mangling?
@@ -612,6 +510,11 @@ int mangle(int fd, const char *buffer, int len) {
   process.
   */
 
+  /*
+  Is there a way to track -- what I've inserted, and make it exempt from
+  other modifications / mangler, wrangler?
+   */
+
   /*
    (random) Look for ANSI CLS and:
 
@@ -714,6 +617,11 @@ int mangle(int fd, const char *buffer, int len) {
         if (random_activate(4)) {
           int r;
           char display[100] = "";
+          /* 
+          Interesting note here:
+          "Anyone there" qualifies as a valid WORDS regex match.
+          It is possible that it can get mangled/wrangled!
+          */
           const char *phrasing[] = {"^R1Haha^P1ha^P1ha", "Poof!", "Got U",
                                     "Anyone there?", "^R1Knock, ^P1Knock",
                                     "^G0101^C07^S6Segmentation Fault ^P1^S9(core ^C12^C24dumped^C07)^P2"};
@@ -792,6 +700,9 @@ int mangle(int fd, const char *buffer, int len) {
 
   // strcpy(work, buffer); // sure.
 
+  // NOTE: This is NOT aware of my ^TRIGGERS, so they will show up
+  // as valid things to mangle in work.  (Keep this in mind).
+
   const char replace_with = ' ';
   for (x = 0; x < len; x++) {
     int ansi = console_char(&console, play[x]);
@@ -898,6 +809,8 @@ int harry_happens(time_t *last_event, int wakeup) {
 
 /*
 
+This is done.  :D  My buffering system works with stack'em.  
+
 TO FIX:  Stop using c strings, must use char * buffer + int length.
 MAY CONTAIN NULL VALUES.
 
@@ -945,6 +858,8 @@ This allows for cleaner process of "lines" of buffer.  We shouldn't break
 in the midDLE OF A WORD.  Downside is that we sit on buffer contents a little
 while / some amount of time -- which will add some lag to prompts showing up.
 
+(LAG?  Are you kidding?)
+
 
 ZModem:
 
@@ -966,32 +881,6 @@ ZModem:
 
  */
 
-/*
- * rstrnstr() Reverse string find in a string
- *
- * This obeys the len, and handles nulls in buffer.
- * find is a c-string (null terminated)
- */
-int rstrnstr(const char *buffer, int len, const char *find) {
-  int flen = strlen(find);
-
-  if (len < flen) {
-    // I can't find a string in a buffer smaller then it is!
-    return -1;
-  }
-  int pos = len - flen;
-  while (pos > 0) {
-    if (buffer[pos] == find[0]) {
-      // First chars match, check them all.
-      if (strncmp(buffer + pos, find, flen) == 0) {
-        return pos;
-      }
-    }
-    pos--;
-  }
-  return -1;
-}
-
 int main(int argc, char *argv[]) {
   int master;
   pid_t pid;

panther.ans

@@ -0,0 +1,23 @@
+[?7hﾜﾜﾛﾛｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱﾛﾛﾜﾜ
+ﾜﾛﾛｱｱｱｱｱｱﾛﾛﾛﾛｱｱ ｱｱﾛﾛﾛﾛｱｱｱｱｱﾛﾛ
+ ﾛ  ｰﾜﾜﾜﾛｰｰｰｰﾛﾛﾛﾛﾛｱｱｱｱｱﾛｱｰ ｰｱﾛｱｱｱｱｱﾛﾛﾛｰｰｰﾛﾜﾜ
+  ﾛ ｰﾛﾛﾟ  ﾜﾄ  ﾜﾜﾜﾛﾟﾟﾛ    ｰｰｰ       ｱｱﾛ ﾞﾞﾛｱｱ ﾛﾛ  ﾟｰｰﾛﾜ ﾛﾟﾟﾛﾜﾜ
+  ｰｰｰﾛﾛｰ  ﾜﾜﾛﾟﾟﾟ  ﾜﾛﾛﾛﾟﾟ ﾛﾜ ﾟﾟﾜﾜﾜﾛﾛﾛﾛｱ   ｱﾛﾛﾛﾛﾜﾜﾜﾟﾟ ﾛ ﾟ ﾛ  ﾟﾟﾟﾟﾜﾜ
+  ｰｰｰｰ ﾛ ﾟﾟﾟﾟﾛﾜﾜ   ﾛﾛﾛﾛﾛﾜﾟﾟﾟﾜ  ﾟﾟﾛﾜﾛﾛﾟﾛ ﾛﾟ ﾛﾜﾛﾟﾛﾛ ﾜﾟ ﾟﾜ ﾛﾛ   ﾜﾛﾟﾟﾟ
+    ｰｰｰﾟﾛ ﾜ ﾟﾛﾜﾟ ﾛﾛ ﾜﾟﾜ    ﾛ       ﾛ    ﾜﾟﾜ ﾛﾛ ﾜ ﾛﾟ
+    ｰｰ ｰｰﾛﾛﾝ ﾛﾛ  ﾟﾟﾟﾟﾟ ﾟﾟﾟｰｰﾜﾜﾟﾟﾟﾜﾜｰｰﾟﾟﾟ ﾟﾟﾟﾟﾟ  ﾟ ﾜﾟ
+ｰﾛｱｱｱ  ﾜﾜﾛﾜﾜﾜﾜ ﾜﾟﾟﾜｰｰﾟﾟﾟｰｰﾜﾟﾟ ﾜﾜﾜﾜﾛﾜﾜ  ﾟｱｱﾛ
+ﾞｱｱｱﾜﾜﾟ       ﾟﾜ ﾟ�ﾟﾟﾟﾟﾟﾟﾟ�ﾟﾟ ﾛﾛﾛﾛﾛﾛﾟﾟﾜｱｱｱﾝ
+  ｰ ｰ  ｰｰ ｰｰｰ    ﾞﾛｱｱｱｱﾛﾛﾟﾛ ﾟﾛﾟ ﾟ  ﾟﾛﾛﾛ ﾛﾛﾛﾟﾟ ﾟﾛﾟ ﾟ  ｰｰｰﾛﾝ
+ ｰ  ｰｰｰｰｰｱｰｰｱﾛｰｰﾟﾟﾟﾟﾟ ﾟﾟﾟ ﾟﾟｰｰﾛｱｰ
+ｰｰｰｰｰｰｰﾟﾜﾟﾛﾟﾜ ｰｰｰANSI by
+    ｰｰｰｰﾟｱｰｰﾟﾜﾜｰｰｰﾜﾞ ﾝﾜｰｰｰﾜ ｰﾜﾟGROO
+ｰｰﾟｱｰ  ﾟﾟﾞﾛﾞﾝﾛﾝﾛﾛﾞﾛﾝﾛﾛﾝﾝﾛﾛﾞﾝﾛﾝﾟﾟ ｰﾟｰ
+ｰｰｰ ｰｰ ｰ  ﾞﾞｲｱﾟｰｲﾟｰﾟｲｰﾛﾟｰ ﾞﾞｰ ｰﾟ  ｱ
+ｰﾟﾜｰ  ﾝﾝﾞﾛﾛﾛﾛｱｱｱﾛﾛﾛﾛﾝ ﾝﾝ ｰｰﾟ  ｰｰｱ
+ｰ   ｰｰﾟﾜ  ﾞﾝ ﾛﾛﾛﾛｱｱｱﾛﾛﾛﾛ  ﾞﾜﾟﾟ    ｰ   ﾜ   ﾜ   ﾜ  ﾜﾜ
+ｰ    ｰｰ  ｰﾟﾜﾜﾜ  ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ   ﾜﾜ    ｰ    ﾛｰｱﾛﾛｱｱﾛﾛｰｱｰﾛﾟｲｰ
+ｰ ｰｰｰ ｰﾛｲ ﾛﾝﾛﾛﾛﾛﾛﾛﾛﾛﾝﾛﾜｲｱｱｱﾛｱｲﾛｰｰｱｲﾛｰｰｰ
+ｰｰ ｰ   ｰﾛﾝ ﾞﾝｲﾛﾛﾛﾛﾛﾛｲﾛﾝ ﾛﾝﾜｰｱｱｱｱ  ｱｲｲ    ﾟﾛ    ﾝ
+ｰｰｰｰｰｰｰ ｱｰﾝﾞﾛﾛﾞﾝﾝﾛﾞﾞﾝﾞﾝﾞﾝﾜｰﾟ ﾛｱ   ｱｲｱﾞ
+ｰｰ  ｰ ｰｰｰｰﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾝ   ﾜﾟ    ｰｱ

show_bat_issue.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+echo ""; ./show bat.ans
+
+

show_skull_issue.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+echo ""; ./show skull.ans
+
+read -p "Press [ENTER] to view skull-blink"
+
+echo ""; ./show skull-blink.ans
+

skull-blink.ans

@@ -0,0 +1,13 @@
+    ｱｰｰｰｲｲｱ   
+   ｱｰｰｰﾛﾛﾛﾛｲｲｰｰ    
+  ｱｰｰｰﾛﾛﾛﾛﾛﾛｲｲｰｰ   
+ ｱｱｱｱｰﾛﾛﾛﾛﾛﾛﾛｲｰｰｱｰ 
+ ｱｱﾛﾛｱｰﾛﾛﾛﾛﾛﾛｱｰﾛｰｰ 
+ ｱｰｰｱｲｱｱﾛﾛﾛｰｱｲｱｱｰﾛ 
+  ｱｰｰｱｰﾛﾛ ﾛﾛｰｱｱﾛﾛ  
+  ｱｰｰﾛﾛ ｲ ﾛﾛｰｰｰ  
+   ﾛｰﾛｲｱﾛﾛﾛﾛ   
+  ｰｰﾞﾝ ｲﾝ ｰ  
+             
+  ｰｲﾝ ﾝｰﾞｰ   
+  ｱｰｰ ｰｰ   

skull.ans

@@ -0,0 +1,13 @@
+    ｱｰｰｰｲｲｱ   
+   ｱｰｰｰﾛﾛﾛﾛｲｲｰｰ    
+  ｱｰｰｰﾛﾛﾛﾛﾛﾛｲｲｰｰ   
+ ｱｱｱｱｰﾛﾛﾛﾛﾛﾛﾛｲｰｰｱｰ 
+ ｱｱﾛﾛｱｰﾛﾛﾛﾛﾛﾛｱｰﾛｰｰ 
+ ｱｰｰｱｲｱｱﾛﾛﾛｰｱｲｱｱｰﾛ 
+  ｱｰｰｱｰﾛﾛ ﾛﾛｰｱｱﾛﾛ  
+  ｱｰｰﾛﾛ ｲ ﾛﾛｰｰｰ  
+   ﾛｰﾛｲｱﾛﾛﾛﾛ   
+  ｰｰﾞﾝ ｲﾝ ｰ  
+             
+  ｰｲﾝ ﾝｰﾞｰ   
+  ｱｰｰ ｰｰ   

utils.cpp

@@ -0,0 +1,152 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "utils.h"
+
+// http://c-faq.com/lib/randrange.html
+int randint(int N) { return rand() / (RAND_MAX / N + 1); }
+
+// http://c-faq.com/lib/randrange.html
+// numbers in the range [M, N] could be generated with something like
+
+int randrange(int M, int N) {
+  return M + rand() / (RAND_MAX / (N - M + 1) + 1);
+}
+
+/**
+ * Display a repr of the given string.
+ *
+ * This converts most \n\r\v\f\t codes,
+ * defaults to \xHH (hex value).
+ */
+char *repr(const char *data) {
+  static char buffer[40960];
+  char *cp;
+
+  strcpy(buffer, data);
+  cp = buffer;
+  while (*cp != 0) {
+    char c = *cp;
+
+    if (c == ' ') {
+      cp++;
+      continue;
+    };
+    /* Ok, it's form-feed ('\f'), newline ('\n'), carriage return ('\r'),
+     * horizontal tab ('\t'), and vertical tab ('\v') */
+    if (strchr("\f\n\r\t\v\?", c) != NULL) {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp++;
+      switch (c) {
+      case '\f':
+        *cp = 'f';
+        cp++;
+        break;
+      case '\n':
+        *cp = 'n';
+        cp++;
+        break;
+      case '\r':
+        *cp = 'r';
+        cp++;
+        break;
+      case '\t':
+        *cp = 't';
+        cp++;
+        break;
+      case '\v':
+        *cp = 'v';
+        cp++;
+        break;
+      default:
+        *cp = '?';
+        cp++;
+        break;
+      }
+      continue;
+    }
+
+    if (c == '\\') {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp += 2;
+      continue;
+    }
+    if (c == '"') {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp += 2;
+      continue;
+    }
+    if (strchr("[()]{}:;,.<>?!@#$%^&*", c) != NULL) {
+      cp++;
+      continue;
+    }
+    if (strchr("0123456789", c) != NULL) {
+      cp++;
+      continue;
+    }
+    if (strchr("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", c) !=
+        NULL) {
+      cp++;
+      continue;
+    }
+
+    // Ok, default to \xHH output.
+    memmove(cp + 3, cp, strlen(cp) + 1);
+    char buffer[10];
+    sprintf(buffer, "\\x%02x", (int)c & 0xff);
+    strncpy(cp, buffer, 4);
+    cp += 4;
+    continue;
+  }
+
+  return buffer;
+}
+
+/*
+ * strnstr()
+ *
+ * buffer safe version that looks for a string.
+ */
+const char *strnstr(const char *source, int len, const char *needle) {
+  int pos;
+
+  for (pos = 0; pos < len; pos++) {
+    if (source[pos] == needle[0]) {
+      if (strncmp(source + pos, needle, strlen(needle)) == 0) {
+        return source + pos;
+      }
+    }
+  }
+  return NULL;
+}
+
+/*
+ * rstrnstr() Reverse string find in a string
+ *
+ * This obeys the len, and handles nulls in buffer.
+ * find is a c-string (null terminated)
+ */
+int rstrnstr(const char *buffer, int len, const char *find) {
+  int flen = strlen(find);
+
+  if (len < flen) {
+    // I can't find a string in a buffer smaller then it is!
+    return -1;
+  }
+  int pos = len - flen;
+  while (pos > 0) {
+    if (buffer[pos] == find[0]) {
+      // First chars match, check them all.
+      if (strncmp(buffer + pos, find, flen) == 0) {
+        return pos;
+      }
+    }
+    pos--;
+  }
+  return -1;
+}
+

utils.h

@@ -0,0 +1,23 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+// http://c-faq.com/lib/randrange.html
+int randint(int N);
+
+// http://c-faq.com/lib/randrange.html
+// numbers in the range [M, N] could be generated with something like
+
+int randrange(int M, int N);
+
+/**
+ * Display a repr of the given string.
+ *
+ * This converts most \n\r\v\f\t codes,
+ * defaults to \xHH (hex value).
+ */
+char *repr(const char *data);
+const char *strnstr(const char *source, int len, const char *needle);
+int rstrnstr(const char *buffer, int len, const char *find);
+
+#endif
+

wolf.ans

@@ -0,0 +1,23 @@
+ﾛﾛﾛﾛﾛﾛｰﾛﾛｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛﾛｰﾛｰﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｱﾛﾛﾛﾛﾛｰ
+ﾛﾛﾛﾛｱｱﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｰﾛｱﾛﾛﾛｱﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ｰﾛﾛ.ﾛﾛﾛﾛﾛﾛｰﾛｱﾛｲﾛ
+ﾛﾛﾛｱﾛｲﾛﾛﾛｰﾛﾛﾛﾛ  ｳ  ﾛﾛﾛﾛﾛﾛｰﾛｲﾛｱｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ. ｰｲｰﾛﾛﾛﾛﾛﾛﾛﾛｰﾛｰﾛﾛ
+ ﾛﾛﾛｱ ｱｰﾛｰﾛﾛﾛ ﾄﾄ ﾄﾄ ﾛﾛﾛﾛﾛｰﾛｱｲｰﾛｱﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜﾛﾛﾛｲﾛﾛｰﾛﾛﾜﾜﾜ ﾛﾛﾛﾛﾛﾛﾛﾛｰﾛｲｱｰﾛﾛﾛﾛﾛﾛ.ﾛｱﾛｰ
+ﾛﾛ.ﾛｰｱﾛﾛﾛﾛﾛﾛ    ｳ  ﾛﾛﾛﾛ ｰﾛｰｰﾛｱﾛﾛﾛﾛ  ﾜﾛﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲﾛｰﾛﾛﾛﾜ   ﾛﾛﾛ ﾛｰｰｱｲﾛﾛﾛﾛﾛﾛﾛﾛｱﾛ
+ﾛﾛﾛﾛｰﾛｰ.ｰﾛﾛﾛﾛﾛﾛ  ﾛ ﾛﾛﾛﾛﾛ ｰﾛｱﾛｰﾛﾛﾛ ﾜﾛﾛﾛﾝ ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲﾛｱﾛﾛﾜ  ﾛ ｱﾛｱﾛｰﾛﾛﾛﾛﾛﾛﾛｱﾛﾛﾛ
+ﾛﾛｰﾛ.ﾛﾛﾛﾛﾛﾛ .ﾛﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛｰｰｱｰﾛ   ﾜﾛﾛｰﾛﾛﾜ   ﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛｰﾛﾛﾜ  ｰﾛﾛ.ﾛﾛｱｰﾛﾛ.ﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛｰﾛｰ     ﾛﾛﾛｰﾛﾛﾛﾛﾛﾛﾛﾛｱ ｰｱﾛﾛﾛﾞﾛｰﾛﾛﾛﾛﾛﾛﾟﾜﾜﾟﾟﾛﾛﾛﾛｱﾛﾝ ﾛﾛﾛﾛﾛｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛ ﾜﾜﾛ     ｰﾛｰﾛ.ﾛﾛﾛﾛﾛﾛ ｰﾛｱﾛﾛﾛﾛﾛﾛｰﾛﾛｱﾛﾛﾟ ﾜﾟ ﾜﾛﾟ ﾜﾜﾜﾟﾟﾛﾛﾛｰﾛﾛﾛﾛﾛﾛｰﾛｰﾛﾛｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛﾛﾛﾛ   ﾜﾜﾜｱｰｱﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｰｱﾛﾛﾛﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾛﾟﾟ
+ﾛﾛ ﾛﾛﾛｰ .ﾛﾛﾛﾛﾝｰ ｱ ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾞﾛﾛﾛﾜ
+ﾛ.ﾛﾞﾛｰｰｰ ﾛﾛﾛｰﾝｰｱ ﾞﾛﾛｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｰﾛﾛﾛﾛﾛﾛﾜﾜ
+   ﾞﾛｰｰﾝｰﾛﾛｰｰﾝｱ.ｱﾞﾛﾛｰﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛﾛｰﾛｲｰﾛﾛﾛﾜﾜﾜﾜ
+ﾛﾛﾛﾞﾛｰﾝｱﾛﾛｰｰﾝｰ ﾜﾛﾛｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾛﾛﾛｰﾛﾛﾛｰﾛﾛﾛｱﾛﾜ
+ﾛ. ﾞﾛｰﾝｰﾛｰｰﾝﾜﾛﾛｰ ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾟﾛｲﾛｱﾛｰﾛｲﾛｲﾛﾛ
+ﾛｰﾛｰﾛﾜﾛｰｰﾛﾛｰ ﾟﾛﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛ    ﾟﾟﾟﾟﾟﾟﾟﾟﾟ
+ﾛﾛｱｱﾟﾛﾛｰｰﾛﾛﾛﾟﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾝ
+ｱｰ ｱﾛ   ﾝ  ｰｰﾛﾛﾛ ﾛﾛﾛｰｰｰ   ｰｰｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛｰﾛﾛ. ﾝ  ｰｰﾛｰｰｰｰｰｰ ｰ ｰ ｰ  ｰｰ ｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ.ﾛﾛﾛﾛﾛﾛﾝ
+ﾛｱﾛﾛﾛﾛﾛｰ    ｰ ｰ ｰｰ   ｰ  ｰｰ  ｰｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
+ﾛﾛﾛﾛｰ ｰｰｰ   ｰ    ｰ  ｰｰｰ ｰｰｰ  ｰｰｰ ｰｰｰ ｰｰﾛﾛﾛﾟﾟ
+ﾛﾛﾛﾛﾛﾛﾛﾛ    ｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟ
+ﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟﾟ    Screen by ANSI-Mation! (C) 1989.