From 57eca1dee931ce97cd8e37e412aae81bcb4fb47f Mon Sep 17 00:00:00 2001
From: water111 <48171810+water111@users.noreply.github.com>
Date: Sat, 27 Feb 2021 14:40:18 -0500
Subject: [PATCH] [Decomp] Decompile more files. (#290)

* decompile ocean trans tables

* more

* exclude tables from decomp progress

* format'
---
 common/goos/PrettyPrinter.cpp                 |     8 +-
 decompiler/IR2/FormExpressionAnalysis.cpp     |     5 +-
 decompiler/ObjectFile/ObjectFileDB_IR2.cpp    |     2 +-
 decompiler/config.cpp                         |     6 +-
 decompiler/config.h                           |     7 +-
 decompiler/config/all-types.gc                |   356 +-
 .../jak1_ntsc_black_label/label_types.jsonc   |    76 +-
 decompiler/util/data_decompile.cpp            |   148 +-
 decompiler/util/data_decompile.h              |    14 +
 goal_src/engine/data/art-h.gc                 |    30 +
 goal_src/engine/data/res-h.gc                 |    34 +
 goal_src/engine/engine/engines.gc             |    10 +
 goal_src/engine/game/game-info-h.gc           |   345 +-
 goal_src/engine/gfx/generic/generic-vu1-h.gc  |    39 +
 goal_src/engine/gfx/merc/merc-h.gc            |   389 +
 goal_src/engine/gfx/mood-h.gc                 |   137 +
 goal_src/engine/gfx/ocean/ocean-frames.gc     | 16389 ++++++++++++++++
 goal_src/engine/gfx/ocean/ocean-h.gc          |     1 +
 .../engine/gfx/ocean/ocean-trans-tables.gc    |  1088 +
 goal_src/engine/gfx/shadow/shadow-cpu-h.gc    |   258 +
 goal_src/engine/gfx/shadow/shadow-vu1-h.gc    |     1 +
 goal_src/engine/gfx/sky/sky-h.gc              |   174 +
 goal_src/engine/gfx/wind-h.gc                 |    43 +
 goal_src/engine/level/load-boundary.gc        |    20 +
 goal_src/engine/physics/dynamics-h.gc         |    46 +
 goal_src/engine/ps2/memcard-h.gc              |    57 +
 goal_src/engine/target/surface-h.gc           |     1 -
 goal_src/kernel-defs.gc                       |     4 +-
 scripts/decomp_progress.py                    |     2 +-
 test/decompiler/test_DataParser.cpp           |   125 +
 test/decompiler/test_FormExpressionBuild.cpp  |    35 +-
 31 files changed, 19469 insertions(+), 381 deletions(-)

diff --git a/common/goos/PrettyPrinter.cpp b/common/goos/PrettyPrinter.cpp
index 1ed70093c0..1e8a0972c6 100644
--- a/common/goos/PrettyPrinter.cpp
+++ b/common/goos/PrettyPrinter.cpp
@@ -14,6 +14,12 @@
 
 namespace pretty_print {
 
+namespace {
+const std::unordered_set<float> allowed_floats = {
+    0.0,     0.0625, 0.125,   0.1875, 0.25,    0.3125,  0.375,   0.4375,  0.5,    0.5625,  0.625,
+    0.6875,  0.75,   0.8125,  0.875,  0.9375,  -0.0625, -0.125,  -0.1875, -0.25,  -0.3125, -0.375,
+    -0.4375, -0.5,   -0.5625, -0.625, -0.6875, -0.75,   -0.8125, -0.875,  -0.9375};
+}
 /*!
  * Print a float in a nice representation if possibly, or an exact 32-bit integer constant to
  * be reinterpreted.
@@ -21,7 +27,7 @@ namespace pretty_print {
 goos::Object float_representation(float value) {
   int rounded = value;
   bool exact_int = ((float)rounded) == value;
-  if (value == 0.5 || value == -0.5 || value == 0.0 || value == 1.0 || value == -1.0 || exact_int) {
+  if (exact_int || allowed_floats.find(value) != allowed_floats.end()) {
     return goos::Object::make_float(value);
   } else {
     u32 int_value;
diff --git a/decompiler/IR2/FormExpressionAnalysis.cpp b/decompiler/IR2/FormExpressionAnalysis.cpp
index 1643fa0230..35519f5723 100644
--- a/decompiler/IR2/FormExpressionAnalysis.cpp
+++ b/decompiler/IR2/FormExpressionAnalysis.cpp
@@ -344,9 +344,8 @@ void SimpleExpressionElement::update_from_stack_identity(const Env& env,
                                                                env.file->words_by_seg, env.dts->ts);
           result->push_back(pool.alloc_element<DecompiledDataElement>(decompiled_data));
         } else {
-          auto type = env.dts->parse_type_spec(kv->second.type_name);
-          auto decompiled_data =
-              decompile_at_label(type, lab, env.file->labels, env.file->words_by_seg, env.dts->ts);
+          auto decompiled_data = decompile_at_label_with_hint(kv->second, lab, env.file->labels,
+                                                              env.file->words_by_seg, *env.dts);
           result->push_back(pool.alloc_element<DecompiledDataElement>(decompiled_data));
         }
       } else {
diff --git a/decompiler/ObjectFile/ObjectFileDB_IR2.cpp b/decompiler/ObjectFile/ObjectFileDB_IR2.cpp
index a3a36699e3..5b11714964 100644
--- a/decompiler/ObjectFile/ObjectFileDB_IR2.cpp
+++ b/decompiler/ObjectFile/ObjectFileDB_IR2.cpp
@@ -406,7 +406,7 @@ void ObjectFileDB::ir2_build_expressions() {
     (void)segment_id;
     (void)data;
     total++;
-    if (func.ir2.top_form && func.ir2.env.has_type_analysis()) {
+    if (func.ir2.top_form && func.ir2.env.has_type_analysis() && func.ir2.env.has_local_vars()) {
       attempted++;
       if (convert_to_expressions(func.ir2.top_form, *func.ir2.form_pool, func, dts)) {
         successful++;
diff --git a/decompiler/config.cpp b/decompiler/config.cpp
index 787b03e332..33169920b1 100644
--- a/decompiler/config.cpp
+++ b/decompiler/config.cpp
@@ -134,7 +134,11 @@ void set_config(const std::string& path_to_config_file) {
       const auto& name = x.at(0).get<std::string>();
       const auto& type_name = x.at(1).get<std::string>();
       bool is_const = x.at(2).get<bool>();
-      gConfig.label_types[obj_name][name] = {type_name, is_const};
+      auto& config_entry = gConfig.label_types[obj_name][name];
+      config_entry = {type_name, is_const, {}};
+      if (x.size() > 3) {
+        config_entry.array_size = x.at(3).get<int>();
+      }
     }
   }
 }
diff --git a/decompiler/config.h b/decompiler/config.h
index 280786feee..d0c63751ca 100644
--- a/decompiler/config.h
+++ b/decompiler/config.h
@@ -1,12 +1,10 @@
 #pragma once
 
-#ifndef JAK2_DISASSEMBLER_CONFIG_H
-#define JAK2_DISASSEMBLER_CONFIG_H
-
 #include <string>
 #include <vector>
 #include <unordered_set>
 #include <unordered_map>
+#include <optional>
 #include "decompiler/Disasm/Register.h"
 
 namespace decompiler {
@@ -18,6 +16,7 @@ struct TypeHint {
 struct LabelType {
   std::string type_name;
   bool is_const = false;
+  std::optional<int> array_size;
 };
 
 struct Config {
@@ -59,5 +58,3 @@ struct Config {
 Config& get_config();
 void set_config(const std::string& path_to_config_file);
 }  // namespace decompiler
-
-#endif  // JAK2_DISASSEMBLER_CONFIG_H
diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc
index 503f3377b3..3c689173c4 100644
--- a/decompiler/config/all-types.gc
+++ b/decompiler/config/all-types.gc
@@ -66,6 +66,9 @@
 (define-extern dma-sync (function pointer int int int))
 (define-extern flush-cache (function int none))
 
+(define-extern mc-run (function none))
+(define-extern mc-check-result (function int))
+
 ;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;; GCOMMON             ;;;;;;;;;;;;;;;;;;;
@@ -5372,7 +5375,7 @@
 
 ;; sky-h
 (deftype sky-color-day (structure)
-  ((hour uint128 24 :offset-assert 0)
+  ((hour sky-color-hour 24 :inline :offset-assert 0)
    )
   :method-count-assert 9
   :size-assert         #x180
@@ -5381,7 +5384,7 @@
 
 ;; sky-h
 (deftype sky-circle-data (structure)
-  ((data uint128 17 :offset-assert 0)
+  ((data vector 17 :inline :offset-assert 0)
    )
   :method-count-assert 9
   :size-assert         #x110
@@ -5427,6 +5430,7 @@
    (min-halo  float  :offset-assert 16)
    (max-halo  float  :offset-assert 20)
    )
+  :allow-misaligned
   :method-count-assert 9
   :size-assert         #x18
   :flag-assert         #x900000018
@@ -5446,19 +5450,23 @@
   :flag-assert         #x9000001c0
   )
 
-; ;; sky-h
-; (deftype sky-parms (basic)
-;   ((orbit             UNKNOWN         3       :offset-assert 4)
-;    (upload-data       sky-upload-data :inline :offset-assert 116)
-;    (sun-lights        light-group     :inline :offset-assert 560)
-;    (moon-lights       light-group     :inline :offset-assert 752)
-;    (default-lights    light-group     :inline :offset-assert 944)
-;    (default-vu-lights vu-lights       :inline :offset-assert 1136)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x4e0
-;   :flag-assert         #x9000004e0
-;   )
+;; sky-h
+(deftype sky-parms (basic)
+  ;; check - the alignment on some of these.
+  ((orbit             sky-orbit 3     :inline      :offset-assert 4)
+   (upload-data       sky-upload-data :inline :offset-assert 112)
+   (sun-lights        light-group     :inline :offset-assert 560)
+   (moon-lights       light-group     :inline :offset-assert 752)
+   (default-lights    light-group     :inline :offset-assert 944)
+   (default-vu-lights vu-lights       :inline :offset-assert 1136)
+   )
+  (:methods
+   (new (symbol type) _type_ 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4e0
+  :flag-assert         #x9000004e0
+  )
 
 ;; sky-h
 (deftype sky-tng-data (basic)
@@ -5517,14 +5525,14 @@
   :flag-assert         #x900000030
   )
 
-; ;; mood-h
-; (deftype mood-fog-table (structure)
-;   ((data UNKNOWN 8 :offset-assert 0)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x180
-;   :flag-assert         #x900000180
-;   )
+;; mood-h
+(deftype mood-fog-table (structure)
+  ((data mood-fog 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x180
+  :flag-assert         #x900000180
+  )
 
 ;; mood-h
 (deftype mood-lights (structure)
@@ -5539,14 +5547,14 @@
   :flag-assert         #x900000050
   )
 
-; ;; mood-h
-; (deftype mood-lights-table (structure)
-;   ((data UNKNOWN 8 :offset-assert 0)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x280
-;   :flag-assert         #x900000280
-;   )
+;; mood-h
+(deftype mood-lights-table (structure)
+  ((data mood-lights 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x280
+  :flag-assert         #x900000280
+  )
 
 ;; mood-h
 (deftype mood-sun (structure)
@@ -5558,39 +5566,42 @@
   :flag-assert         #x900000020
   )
 
-; ;; mood-h
-; (deftype mood-sun-table (structure)
-;   ((data UNKNOWN 8 :offset-assert 0)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x100
-;   :flag-assert         #x900000100
-;   )
+;; mood-h
+(deftype mood-sun-table (structure)
+  ((data mood-sun 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x100
+  :flag-assert         #x900000100
+  )
 
-; ;; mood-h
-; (deftype mood-context (basic)
-;   ((mood-fog-table       mood-fog-table            :offset-assert 4)
-;    (mood-lights-table    mood-lights-table         :offset-assert 8)
-;    (mood-sun-table       mood-sun-table            :offset-assert 12)
-;    (fog-interp           sky-color-day             :offset-assert 16)
-;    (palette-interp       sky-color-day             :offset-assert 20)
-;    (sky-texture-interp   sky-color-day             :offset-assert 24)
-;    (current-fog          mood-fog          :inline :offset-assert 32)
-;    (current-sun          mood-sun          :inline :offset-assert 80)
-;    (current-prt-color    vector            :inline :offset-assert 112)
-;    (current-shadow       vector            :inline :offset-assert 128)
-;    (current-shadow-color vector            :inline :offset-assert 144)
-;    (light-group          UNKNOWN           8       :offset-assert 160)
-;    (times                UNKNOWN           8       :offset-assert 1696)
-;    (sky-times            UNKNOWN           8       :offset-assert 1824)
-;    (itimes               UNKNOWN           4       :offset-assert 1856)
-;    (state                UNKNOWN           16      :offset-assert 1920)
-;    (num-stars            float                     :offset-assert 1936)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x794
-;   :flag-assert         #x900000794
-;   )
+;; mood-h
+(deftype mood-context (basic)
+  ((mood-fog-table       mood-fog-table            :offset-assert 4)
+   (mood-lights-table    mood-lights-table         :offset-assert 8)
+   (mood-sun-table       mood-sun-table            :offset-assert 12)
+   (fog-interp           sky-color-day             :offset-assert 16)
+   (palette-interp       sky-color-day             :offset-assert 20)
+   (sky-texture-interp   sky-color-day             :offset-assert 24)
+   (current-fog          mood-fog          :inline :offset-assert 32)
+   (current-sun          mood-sun          :inline :offset-assert 80)
+   (current-prt-color    vector            :inline :offset-assert 112)
+   (current-shadow       vector            :inline :offset-assert 128)
+   (current-shadow-color vector            :inline :offset-assert 144)
+   ;; (light-group          UNKNOWN           8       :offset-assert 160)
+   (times                vector  8 :inline       :offset 1696)
+   (sky-times            float           8       :offset-assert 1824)
+   ;; (itimes               UNKNOWN           4       :offset-assert 1856)
+   ;; (state                UNKNOWN           16      :offset-assert 1920)
+   (num-stars            float                     :offset 1936)
+   )
+  (:methods 
+    (new (symbol type) _type_ 0)
+    )
+  :method-count-assert 9
+  :size-assert         #x794
+  :flag-assert         #x900000794
+  )
 
 ;; time-of-day-h
 (deftype palette-fade-control (structure)
@@ -5603,18 +5614,18 @@
   :flag-assert         #x900000018
   )
 
-; ;; time-of-day-h
-; (deftype palette-fade-controls (basic)
-;   ((control UNKNOWN 8 :offset-assert 16)
-;    )
-;   :method-count-assert 11
-;   :size-assert         #x110
-;   :flag-assert         #xb00000110
-;   (:methods
-;     (dummy-9 () none 9)
-;     (dummy-10 () none 10)
-;     )
-;   )
+;; time-of-day-h
+(deftype palette-fade-controls (basic)
+  ((control palette-fade-control 8 :inline :offset-assert 16)
+   )
+  :method-count-assert 11
+  :size-assert         #x110
+  :flag-assert         #xb00000110
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    )
+  )
 
 ;; time-of-day-h
 (deftype time-of-day-proc (process)
@@ -5919,29 +5930,29 @@
 ;     )
 ;   )
 
-; ;; generic-vu1-h
-; (deftype pris-mtx (structure)
-;   ((data   UNKNOWN 32      :offset-assert 0)
-;    (vector UNKNOWN 8       :offset-assert 0)
-;    (t-mtx  matrix  :inline :offset-assert 0)
-;    (n-mtx  matrix3 :inline :offset-assert 64)
-;    (scale  vector  :inline :offset-assert 112)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x80
-;   :flag-assert         #x900000080
-;   )
+;; generic-vu1-h
+(deftype pris-mtx (structure)
+  ((data   float 32      :offset 0)
+   (vector vector 8 :inline       :offset 0)
+   (t-mtx  matrix  :inline :offset 0)
+   (n-mtx  matrix3 :inline :offset 64)
+   (scale  vector  :inline :offset 112)
+   )
+  :method-count-assert 9
+  :size-assert         #x80
+  :flag-assert         #x900000080
+  )
 
-; ;; generic-vu1-h
-; (deftype generic-pris-mtx-save (structure)
-;   ((loc-mtx pris-mtx :inline :offset-assert 0)
-;    (par-mtx pris-mtx :inline :offset-assert 128)
-;    (dif-mtx pris-mtx :inline :offset-assert 256)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x180
-;   :flag-assert         #x900000180
-;   )
+;; generic-vu1-h
+(deftype generic-pris-mtx-save (structure)
+  ((loc-mtx pris-mtx :inline :offset-assert 0)
+   (par-mtx pris-mtx :inline :offset-assert 128)
+   (dif-mtx pris-mtx :inline :offset-assert 256)
+   )
+  :method-count-assert 9
+  :size-assert         #x180
+  :flag-assert         #x900000180
+  )
 
 ;; generic-vu1-h
 (deftype generic-constants (structure)
@@ -6322,6 +6333,9 @@
    (send-query              basic  :offset-assert 32)
    (query                   basic  :offset-assert 36)
    )
+  (:methods 
+    (new (symbol type) _type_ 0)
+    )
   :method-count-assert 9
   :size-assert         #x28
   :flag-assert         #x900000028
@@ -6369,20 +6383,20 @@
   :flag-assert         #x9000001a0
   )
 
-;; generic-merc-h
-; (deftype generic-merc-input (structure)
-;   ((geo-tag     generic-merc-tag           :inline :offset-assert 0)
-;    (geo-block   UNKNOWN                    1296    :offset-assert 16)
-;    (byte-header merc-byte-header           :inline :offset-assert 16)
-;    (matrix      UNKNOWN                    9       :offset-assert 1312)
-;    (control     generic-merc-ctrl-with-sfx :inline :offset-assert 2464)
-;    (end-tag     generic-merc-tag           :inline :offset-assert 2880)
-;    (shader      adgif-shader               :inline :offset-assert 2896)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #xba0
-;   :flag-assert         #x900000ba0
-;   )
+; generic-merc-h
+(deftype generic-merc-input (structure)
+  ((geo-tag     generic-merc-tag           :inline :offset-assert 0)
+   (geo-block   uint8                    1296    :offset-assert 16)
+   (byte-header merc-byte-header           :inline :offset 16)
+   (matrix      merc-matrix       9    :inline   :offset-assert 1312)
+   (control     generic-merc-ctrl-with-sfx :inline :offset-assert 2464)
+   (end-tag     generic-merc-tag           :inline :offset-assert 2880)
+   (shader      adgif-shader               :inline :offset-assert 2896)
+   )
+  :method-count-assert 9
+  :size-assert         #xba0
+  :flag-assert         #x900000ba0
+  )
 
 ; ;; generic-merc-h
 ; (deftype generic-merc-output (structure)
@@ -6819,10 +6833,11 @@
   :size-assert         #x60
   :flag-assert         #x1000000060
   (:methods
-    (dummy-9 () none 9)
-    (dummy-10 () none 10)
-    (dummy-11 () none 11)
-    (dummy-12 () none 12)
+    (new (symbol type float float float float float) _type_ 0)
+    (clear-offset-bit (shadow-control) none 9)
+    (set-offset-bit (shadow-control) none 10)
+    (set-top-plane-offset (shadow-control float) none 11)
+    (set-bottom-plane-offset (shadow-control float) none 12)
     (dummy-13 () none 13)
     (dummy-14 () none 14)
     (dummy-15 () none 15)
@@ -6863,21 +6878,32 @@
   ((first uint32  :offset-assert 0)
    (next  uint32  :offset-assert 4)
    )
+  :allow-misaligned
   :method-count-assert 9
   :size-assert         #x8
   :flag-assert         #x900000008
   )
 
-;; shadow-cpu-h
-; (deftype shadow-queue (structure)
-;   ((num-runs uint32     :offset-assert 0)
-;    (cur-run  uint32     :offset-assert 4)
-;    (run      UNKNOWN 15 :offset-assert 8)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #xf8
-;   :flag-assert         #x9000000f8
-;   )
+; shadow-cpu-h
+(deftype shadow-queue (structure)
+  ((num-runs uint32     :offset-assert 0)
+   (cur-run  uint32     :offset-assert 4)
+   (run      shadow-run 15 :inline :offset-assert 8)
+   )
+  :method-count-assert 9
+  :size-assert         #xf8
+  :flag-assert         #x9000000f8
+  )
+
+(define-extern shadow-queue-append (function shadow-queue uint))
+;;(define-extern shadow-work object) ;; unknown type
+;;(define-extern shadow-queue object) ;; unknown type
+;;(define-extern *shadow-queue* object) ;; unknown type
+;;(define-extern *shadow* object) ;; unknown type
+;;(define-extern shadow-settings object) ;; unknown type
+;;(define-extern *shadow-object* object) ;; unknown type
+(define-extern shadow-queue-reset (function shadow-queue int))
+
 
 ;; shadow-cpu-h
 (deftype shadow-vertex (structure)
@@ -7016,6 +7042,9 @@
   :flag-assert         #x90000012c
   )
 
+(define-extern show-mc-info (function none))
+(define-extern mc-sync (function int))
+
 ;; game-info-h
 (deftype game-bank (basic)
   ((life-max-default   float  :offset-assert 4)
@@ -7046,7 +7075,7 @@
 (deftype load-state (basic)
   ((want          level-buffer-state  2 :inline  :offset-assert 4)
    (vis-nick      basic       :offset-assert 36)
-   (command-list  basic       :offset-assert 40)
+   (command-list  pair       :offset-assert 40)
    (object-name   basic 256 :offset-assert 44)
    (object-status basic 256 :offset-assert 1068)
    )
@@ -7054,7 +7083,8 @@
   :size-assert         #x82c
   :flag-assert         #x150000082c
   (:methods
-    (dummy-9 () none 9)
+    (new (symbol type) _type_ 0)
+    (reset! (_type_) _type_ 9)
     (dummy-10 () none 10)
     (dummy-11 () none 11)
     (dummy-12 () none 12)
@@ -7182,18 +7212,18 @@
   :flag-assert         #x900000010
   )
 
-; ;; wind-h
-; (deftype wind-work (basic)
-;   ((wind-array  UNKNOWN 64      :offset-assert 16)
-;    (wind-normal vector  :inline :offset-assert 1040)
-;    (wind-temp   vector  :inline :offset-assert 1056)
-;    (wind-force  UNKNOWN 64      :offset-assert 1072)
-;    (wind-time   uint32          :offset-assert 1328)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x534
-;   :flag-assert         #x900000534
-;   )
+;; wind-h
+(deftype wind-work (basic)
+  ((wind-array  vector  64 :inline      :offset-assert 16)
+   (wind-normal vector  :inline :offset-assert 1040)
+   (wind-temp   vector  :inline :offset-assert 1056)
+   (wind-force  float 64      :offset-assert 1072)
+   (wind-time   uint32          :offset-assert 1328)
+   )
+  :method-count-assert 9
+  :size-assert         #x534
+  :flag-assert         #x900000534
+  )
 
 ; ;; prototype-h
 ; (deftype prototype-bucket (basic)
@@ -7582,11 +7612,17 @@
   )
 
 ;; res-h
+
+(deftype res-tag (uint128)
+  ()
+  :flag-assert #x900000010
+  )
+
 (deftype res-lump (basic)
   ((length           int32   :offset-assert 4)
    (allocated-length int32   :offset-assert 8)
-   (data-base        uint32  :offset-assert 12)
-   (data-top         uint32  :offset-assert 16)
+   (data-base        pointer  :offset-assert 12)
+   (data-top         pointer  :offset-assert 16)
    (data-size        int32   :offset-assert 20)
    (extra            basic   :offset-assert 24)
    (tag              uint32  :offset-assert 28)
@@ -32987,7 +33023,7 @@
 ;;(define-extern *ocean-mid-indices-village2* object) ;; unknown type
 ;;(define-extern *ocean-mid-masks-sunken* object) ;; unknown type
 ;;(define-extern *ocean-map-village1* object) ;; unknown type
-;;(define-extern *ocean-spheres-village1* object) ;; unknown type
+(define-extern *ocean-spheres-village1* (inline-array sphere)) ;; unknown type
 ;;(define-extern *ocean-wave-frames* object) ;; unknown type
 ;;(define-extern sky-color-hour object) ;; unknown type
 ;;(define-extern sky-circle-data object) ;; unknown type
@@ -33001,7 +33037,7 @@
 ;;(define-extern sky-upload-data object) ;; unknown type
 ;;(define-extern *sky-parms* object) ;; unknown type
 ;;(define-extern sky-moon-data object) ;; unknown type
-;;(define-extern *sky-upload-data* object) ;; unknown type
+(define-extern *sky-upload-data* sky-upload-data) ;; unknown type
 ;;(define-extern sky-work object) ;; unknown type
 ;;(define-extern sky-parms object) ;; unknown type
 ;;(define-extern mood-fog object) ;; unknown type
@@ -33017,7 +33053,7 @@
 ;;(define-extern *time-of-day-mode* object) ;; unknown type
 ;;(define-extern time-of-day-dma object) ;; unknown type
 ;;(define-extern palette-fade-controls object) ;; unknown type
-;;(define-extern *palette-fade-controls* object) ;; unknown type
+(define-extern *palette-fade-controls* palette-fade-controls) ;; unknown type
 (define-extern time-of-day-palette type)
 ;;(define-extern time-of-day-proc object) ;; unknown type
 (define-extern skeleton-group type)
@@ -33057,7 +33093,7 @@
 ;;(define-extern merc-effect object) ;; unknown type
 ;;(define-extern ripple-wave object) ;; unknown type
 ;;(define-extern merc-mat-dest object) ;; unknown type
-(define-extern merc-fragment-fp-data function)
+(define-extern merc-fragment-fp-data (function merc-fragment pointer))
 (define-extern ripple-wave-set type)
 ;;(define-extern merc-fragment object) ;; unknown type
 ;;(define-extern merc-vtx object) ;; unknown type
@@ -33101,14 +33137,7 @@
 ;;(define-extern generic-effect-buffer object) ;; unknown type
 ;;(define-extern generic-vu1-texbuf object) ;; unknown type
 ;;(define-extern *generic-debug* object) ;; unknown type
-(define-extern shadow-queue-append function)
-;;(define-extern shadow-work object) ;; unknown type
-;;(define-extern shadow-queue object) ;; unknown type
-;;(define-extern *shadow-queue* object) ;; unknown type
-;;(define-extern *shadow* object) ;; unknown type
-;;(define-extern shadow-settings object) ;; unknown type
-;;(define-extern *shadow-object* object) ;; unknown type
-(define-extern shadow-queue-reset function)
+
 ;;(define-extern shadow-matrix-ref object) ;; unknown type
 ;;(define-extern *shadow-debug* object) ;; unknown type
 (define-extern shadow-geo type)
@@ -33120,10 +33149,7 @@
 ;;(define-extern shadow-edge object) ;; unknown type
 (define-extern shadow-control type)
 ;;(define-extern mc-file-info object) ;; unknown type
-(define-extern show-mc-info function)
-;;(define-extern mc-handle object) ;; unknown type
-;;(define-extern mc-slot-info object) ;; unknown type
-(define-extern mc-sync function)
+
 ;;(define-extern mc-run object) ;; unknown type
 ;;(define-extern mc-get-slot-info object) ;; unknown type
 ;;(define-extern mc-check-result object) ;; unknown type
@@ -33136,10 +33162,10 @@
 ;;(define-extern actor-id object) ;; unknown type
 ;;(define-extern *GAME-bank* object) ;; unknown type
 ;;(define-extern wind-work object) ;; unknown type
-(define-extern wind-get-hashed-index function)
+(define-extern wind-get-hashed-index (function vector int))
 ;;(define-extern *wind-scales* object) ;; unknown type
 ;;(define-extern wind-vector object) ;; unknown type
-;;(define-extern *wind-work* object) ;; unknown type
+(define-extern *wind-work* wind-work) ;; unknown type
 (define-extern prototype-bucket-shrub type)
 (define-extern prototype-bucket-tie type)
 ;;(define-extern instance object) ;; unknown type
@@ -33164,7 +33190,7 @@
 ;;(define-extern bone-buffer object) ;; unknown type
 ;;(define-extern merc-global-array object) ;; unknown type
 ;;(define-extern *merc-globals* object) ;; unknown type
-;;(define-extern *matrix-engine* object) ;; unknown type
+(define-extern *matrix-engine* (array handle)) ;; unknown type
 ;;(define-extern camera-eng object) ;; unknown type
 ;;(define-extern *camera-engine* object) ;; unknown type
 ;;(define-extern *background-draw-engine* object) ;; unknown type
@@ -33193,8 +33219,8 @@
 (define-extern light-group-process! function)
 ;;(define-extern *default-lights* object) ;; unknown type
 (define-extern vu-lights<-light-group! function)
-(define-extern time-to-apex function)
-(define-extern time-to-ground function)
+(define-extern time-to-apex (function float float int))
+(define-extern time-to-ground (function float float float int))
 ;;(define-extern *standard-dynamics* object) ;; unknown type
 (define-extern dynamics type)
 ;;(define-extern standard object) ;; unknown type
@@ -33208,7 +33234,7 @@
 ;;(define-extern *smack-jump-mods* object) ;; unknown type
 ;;(define-extern *dive-mods* object) ;; unknown type
 ;;(define-extern *swim-surface* object) ;; unknown type
-(define-extern calc-terminal2-vel function)
+(define-extern calc-terminal2-vel (function float float float float float))
 ;;(define-extern *wade-surface* object) ;; unknown type
 ;;(define-extern *jump-mods* object) ;; unknown type
 ;;(define-extern *turn-around-mods* object) ;; unknown type
@@ -33226,11 +33252,11 @@
 ;;(define-extern *run-attack-mods* object) ;; unknown type
 ;;(define-extern *quicksand-surface* object) ;; unknown type
 ;;(define-extern *walk-no-turn-mods* object) ;; unknown type
-(define-extern calc-terminal-vel function)
+(define-extern calc-terminal-vel (function float float float float))
 ;;(define-extern *duck-mods* object) ;; unknown type
 ;;(define-extern *duck-attack-mods* object) ;; unknown type
 ;;(define-extern *slope-surface* object) ;; unknown type
-(define-extern calc-terminal4-vel function)
+(define-extern calc-terminal4-vel (function float float float float))
 ;;(define-extern *edge-grab-mods* object) ;; unknown type
 ;;(define-extern *standard-ground-surface* object) ;; unknown type
 ;;(define-extern *flop-land-mods* object) ;; unknown type
diff --git a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
index 54da23d9d1..90def6af72 100644
--- a/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
+++ b/decompiler/config/jak1_ntsc_black_label/label_types.jsonc
@@ -142,6 +142,80 @@
 	],
 
 	"text-h":[
-		["L2", "_auto_", true]]
+		["L2", "_auto_", true]],
+
+	"ocean-trans-tables":[
+		["L1", "(pointer float)", true, 16],
+		["L2", "(pointer float)", true, 160],
+		["L3", "(pointer float)", true, 100],
+		["L4", "(pointer float)", true, 72],
+		["L5", "(pointer float)", true, 72],
+		["L6", "(pointer float)", true, 72],
+		["L7", "(pointer float)", true, 72],
+		["L8", "(pointer float)", true, 44],
+		["L9", "(pointer float)", true, 44],
+		["L10", "(pointer float)", true, 44],
+		["L11", "(pointer float)", true, 44],
+		["L12", "(pointer float)", true, 40],
+		["L13", "(pointer float)", true, 40],
+		["L14", "(pointer float)", true, 40],
+		["L15", "(pointer float)", true, 40],
+		["L16", "(pointer float)", true, 28],
+		["L17", "(pointer float)", true, 28],
+		["L18", "(pointer float)", true, 28],
+		["L19", "(pointer float)", true, 28]
+	],
+
+	"ocean-tables":[
+		["L26", "(inline-array sphere)", true, 36],
+		["L25", "(pointer uint32)", true, 2548]
+	],
+
+	"ocean-frames":[
+		["L1", "(pointer uint32)", true, 16384]
+	],
+
+	"sky-h":[
+		["L73", "float", true],
+		["L71", "float", true],
+		["L72", "float", true]
+	],
+
+	"mood-h":[
+		["L3", "float", true]
+	],
+
+	"merc-h":[
+		["L4", "float", true],
+		["L5", "float", true],
+		["L6", "float", true],
+		["L7", "float", true]
+	],
+
+	"shadow-cpu-h":[
+				["L9", "float", true],
+		["L10", "float", true]
+	],
+
+	"game-info-h":[
+		["L4", "game-bank", true],
+		["L3", "game-info", true]
+	],
+
+	"wind-h":[
+		["L3", "_auto_", true]
+	],
+
+	"dynamics-h":[
+		["L7", "float", true],
+		["L6", "_auto_", true]
+	],
+
+	"surface-h":[
+		["L72", "float", true],
+		["L71", "float", true]
+	]
+
+
 
 }
\ No newline at end of file
diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp
index 216a1b3b6c..bea8e0e964 100644
--- a/decompiler/util/data_decompile.cpp
+++ b/decompiler/util/data_decompile.cpp
@@ -6,6 +6,74 @@
 
 namespace decompiler {
 
+/*!
+ * Entry point from the decompiler to decompile data.
+ */
+goos::Object decompile_at_label_with_hint(const LabelType& hint,
+                                          const DecompilerLabel& label,
+                                          const std::vector<DecompilerLabel>& labels,
+                                          const std::vector<std::vector<LinkedWord>>& words,
+                                          DecompilerTypeSystem& dts) {
+  auto type = dts.parse_type_spec(hint.type_name);
+  if (!hint.array_size.has_value()) {
+    // if we don't have an array size, treat it as just a normal type.
+    return decompile_at_label(type, label, labels, words, dts.ts);
+  }
+
+  if (type.base_type() == "pointer") {
+    auto field_type_info = dts.ts.lookup_type(type.get_single_arg());
+    if (field_type_info->is_reference()) {
+      throw std::runtime_error(
+          fmt::format("Type {} is not yet supported by the data decompiler.", hint.type_name));
+    } else {
+      auto stride = field_type_info->get_size_in_memory();
+
+      int word_count = ((stride * (*hint.array_size)) + 3) / 4;
+      std::vector<LinkedWord> obj_words;
+      obj_words.insert(obj_words.begin(),
+                       words.at(label.target_segment).begin() + (label.offset / 4),
+                       words.at(label.target_segment).begin() + (label.offset / 4) + word_count);
+
+      return decompile_value_array(type.get_single_arg(), field_type_info, *hint.array_size, stride,
+                                   0, obj_words, dts.ts);
+    }
+  }
+
+  if (type.base_type() == "inline-array") {
+    auto field_type_info = dts.ts.lookup_type(type.get_single_arg());
+    if (!field_type_info->is_reference()) {
+      throw std::runtime_error(
+          fmt::format("Type {} is invalid, the element type is not inlineable.", hint.type_name));
+    } else {
+      // it's an inline array.  let's figure out the len and stride
+      auto len = *hint.array_size;
+      // TODO - having this logic here isn't great.
+      auto stride = align(field_type_info->get_size_in_memory(),
+                          field_type_info->get_inline_array_stride_alignment());
+
+      if (dynamic_cast<BasicType*>(field_type_info)) {
+        throw std::runtime_error("Plan basic arrays not supported yet");
+        // I just want to double check offsets....
+      }
+
+      std::vector<goos::Object> array_def = {pretty_print::to_symbol(fmt::format(
+          "new 'static 'inline-array '{} {}", type.get_single_arg().print(), *hint.array_size))};
+      for (int elt = 0; elt < len; elt++) {
+        DecompilerLabel fake_label;
+        fake_label.target_segment = label.target_segment;
+        fake_label.offset = label.offset + field_type_info->get_offset() + stride * elt;
+        fake_label.name = fmt::format("fake-label-{}-elt-{}", type.get_single_arg().print(), elt);
+        array_def.push_back(
+            decompile_at_label(type.get_single_arg(), fake_label, labels, words, dts.ts));
+      }
+      return pretty_print::build_list(array_def);
+    }
+  }
+
+  throw std::runtime_error(
+      fmt::format("Type {} is not yet supported by the data decompiler.", hint.type_name));
+}
+
 /*!
  * Attempt to determine the type of this label. This does not make sure that the type system
  * actually knows about the type. If the thing is not a basic or pair, it will fail.
@@ -140,6 +208,33 @@ goos::Object decompile_string_at_label(const DecompilerLabel& label,
   return goos::StringObject::make_new(result);
 }
 
+goos::Object decompile_value_array(const TypeSpec& elt_type,
+                                   const Type* elt_type_info,
+                                   int length,
+                                   int stride,
+                                   int offset,
+                                   const std::vector<LinkedWord>& obj_words,
+                                   const TypeSystem& ts) {
+  std::vector<goos::Object> array_def = {
+      pretty_print::to_symbol(fmt::format("new 'static 'array '{} {}", elt_type.print(), length))};
+
+  for (int i = 0; i < length; i++) {
+    auto start = offset + stride * i;
+    auto end = start + elt_type_info->get_size_in_memory();
+    std::vector<u8> elt_bytes;
+    for (int j = start; j < end; j++) {
+      auto& word = obj_words.at(j / 4);
+      if (word.kind != LinkedWord::PLAIN_DATA) {
+        throw std::runtime_error("Got bad word in kind in array of values");
+      }
+      elt_bytes.push_back(word.get_byte(j % 4));
+    }
+    array_def.push_back(decompile_value(elt_type, elt_bytes, ts));
+  }
+
+  return pretty_print::build_list(array_def);
+}
+
 goos::Object decompile_structure(const TypeSpec& type,
                                  const DecompilerLabel& label,
                                  const std::vector<DecompilerLabel>& labels,
@@ -289,24 +384,9 @@ goos::Object decompile_structure(const TypeSpec& type,
         auto stride = ts.get_size_in_type(field) / len;
         assert(stride == field_type_info->get_size_in_memory());
 
-        std::vector<goos::Object> array_def = {pretty_print::to_symbol(
-            fmt::format("new 'static 'array '{} {}", field.type().print(), field.array_size()))};
-
-        for (int i = 0; i < len; i++) {
-          auto start = field_start + stride * i;
-          auto end = start + field_type_info->get_size_in_memory();
-          std::vector<u8> elt_bytes;
-          for (int j = start; j < end; j++) {
-            auto& word = obj_words.at(j / 4);
-            if (word.kind != LinkedWord::PLAIN_DATA) {
-              throw std::runtime_error("Got bad word in kind in array of values");
-            }
-            elt_bytes.push_back(word.get_byte(j % 4));
-          }
-          array_def.push_back(decompile_value(field.type(), elt_bytes, ts));
-        }
-
-        field_defs_out.emplace_back(field.name(), pretty_print::build_list(array_def));
+        field_defs_out.emplace_back(
+            field.name(), decompile_value_array(field.type(), field_type_info, len, stride,
+                                                field_start, obj_words, ts));
       } else if (field.is_dynamic()) {
         throw std::runtime_error(
             fmt::format("Dynamic value field {} in static data type {} not yet implemented",
@@ -476,9 +556,12 @@ goos::Object decompile_value(const TypeSpec& type,
     float value;
     memcpy(&value, bytes.data(), 4);
     return pretty_print::float_representation(value);
-  }
-
-  else {
+  } else if (ts.typecheck(TypeSpec("uint8"), type, "", false, false)) {
+    assert(bytes.size() == 1);
+    u8 value;
+    memcpy(&value, bytes.data(), 1);
+    return pretty_print::to_symbol(fmt::format("#x{:x}", value));
+  } else {
     throw std::runtime_error(fmt::format("decompile_value failed on a {}", type.print()));
   }
 }
@@ -547,8 +630,27 @@ goos::Object decompile_boxed_array(const DecompilerLabel& label,
 
     return pretty_print::build_list(result);
   } else {
-    // value type.
-    throw std::runtime_error("boxed value type array decompile not yet implemented.");
+    // value array
+    std::vector<goos::Object> result = {
+        pretty_print::to_symbol("new"), pretty_print::to_symbol("'static"),
+        pretty_print::to_symbol("'boxed-array"), pretty_print::to_symbol(content_type.print()),
+        pretty_print::to_symbol(fmt::format("{}", array_length))};
+
+    auto stride = content_type_info->get_size_in_memory();
+    for (int i = 0; i < array_length; i++) {
+      auto start = first_elt_word_idx * 4 + stride * i;
+      auto end = start + content_type_info->get_size_in_memory();
+      std::vector<u8> elt_bytes;
+      for (int j = start; j < end; j++) {
+        auto& word = words.at(label.target_segment).at(j / 4);
+        if (word.kind != LinkedWord::PLAIN_DATA) {
+          throw std::runtime_error("Got bad word in kind in array of values");
+        }
+        elt_bytes.push_back(word.get_byte(j % 4));
+      }
+      result.push_back(decompile_value(content_type, elt_bytes, ts));
+    }
+    return pretty_print::build_list(result);
   }
 }
 
diff --git a/decompiler/util/data_decompile.h b/decompiler/util/data_decompile.h
index c9c4a35a75..b7942631a7 100644
--- a/decompiler/util/data_decompile.h
+++ b/decompiler/util/data_decompile.h
@@ -6,6 +6,8 @@
 #include "decompiler/ObjectFile/LinkedWord.h"
 #include "common/type_system/TypeSpec.h"
 #include "common/type_system/TypeSystem.h"
+#include "decompiler/config.h"
+#include "decompiler/util/DecompilerTypeSystem.h"
 
 namespace decompiler {
 std::optional<TypeSpec> get_type_of_label(const DecompilerLabel& label,
@@ -18,6 +20,11 @@ goos::Object decompile_at_label(const TypeSpec& type,
                                 const std::vector<DecompilerLabel>& labels,
                                 const std::vector<std::vector<LinkedWord>>& words,
                                 const TypeSystem& ts);
+goos::Object decompile_at_label_with_hint(const LabelType& hint,
+                                          const DecompilerLabel& label,
+                                          const std::vector<DecompilerLabel>& labels,
+                                          const std::vector<std::vector<LinkedWord>>& words,
+                                          DecompilerTypeSystem& dts);
 goos::Object decompile_at_label_guess_type(const DecompilerLabel& label,
                                            const std::vector<DecompilerLabel>& labels,
                                            const std::vector<std::vector<LinkedWord>>& words,
@@ -38,4 +45,11 @@ goos::Object decompile_boxed_array(const DecompilerLabel& label,
 goos::Object decompile_value(const TypeSpec& type,
                              const std::vector<u8>& bytes,
                              const TypeSystem& ts);
+goos::Object decompile_value_array(const TypeSpec& elt_type,
+                                   const Type* elt_type_info,
+                                   int length,
+                                   int stride,
+                                   int offset,
+                                   const std::vector<LinkedWord>& obj_words,
+                                   const TypeSystem& ts);
 }  // namespace decompiler
diff --git a/goal_src/engine/data/art-h.gc b/goal_src/engine/data/art-h.gc
index 3a4a22b747..ac68cb7836 100644
--- a/goal_src/engine/data/art-h.gc
+++ b/goal_src/engine/data/art-h.gc
@@ -5,3 +5,33 @@
 ;; name in dgo: art-h
 ;; dgos: GAME, ENGINE
 
+;; TODO more
+(deftype art (basic)
+  ((name   basic  :offset 8)
+   (length int32  :offset-assert 12)
+   (extra  basic  :offset-assert 16)
+   )
+  :method-count-assert 13
+  :size-assert         #x14
+  :flag-assert         #xd00000014
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    (dummy-11 () none 11)
+    (dummy-12 () none 12)
+    )
+  )
+
+;; art-h
+(deftype art-element (art)
+  ((pad uint8 12))
+  :method-count-assert 13
+  :size-assert         #x20
+  :flag-assert         #xd00000020
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    (dummy-11 () none 11)
+    (dummy-12 () none 12)
+    )
+  )
diff --git a/goal_src/engine/data/res-h.gc b/goal_src/engine/data/res-h.gc
index b1ede8ab0d..898801247e 100644
--- a/goal_src/engine/data/res-h.gc
+++ b/goal_src/engine/data/res-h.gc
@@ -5,3 +5,37 @@
 ;; name in dgo: res-h
 ;; dgos: GAME, ENGINE
 
+(deftype res-tag (uint128)
+  ()
+  :flag-assert #x900000010
+  )
+
+(deftype res-lump (basic)
+  ((length           int32   :offset-assert 4)
+   (allocated-length int32   :offset-assert 8)
+   (data-base        pointer  :offset-assert 12)
+   (data-top         pointer  :offset-assert 16)
+   (data-size        int32   :offset-assert 20)
+   (extra            basic   :offset-assert 24)
+   (tag              uint32  :offset-assert 28)
+   )
+  :method-count-assert 22
+  :size-assert         #x20
+  :flag-assert         #x1600000020
+  ;; field extra is a basic loaded with a signed load 
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    (dummy-11 () none 11)
+    (dummy-12 () none 12)
+    (dummy-13 () none 13)
+    (dummy-14 () none 14)
+    (dummy-15 () none 15)
+    (dummy-16 () none 16)
+    (dummy-17 () none 17)
+    (dummy-18 () none 18)
+    (dummy-19 () none 19)
+    (dummy-20 () none 20)
+    (dummy-21 () none 21)
+    )
+  )
diff --git a/goal_src/engine/engine/engines.gc b/goal_src/engine/engine/engines.gc
index 10a4f8e7dc..878cda13ca 100644
--- a/goal_src/engine/engine/engines.gc
+++ b/goal_src/engine/engine/engines.gc
@@ -5,3 +5,13 @@
 ;; name in dgo: engines
 ;; dgos: GAME, ENGINE
 
+
+;; Allocate some engines.
+
+(define *background-draw-engine* (new 'global 'engine 'draw 10))
+(define *matrix-engine* (new 'global 'boxed-array handle 1024))
+(set! (-> *matrix-engine* length) 0)
+(define *camera-engine* (new 'global 'engine 'camera-eng 128))
+(if *debug-segment*
+    (define *debug-engine* (new 'debug 'engine 'debug 512))
+    )
diff --git a/goal_src/engine/game/game-info-h.gc b/goal_src/engine/game/game-info-h.gc
index 4d6b3b9cb0..3fb09ba7b4 100644
--- a/goal_src/engine/game/game-info-h.gc
+++ b/goal_src/engine/game/game-info-h.gc
@@ -5,188 +5,181 @@
 ; ;; name in dgo: game-info-h
 ; ;; dgos: GAME, ENGINE
 
-; ;; Some very basic game info.
-; ;; the life stuff seems to be unused.
-; (deftype game-bank (basic)
-;   ((life-max-default   float  :offset-assert 4)
-;    (life-start-default float  :offset-assert 8)
-;    (life-single-inc    float  :offset-assert 12)
-;    (money-task-inc     float  :offset-assert 16)
-;    (money-oracle-inc   float  :offset-assert 20)
-;    )
-;   :method-count-assert 9
-;   :size-assert         #x18
-;   :flag-assert         #x900000018
-;   )
+(deftype game-bank (basic)
+  ((life-max-default   float  :offset-assert 4)
+   (life-start-default float  :offset-assert 8)
+   (life-single-inc    float  :offset-assert 12)
+   (money-task-inc     float  :offset-assert 16)
+   (money-oracle-inc   float  :offset-assert 20)
+   )
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
 
-; ;; Set up the default game parameters
-; (define *GAME-bank* (new 'static 'game-bank
-; 			 :life-max-default 99.0
-; 			 :life-start-default 5.0
-; 			 :life-single-inc 1.0
-; 			 :money-task-inc 90.0
-; 			 :money-oracle-inc 120.0
-; 			 )
-;   )
+(define *GAME-bank* (new 'static 'game-bank
+                         :life-max-default 99.000000
+                         :life-start-default 5.000000
+                         :life-single-inc 1.000000
+                         :money-task-inc 90.000000
+                         :money-oracle-inc 120.000000
+                         )
+  )
 
-; ;; ??
-; (deftype actor-id (uint32)
-;   ()
-;   )
+(deftype actor-id (uint32)
+  ()
+  :flag-assert #x900000004
+  )
 
-; ;; main state for each loaded level.
-; (deftype level-buffer-state (structure)
-;   ((name          basic  :offset-assert 0)
-;    (display?      basic  :offset-assert 4)
-;    (force-vis?    basic  :offset-assert 8)
-;    (force-inside? basic  :offset-assert 12)
-;    )
-;   :pack-me
-;   :method-count-assert 9
-;   :size-assert         #x10
-;   :flag-assert         #x900000010
-;   )
+(deftype level-buffer-state (structure)
+  ((name          basic  :offset-assert 0)
+   (display?      basic  :offset-assert 4)
+   (force-vis?    basic  :offset-assert 8)
+   (force-inside? basic  :offset-assert 12)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
 
+(deftype load-state (basic)
+  ((want          level-buffer-state  2 :inline  :offset-assert 4)
+   (vis-nick      basic       :offset-assert 36)
+   (command-list  pair        :offset-assert 40)
+   (object-name   basic 256 :offset-assert 44)
+   (object-status basic 256 :offset-assert 1068)
+   )
+  :method-count-assert 21
+  :size-assert         #x82c
+  :flag-assert         #x150000082c
+  (:methods
+   (new (symbol type) _type_ 0)
+   (reset! (_type_) _type_ 9)
+   (dummy-10 () none 10)
+   (dummy-11 () none 11)
+   (dummy-12 () none 12)
+   (dummy-13 () none 13)
+   (dummy-14 () none 14)
+   (dummy-15 () none 15)
+   (dummy-16 () none 16)
+   (dummy-17 () none 17)
+   (dummy-18 () none 18)
+   (dummy-19 () none 19)
+   (dummy-20 () none 20)
+   )
+  )
 
-; (deftype load-state (basic)
-;   ((want          level-buffer-state  2 :inline  :offset-assert 4)
-;    (vis-nick      basic                          :offset-assert 36)
-;    (command-list  basic                          :offset-assert 40)
-;    (object-name   basic 256                      :offset-assert 44)
-;    (object-status basic 256                      :offset-assert 1068)
-;    )
-;   :method-count-assert 21
-;   :size-assert         #x82c
-;   :flag-assert         #x150000082c
-;   (:methods
-;     (new (symbol type) load-state 0)
-;     (init-load-state ((obj load-state)) load-state 9)
-;     (dummy-10 () none 10)
-;     (dummy-11 () none 11)
-;     (dummy-12 () none 12)
-;     (dummy-13 () none 13)
-;     (dummy-14 () none 14)
-;     (dummy-15 () none 15)
-;     (dummy-16 () none 16)
-;     (dummy-17 () none 17)
-;     (dummy-18 () none 18)
-;     (dummy-19 () none 19)
-;     (dummy-20 () none 20)
-;     )
-;   )
+(defmethod new load-state ((allocation symbol) (type-to-make type))
+  (reset!
+   (object-new allocation type-to-make (the-as int (-> type-to-make size)))
+   )
+  )
 
-; (defmethod new load-state ((allocation symbol) (type-to-make type))
-;   (let ((obj (object-new allocation type)))
-;     (init-load-state obj)
-;     )
-;   )
+(deftype continue-point (basic)
+  ((name          basic           :offset-assert 4)
+   (level         basic           :offset-assert 8)
+   (flags         uint32          :offset-assert 12)
+   (trans         vector  :inline :offset-assert 16)
+   (quat          vector  :inline :offset-assert 32)
+   (camera-trans  vector  :inline :offset-assert 48)
+   (camera-rot    float 9       :offset-assert 64)
+   (load-commands pair           :offset-assert 100)
+   (vis-nick      basic           :offset-assert 104)
+   (lev0          basic           :offset-assert 108)
+   (disp0         basic           :offset-assert 112)
+   (lev1          basic           :offset-assert 116)
+   (disp1         basic           :offset-assert 120)
+   )
+  :method-count-assert 10
+  :size-assert         #x7c
+  :flag-assert         #xa0000007c
+  (:methods
+    (dummy-9 () none 9)
+    )
+  )
 
-; (deftype continue-point (basic)
-;   ((name          basic           :offset-assert 4)
-;    (level         basic           :offset-assert 8)
-;    (flags         uint32          :offset-assert 12)
-;    (trans         vector  :inline :offset-assert 16)
-;    (quat          vector  :inline :offset-assert 32)
-;    (camera-trans  vector  :inline :offset-assert 48)
-;    (camera-rot    float 9         :offset-assert 64)
-;    (load-commands basic           :offset-assert 100)
-;    (vis-nick      basic           :offset-assert 104)
-;    (lev0          basic           :offset-assert 108)
-;    (disp0         basic           :offset-assert 112)
-;    (lev1          basic           :offset-assert 116)
-;    (disp1         basic           :offset-assert 120)
-;    )
-;   :method-count-assert 10
-;   :size-assert         #x7c
-;   :flag-assert         #xa0000007c
-;   (:methods
-;     (dummy-9 () none 9)
-;     )
-;   )
+(deftype game-info (basic)
+  ((mode                  basic      :offset-assert 4)
+   (save-name             basic      :offset-assert 8)
+   (life                  float      :offset-assert 12)
+   (life-max              float      :offset-assert 16)
+   (money                 float      :offset-assert 20)
+   (money-total           float      :offset-assert 24)
+   (money-per-level       uint8 32 :offset-assert 28)
+   (deaths-per-level      uint8 32 :offset-assert 60)
+   (buzzer-total          float      :offset-assert 92)
+   (fuel                  float      :offset-assert 96)
+   (perm-list             basic      :offset-assert 100)
+   (task-perm-list        basic      :offset-assert 104)
+   (current-continue      basic      :offset-assert 108)
+   (text-ids-seen         basic      :offset-assert 112)
+   (level-opened          uint8 32 :offset-assert 116)
+   (hint-control          basic      :offset-assert 148)
+   (task-hint-control     basic      :offset-assert 152)
+   (total-deaths          int32      :offset-assert 156)
+   (continue-deaths       int32      :offset-assert 160)
+   (fuel-cell-deaths      int32      :offset-assert 164)
+   (game-start-time       uint64     :offset-assert 168)
+   (continue-time         uint64     :offset-assert 176)
+   (death-time            uint64     :offset-assert 184)
+   (hit-time              uint64     :offset-assert 192)
+   (fuel-cell-pickup-time uint64     :offset-assert 200)
+   (fuel-cell-time        basic      :offset-assert 208)
+   (enter-level-time      basic      :offset-assert 212)
+   (in-level-time         basic      :offset-assert 216)
+   (blackout-time         uint64     :offset-assert 224)
+   (letterbox-time        uint64     :offset-assert 232)
+   (hint-play-time        uint64     :offset-assert 240)
+   (display-text-time     uint64     :offset-assert 248)
+   (display-text-handle   uint64     :offset-assert 256)
+   (death-movie-tick      int32      :offset-assert 264)
+   (want-auto-save        basic      :offset-assert 268)
+   (auto-save-proc        uint64     :offset-assert 272)
+   (auto-save-status      uint32     :offset-assert 280)
+   (auto-save-card        int32      :offset-assert 284)
+   (auto-save-which       int32      :offset-assert 288)
+   (pov-camera-handle     uint64     :offset-assert 296)
+   (other-camera-handle   uint64     :offset-assert 304)
+   (death-pos             basic      :offset-assert 312)
+   (dummy                 basic      :offset-assert 316)
+   (auto-save-count       int32      :offset-assert 320)
+   )
+  :method-count-assert 29
+  :size-assert         #x144
+  :flag-assert         #x1d00000144
+  ;; field dummy is a basic loaded with a signed load 
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    (dummy-11 () none 11)
+    (dummy-12 () none 12)
+    (dummy-13 () none 13)
+    (dummy-14 () none 14)
+    (dummy-15 () none 15)
+    (dummy-16 () none 16)
+    (dummy-17 () none 17)
+    (dummy-18 () none 18)
+    (dummy-19 () none 19)
+    (dummy-20 () none 20)
+    (dummy-21 () none 21)
+    (dummy-22 () none 22)
+    (dummy-23 () none 23)
+    (dummy-24 () none 24)
+    (dummy-25 () none 25)
+    (dummy-26 () none 26)
+    (dummy-27 () none 27)
+    (dummy-28 () none 28)
+    )
+  )
 
-; (deftype game-info (basic)
-;   ((mode                  basic      :offset-assert 4)
-;    (save-name             basic      :offset-assert 8)
-;    (life                  float      :offset-assert 12)
-;    (life-max              float      :offset-assert 16)
-;    (money                 float      :offset-assert 20)
-;    (money-total           float      :offset-assert 24)
-;    (money-per-level       uint8 32   :offset-assert 28)
-;    (deaths-per-level      uint8 32   :offset-assert 60)
-;    (buzzer-total          float      :offset-assert 92)
-;    (fuel                  float      :offset-assert 96)
-;    (perm-list             basic      :offset-assert 100)
-;    (task-perm-list        basic      :offset-assert 104)
-;    (current-continue      basic      :offset-assert 108)
-;    (text-ids-seen         basic      :offset-assert 112)
-;    (level-opened          uint8 32   :offset-assert 116)
-;    (hint-control          basic      :offset-assert 148)
-;    (task-hint-control     basic      :offset-assert 152)
-;    (total-deaths          int32      :offset-assert 156)
-;    (continue-deaths       int32      :offset-assert 160)
-;    (fuel-cell-deaths      int32      :offset-assert 164)
-;    (game-start-time       uint64     :offset-assert 168)
-;    (continue-time         uint64     :offset-assert 176)
-;    (death-time            uint64     :offset-assert 184)
-;    (hit-time              uint64     :offset-assert 192)
-;    (fuel-cell-pickup-time uint64     :offset-assert 200)
-;    (fuel-cell-time        basic      :offset-assert 208)
-;    (enter-level-time      basic      :offset-assert 212)
-;    (in-level-time         basic      :offset-assert 216)
-;    (blackout-time         uint64     :offset-assert 224)
-;    (letterbox-time        uint64     :offset-assert 232)
-;    (hint-play-time        uint64     :offset-assert 240)
-;    (display-text-time     uint64     :offset-assert 248)
-;    (display-text-handle   uint64     :offset-assert 256)
-;    (death-movie-tick      int32      :offset-assert 264)
-;    (want-auto-save        basic      :offset-assert 268)
-;    (auto-save-proc        uint64     :offset-assert 272)
-;    (auto-save-status      uint32     :offset-assert 280)
-;    (auto-save-card        int32      :offset-assert 284)
-;    (auto-save-which       int32      :offset-assert 288)
-;    (pov-camera-handle     uint64     :offset-assert 296)
-;    (other-camera-handle   uint64     :offset-assert 304)
-;    (death-pos             basic      :offset-assert 312)
-;    (dummy                 basic      :offset-assert 316)
-;    (auto-save-count       int32      :offset-assert 320)
-;    )
-;   :method-count-assert 29
-;   :size-assert         #x144
-;   :flag-assert         #x1d00000144
-;   ;; field dummy is a basic loaded with a signed load 
-;   (:methods
-;     (dummy-9 () none 9)
-;     (dummy-10 () none 10)
-;     (dummy-11 () none 11)
-;     (dummy-12 () none 12)
-;     (dummy-13 () none 13)
-;     (dummy-14 () none 14)
-;     (dummy-15 () none 15)
-;     (dummy-16 () none 16)
-;     (dummy-17 () none 17)
-;     (dummy-18 () none 18)
-;     (dummy-19 () none 19)
-;     (dummy-20 () none 20)
-;     (dummy-21 () none 21)
-;     (dummy-22 () none 22)
-;     (dummy-23 () none 23)
-;     (dummy-24 () none 24)
-;     (dummy-25 () none 25)
-;     (dummy-26 () none 26)
-;     (dummy-27 () none 27)
-;     (dummy-28 () none 28)
-;     )
-;   )
+(define-extern *game-info* game-info)
 
-; (define-extern *game-info* game-info)
-
-; (when (or (not *game-info*)
-; 	  (= 0 *game-info*))
-;   (set! *game-info* (new 'static 'game-info
-; 			 :mode 'debug
-; 			 :current-continue #f)
-; 	)
-;   (set! (-> *game-info* fuel-cell-time) (new 'global 'boxed-array uint64 116))
-;   (set! (-> *game-info* enter-level-time) (new 'global 'boxed-array uint64 32))
-;   (set! (-> *game-info* in-level-time) (new 'global 'boxed-array uint64 32))
-;   )
+(when (or (not *game-info*) (zero? *game-info*))
+  (let ((temp (new 'static 'game-info :mode 'debug :current-continue #f)))
+    (set! (-> temp fuel-cell-time) (new 'global 'boxed-array uint64 116))
+    (set! (-> temp enter-level-time) (new 'global 'boxed-array uint64 32))
+    (set! (-> temp in-level-time) (new 'global 'boxed-array uint64 32))
+    (set! *game-info* temp)
+    )
+  )
diff --git a/goal_src/engine/gfx/generic/generic-vu1-h.gc b/goal_src/engine/gfx/generic/generic-vu1-h.gc
index b753b9c9e2..21b234d181 100644
--- a/goal_src/engine/gfx/generic/generic-vu1-h.gc
+++ b/goal_src/engine/gfx/generic/generic-vu1-h.gc
@@ -5,3 +5,42 @@
 ;; name in dgo: generic-vu1-h
 ;; dgos: GAME, ENGINE
 
+
+(deftype pris-mtx (structure)
+  ((data   float 32      :offset 0)
+   (vector vector 8 :inline       :offset 0)
+   (t-mtx  matrix  :inline :offset 0)
+   (n-mtx  matrix3 :inline :offset 64)
+   (scale  vector  :inline :offset 112)
+   )
+  :method-count-assert 9
+  :size-assert         #x80
+  :flag-assert         #x900000080
+  )
+
+(deftype generic-pris-mtx-save (structure)
+  ((loc-mtx pris-mtx :inline :offset-assert 0)
+   (par-mtx pris-mtx :inline :offset-assert 128)
+   (dif-mtx pris-mtx :inline :offset-assert 256)
+   )
+  :method-count-assert 9
+  :size-assert         #x180
+  :flag-assert         #x900000180
+  )
+
+(deftype generic-constants (structure)
+  ((fog         vector :inline :offset-assert 0)
+   (adgif       qword  :inline :offset-assert 16)
+   (giftag      qword  :inline :offset-assert 32)
+   (hvdf-offset vector :inline :offset-assert 48)
+   (hmge-scale  vector :inline :offset-assert 64)
+   (invh-scale  vector :inline :offset-assert 80)
+   (guard       vector :inline :offset-assert 96)
+   (adnop       qword  :inline :offset-assert 112)
+   (flush       qword  :inline :offset-assert 128)
+   (stores      qword  :inline :offset-assert 144)
+   )
+  :method-count-assert 9
+  :size-assert         #xa0
+  :flag-assert         #x9000000a0
+  )
diff --git a/goal_src/engine/gfx/merc/merc-h.gc b/goal_src/engine/gfx/merc/merc-h.gc
index 6f4b23992c..a777869c65 100644
--- a/goal_src/engine/gfx/merc/merc-h.gc
+++ b/goal_src/engine/gfx/merc/merc-h.gc
@@ -5,3 +5,392 @@
 ;; name in dgo: merc-h
 ;; dgos: GAME, ENGINE
 
+(deftype ripple-merc-query (inline-array-class)
+  ((start-vertex     int32            :offset-assert 16)
+   (vertex-skip      int32            :offset-assert 20)
+   (vertex-count     int32            :offset-assert 24)
+   (current-loc      int32            :offset-assert 28)
+   (data2             uint8 :dynamic :offset-assert 32) ;; renamed from data. suspect inline-array has some magic.
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+(set! (-> ripple-merc-query heap-base) 16)
+
+(deftype merc-byte-header (structure)
+  ((srcdest-off        uint8      :offset-assert 0)
+   (rgba-off           uint8      :offset-assert 1)
+   (lump-off           uint8      :offset-assert 2)
+   (fp-off             uint8      :offset-assert 3)
+   (mat1-cnt           uint8      :offset-assert 4)
+   (mat2-cnt           uint8      :offset-assert 5)
+   (mat3-cnt           uint8      :offset-assert 6)
+   (samecopy-cnt       uint8      :offset-assert 7)
+   (crosscopy-cnt      uint8      :offset-assert 8)
+   (strip-len          uint8      :offset-assert 9)
+   (mm-quadword-fp-off uint8      :offset-assert 10)
+   (mm-quadword-size   uint8      :offset-assert 11)
+   (perc-off           uint8      :offset-assert 12)
+   (mat-slot           uint8 10 :offset-assert 13)
+   )
+  :method-count-assert 9
+  :size-assert         #x17
+  :flag-assert         #x900000017
+  )
+
+;; merc-h
+(deftype merc-fragment (structure)
+  ((header merc-byte-header :inline :offset-assert 0)
+   (rest   uint8          1       :offset-assert 23)
+   )
+  :method-count-assert 10
+  :size-assert         #x18
+  :flag-assert         #xa00000018
+  (:methods
+    (dummy-9 () none 9)
+    )
+  )
+
+;; merc-h
+(deftype merc-vtx (structure)
+  ((mat-0 uint8  :offset-assert 0)
+   (mat-1 uint8  :offset-assert 1)
+   (nrm-x uint8  :offset-assert 2)
+   (pos-x uint8  :offset-assert 3)
+   (dst-0 uint8  :offset-assert 4)
+   (dst-1 uint8  :offset-assert 5)
+   (nrm-y uint8  :offset-assert 6)
+   (pos-y uint8  :offset-assert 7)
+   (tex-s uint8  :offset-assert 8)
+   (tex-t uint8  :offset-assert 9)
+   (nrm-z uint8  :offset-assert 10)
+   (pos-z uint8  :offset-assert 11)
+   )
+  :method-count-assert 9
+  :size-assert         #xc
+  :flag-assert         #x90000000c
+  )
+
+;; merc-h
+(deftype merc-fp-header (structure)
+  ((x-add            float  :offset-assert 0)
+   (y-add            float  :offset-assert 4)
+   (z-add            float  :offset-assert 8)
+   (shader-cnt       uint8  :offset-assert 12)
+   (kick-info-offset uint8  :offset-assert 13)
+   (kick-info-step   uint8  :offset-assert 14)
+   (hword-cnt        uint8  :offset-assert 15)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+(defun merc-fragment-fp-data ((arg0 merc-fragment))
+  "Get the floating-point data of a merc-fragment"
+  (the pointer (&+ arg0 (the-as uint (shl (-> arg0 header mm-quadword-fp-off) 4))))
+  )
+
+;; merc-h
+(deftype merc-mat-dest (structure)
+  ((matrix-number uint8  :offset-assert 0)
+   (matrix-dest   uint8  :offset-assert 1)
+   )
+  :method-count-assert 9
+  :size-assert         #x2
+  :flag-assert         #x900000002
+  )
+
+;; merc-h
+(deftype merc-fragment-control (structure)
+  ((unsigned-four-count uint8            :offset-assert 0)
+   (lump-four-count     uint8            :offset-assert 1)
+   (fp-qwc              uint8            :offset-assert 2)
+   (mat-xfer-count      uint8            :offset-assert 3)
+   (mat-dest-data       uint8 :dynamic :offset-assert 4)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+;; merc-h
+(deftype merc-blend-data (structure) ;; was unknown!
+  ((int8-data int8 :dynamic :offset-assert 0)
+   )
+  )
+
+;; merc-h
+(deftype merc-blend-ctrl (structure)
+  ((blend-vtx-count     uint8            :offset-assert 0)
+   (nonzero-index-count uint8            :offset-assert 1)
+   (bt-index            uint8 :dynamic :offset-assert 2)
+   )
+  :method-count-assert 9
+  :size-assert         #x2
+  :flag-assert         #x900000002
+  )
+
+;; merc-h
+(deftype mei-envmap-tint (structure)
+  ((fade0 float   :offset-assert 0)
+   (fade1 float   :offset-assert 4)
+   (tint  uint32  :offset-assert 8)
+   (dummy int32   :offset-assert 12)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; merc-h
+(deftype mei-texture-scroll (structure)
+  ((max-dist     float     :offset-assert 0)
+   (st-int-scale uint8     :offset-assert 4)
+   (time-factor  uint8     :offset-assert 5)
+   (scroll-dir   uint8     :offset-assert 6)
+   (cached-time  uint8     :offset-assert 7)
+   (time-delta   uint8     :offset-assert 8)
+   (dummy        uint8 7 :offset-assert 9)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; merc-h
+(deftype mei-ripple (structure)
+  ((x-base    float  :offset-assert 0)
+   (z-base    float  :offset-assert 4)
+   (grid-size float  :offset-assert 8)
+   (angle     float  :offset-assert 12)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+;; merc-h
+(deftype merc-extra-info (structure)
+  ((envmap-tint-offset    uint8      :offset-assert 0)
+   (shader-offset         uint8      :offset-assert 1)
+   (texture-scroll-offset uint8      :offset-assert 2)
+   (ripple-offset         uint8      :offset-assert 3)
+   (dummy                 uint8 12 :offset-assert 4)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+; ;; merc-h
+(deftype merc-effect (structure)
+  ((frag-geo         merc-fragment          :offset-assert 0)
+   (frag-ctrl        merc-fragment-control  :offset-assert 4)
+   (blend-data       merc-blend-data        :offset-assert 8)
+   (blend-ctrl       merc-blend-ctrl        :offset-assert 12)
+   (dummy0           uint8                  :offset-assert 16)
+   (effect-bits      uint8                  :offset-assert 17)
+   (frag-count       uint16                 :offset-assert 18)
+   (blend-frag-count uint16                 :offset-assert 20)
+   (tri-count        uint16                 :offset-assert 22)
+   (dvert-count      uint16                 :offset-assert 24)
+   (dummy1           uint8                  :offset-assert 26)
+   (envmap-usage     uint8                  :offset-assert 27)
+   (extra-info       merc-extra-info        :offset-assert 28)
+   )
+  :method-count-assert 10
+  :size-assert         #x20
+  :flag-assert         #xa00000020
+  (:methods
+    (dummy-9 () none 9)
+    )
+  )
+
+;; merc-h
+(deftype merc-eye-ctrl (structure)
+  ((eye-slot      int8                 :offset-assert 0)
+   (shader-offset int8                 :offset-assert 1)
+   (shader-count  int8                 :offset-assert 2)
+   ;(shader        UNKNOWN      3       :offset-assert 16)
+   (iris-shader   adgif-shader :inline :offset-assert 16)
+   (pupil-shader  adgif-shader :inline :offset-assert 96)
+   (lid-shader    adgif-shader :inline :offset-assert 176)
+   )
+  :method-count-assert 9
+  :size-assert         #x100
+  :flag-assert         #x900000100
+  )
+
+;; merc-h
+(deftype merc-eye-anim-frame (structure)
+  ((pupil-trans-x int8    :offset-assert 0)
+   (pupil-trans-y int8    :offset-assert 1)
+   (blink         int8    :offset-assert 2)
+   (iris-scale    int8    :offset 4)
+   (pupil-scale   int8    :offset-assert 5)
+   (lid-scale     int8    :offset-assert 6)
+   (dword         uint64  :offset 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+;; merc-h
+(deftype merc-eye-anim-block (structure)
+  ((max-frame int16            :offset-assert 0)
+   (data      uint8 :dynamic :offset 8)
+   )
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+;; merc-h
+(deftype merc-ctrl-header (structure)
+  ((xyz-scale              float            :offset-assert 0)
+   (st-magic               uint32           :offset-assert 4)
+   (st-out-a               uint32           :offset-assert 8)
+   (st-out-b               uint32           :offset-assert 12)
+   (st-vif-add             uint32           :offset-assert 16)
+   (st-int-off             uint16           :offset-assert 20)
+   (st-int-scale           uint16           :offset-assert 22)
+   (effect-count           uint32           :offset-assert 24)
+   (blend-target-count     uint32           :offset-assert 28)
+   (fragment-count         uint16           :offset-assert 32)
+   (tri-count              uint16           :offset-assert 34)
+   (matrix-count           uint8            :offset-assert 36)
+   (shader-count           uint8            :offset-assert 37)
+   (transform-vertex-count uint16           :offset-assert 38)
+   (dvert-count            uint16           :offset-assert 40)
+   (one-mat-count          uint16           :offset-assert 42)
+   (two-mat-count          uint16           :offset-assert 44)
+   (two-mat-reuse-count    uint16           :offset-assert 46)
+   (three-mat-count        uint16           :offset-assert 48)
+   (three-mat-reuse-count  uint16           :offset-assert 50)
+   (shader-upload-count    uint8            :offset-assert 52)
+   (matrix-upload-count    uint8            :offset-assert 53)
+   (same-copy-count        uint16           :offset-assert 54)
+   (cross-copy-count       uint16           :offset-assert 56)
+   (num-verts              uint16           :offset-assert 58)
+   (longest-edge           float            :offset-assert 60)
+   (eye-ctrl               merc-eye-ctrl    :offset-assert 64)
+   (masks                  uint32       3  :offset-assert 68)
+   (dummy-bytes            uint8       48 :offset 32)
+   (envmap-tint            uint32           :offset 32)
+   (query                  basic            :offset 36)
+   (needs-clip             uint8            :offset 40)
+   (use-isometric          uint8            :offset 41)
+   (use-attached-shader    uint8            :offset 42)
+   (display-triangles      uint8            :offset 43)
+   (death-vertex-skip      uint16           :offset 44)
+   (death-start-vertex     uint16           :offset 46)
+   (death-effect           uint32           :offset 48)
+   (use-translucent        uint8            :offset 52)
+   (display-this-fragment  uint8            :offset 53)
+   )
+  :method-count-assert 9
+  :size-assert         #x50
+  :flag-assert         #x900000050
+  ;; field xyz-scale is a float printed as hex? 
+  )
+
+;; merc-h
+(deftype merc-ctrl (art-element)
+  ((num-joints int32                     :offset 20)
+   (header     merc-ctrl-header :inline  :offset-assert 32)
+   (effect     uint8          :dynamic :offset-assert 112)
+   )
+  :method-count-assert 13
+  :size-assert         #x70
+  :flag-assert         #xd00000070
+  (:methods
+    (dummy-9 () none 9)
+    (dummy-10 () none 10)
+    (dummy-11 () none 11)
+    (dummy-12 () none 12)
+    )
+  )
+
+;; merc-h
+(deftype merc-vu1-low-mem (structure)
+  ((tri-strip-gif qword   :inline :offset-assert 0)
+   (ad-gif        qword   :inline :offset-assert 16)
+   (hvdf-offset   vector  :inline :offset-assert 32)
+   (perspective   uint128 4       :offset-assert 48)
+   (fog           vector  :inline :offset-assert 112)
+   )
+  :method-count-assert 9
+  :size-assert         #x80
+  :flag-assert         #x900000080
+  )
+
+;; merc-h
+(deftype ripple-wave (structure)
+  ((scale float  :offset-assert 0)
+   (offs  float  :offset-assert 4)
+   (xdiv  int16  :offset-assert 8)
+   (zdiv  int16  :offset-assert 10)
+   (speed float  :offset-assert 12)
+   (xmul  float  :offset-assert 16)
+   (zmul  float  :offset-assert 20)
+   (delta float  :offset-assert 24)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x1c
+  :flag-assert         #x90000001c
+  )
+
+;; merc-h
+(deftype ripple-wave-set (basic)
+  ((count        int32     :offset-assert 4)
+   (converted    basic     :offset-assert 8)
+   (frame-save   uint32    :offset-assert 12)
+   (normal-scale float     :offset-assert 16)
+   (wave         ripple-wave 4 :inline :offset-assert 20)
+   )
+  :method-count-assert 9
+  :size-assert         #x84
+  :flag-assert         #x900000084
+  )
+
+;; merc-h
+(deftype ripple-control (basic)
+  ((global-scale            float  :offset-assert 4)
+   (last-frame-scale        float  :offset-assert 8)
+   (close-fade-dist         float  :offset-assert 12)
+   (far-fade-dist           float  :offset-assert 16)
+   (faded-scale             float  :offset-assert 20)
+   (individual-normal-scale float  :offset-assert 24)
+   (waveform                basic  :offset-assert 28)
+   (send-query              basic  :offset-assert 32)
+   (query                   basic  :offset-assert 36)
+   )
+  (:methods 
+   (new (symbol type) _type_ 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x28
+  :flag-assert         #x900000028
+  )
+
+(defmethod new ripple-control ((allocation symbol) (type-to-make type))
+  (local-vars (v0-0 ripple-control))
+  (set! v0-0
+        (object-new allocation type-to-make (the-as int (-> type-to-make size)))
+        )
+  (set! (-> v0-0 global-scale) 0.000000)
+  (set! (-> v0-0 last-frame-scale) (the-as float #xba83126f))
+  (set! (-> v0-0 close-fade-dist) (the-as float #x4f742400))
+  (set! (-> v0-0 far-fade-dist) (the-as float #x4ff42400))
+  (set! (-> v0-0 faded-scale) (the-as float #xba83126f))
+  (set! (-> v0-0 waveform) #f)
+  (set! (-> v0-0 individual-normal-scale) 1.000000)
+  (set! (-> v0-0 send-query) #f)
+  (set! (-> v0-0 query) #f)
+  v0-0
+  )
diff --git a/goal_src/engine/gfx/mood-h.gc b/goal_src/engine/gfx/mood-h.gc
index 5ca4ab87ec..40c858ece5 100644
--- a/goal_src/engine/gfx/mood-h.gc
+++ b/goal_src/engine/gfx/mood-h.gc
@@ -5,3 +5,140 @@
 ;; name in dgo: mood-h
 ;; dgos: GAME, ENGINE
 
+(deftype mood-fog (structure)
+  ((fog-color   vector :inline :offset-assert 0)
+   (fog-dists   vector :inline :offset-assert 16)
+   (fog-start   float         :offset 16) ;; meters
+   (fog-end     float         :offset 20) ;;meters
+   (fog-max     float          :offset 24)
+   (fog-min     float          :offset 28)
+   (erase-color vector :inline :offset-assert 32)
+   )
+  :method-count-assert 9
+  :size-assert         #x30
+  :flag-assert         #x900000030
+  )
+
+(deftype mood-fog-table (structure)
+  ((data mood-fog 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x180
+  :flag-assert         #x900000180
+  )
+
+(deftype mood-lights (structure)
+  ((direction vector :inline :offset-assert 0)
+   (lgt-color vector :inline :offset-assert 16)
+   (prt-color vector :inline :offset-assert 32)
+   (amb-color vector :inline :offset-assert 48)
+   (shadow    vector :inline :offset-assert 64)
+   )
+  :method-count-assert 9
+  :size-assert         #x50
+  :flag-assert         #x900000050
+  )
+
+(deftype mood-lights-table (structure)
+  ((data mood-lights 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x280
+  :flag-assert         #x900000280
+  )
+
+(deftype mood-sun (structure)
+  ((sun-color vector :inline :offset-assert 0)
+   (env-color vector :inline :offset-assert 16)
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+(deftype mood-sun-table (structure)
+  ((data mood-sun 8 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x100
+  :flag-assert         #x900000100
+  )
+
+(deftype mood-context (basic)
+  ((mood-fog-table       mood-fog-table            :offset-assert 4)
+   (mood-lights-table    mood-lights-table         :offset-assert 8)
+   (mood-sun-table       mood-sun-table            :offset-assert 12)
+   (fog-interp           sky-color-day             :offset-assert 16)
+   (palette-interp       sky-color-day             :offset-assert 20)
+   (sky-texture-interp   sky-color-day             :offset-assert 24)
+   (current-fog          mood-fog          :inline :offset-assert 32)
+   (current-sun          mood-sun          :inline :offset-assert 80)
+   (current-prt-color    vector            :inline :offset-assert 112)
+   (current-shadow       vector            :inline :offset-assert 128)
+   (current-shadow-color vector            :inline :offset-assert 144)
+   ;; (light-group          UNKNOWN           8       :offset-assert 160)
+   (times                vector  8 :inline       :offset 1696)
+   (sky-times            float           8       :offset-assert 1824)
+   ;; (itimes               UNKNOWN           4       :offset-assert 1856)
+   ;; (state                UNKNOWN           16      :offset-assert 1920)
+   (num-stars            float                     :offset 1936)
+   )
+  (:methods 
+   (new (symbol type) _type_ 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x794
+  :flag-assert         #x900000794
+  )
+
+
+(defmethod new mood-context ((allocation symbol) (type-to-make type))
+  (local-vars
+   (v0-0 mood-context)
+   (v1 vector)
+   )
+  (set! v0-0
+        (object-new allocation type-to-make (the-as int (-> type-to-make size)))
+        )
+  (set! v1 (-> v0-0 times 0))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 1))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 2))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 3))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 4))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 5))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 6))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  (set! v1 (-> v0-0 times 7))
+  (set! (-> v1 data 0) 1.000000)
+  (set! (-> v1 data 1) 1.000000)
+  (set! (-> v1 data 2) 1.000000)
+  (set! (-> v1 data 3) 0.000000)
+  v0-0
+  )
diff --git a/goal_src/engine/gfx/ocean/ocean-frames.gc b/goal_src/engine/gfx/ocean/ocean-frames.gc
index 7bc75557ca..9642950be3 100644
--- a/goal_src/engine/gfx/ocean/ocean-frames.gc
+++ b/goal_src/engine/gfx/ocean/ocean-frames.gc
@@ -5,3 +5,16392 @@
 ;; name in dgo: ocean-frames
 ;; dgos: GAME, ENGINE
 
+(define *ocean-wave-frames*
+    (new 'static 'array uint32 16384
+         #x130af9fc
+         #x12fdff18
+         #xf1effc05
+         #xb170e04
+         #x4fb00fb
+         #xf0dfa07
+         #xffff0701
+         #xf80010
+         #x1408f4fa
+         #xbf1021b
+         #xe7fa050b
+         #x11140efa
+         #x4fcfcfc
+         #xe00fe0e
+         #xfa010e06
+         #xfcf80a11
+         #xefff2fb
+         #xfbf00c19
+         #xeb0b0906
+         #x120d0aee
+         #x2fdf803
+         #x7fc060e
+         #xfa0c1108
+         #xfc001007
+         #x7faf700
+         #xf1f8100f
+         #xfc1502fc
+         #xc0603eb
+         #x5fef80b
+         #x2ff0d0a
+         #x120b06
+         #x51001
+         #x5fcfd02
+         #xf1ff0804
+         #xe12f9f5
+         #x100fdf3
+         #xbfcfa0f
+         #x1071008
+         #x50e0507
+         #x20c10fd
+         #x8fb0004
+         #xf1fafb06
+         #x1606f6f3
+         #xf7fcfd02
+         #x10f9000b
+         #xe0d09
+         #x406070b
+         #x5130ef9
+         #x7f70509
+         #xebf0f914
+         #x1201f9ec
+         #xf3fe000d
+         #xff90400
+         #x2180b0d
+         #x2020e08
+         #xc1904f4
+         #xfcf40e10
+         #xe4ed041f
+         #xe07f7e1
+         #xf7ff0012
+         #x7fb06f7
+         #x91f0e13
+         #x1031301
+         #x1312f4f4
+         #xf0ff170f
+         #xe8f71117
+         #xe0dede0
+         #xfefb0213
+         #xfd0003f6
+         #x171c1214
+         #x1050b00
+         #xe00ed00
+         #xf30d1404
+         #xf3011207
+         #xf08e4e1
+         #xfff50a13
+         #xf80400fd
+         #x1f19140d
+         #x1050107
+         #xf4f608
+         #x21306f6
+         #x40aff
+         #xcf9e0e7
+         #xf8f21313
+         #xfa050005
+         #x1f181602
+         #x5fd12
+         #xf4f70608
+         #xa07f7f2
+         #x3000505
+         #x2ebe0f2
+         #xf1fa170d
+         #x1060409
+         #x1e1a11fb
+         #x3030018
+         #xf5020d02
+         #x2f6f3f8
+         #xff070d
+         #xf7e7e8fb
+         #xf2031403
+         #x7070804
+         #x1b1d08f9
+         #x7000217
+         #xfc0b0c03
+         #xf1edfa00
+         #x20c0a
+         #xf1f2f4fa
+         #xfa0708f9
+         #xa080900
+         #x1b1d01fd
+         #x9fd0311
+         #x20a0a0c
+         #xe8f60000
+         #x80807f7
+         #xf6fdf5fb
+         #xfdf3
+         #x90a0803
+         #x1d150104
+         #x5fb010f
+         #x1081316
+         #xeffffffd
+         #xf04fae9
+         #xfbfff404
+         #xfef7faf3
+         #x90b0709
+         #x1d100706
+         #xf9fe10
+         #xfe0b1d16
+         #xfdfff9fb
+         #xdf8eaea
+         #xfcf9fd12
+         #xf5f4fef4
+         #xc0b080c
+         #x19100b03
+         #xfdf9fc16
+         #xfe151f0b
+         #x1f5f9fe
+         #xebe5f9
+         #xf7f90e17
+         #xf1fdfff1
+         #x11080a07
+         #x14150700
+         #xfff6001a
+         #x21a1d04
+         #xfbedff00
+         #xf1e6eb06
+         #xf5031b0d
+         #xf907f7ec
+         #x14030900
+         #x12180001
+         #xfff30918
+         #x51e1702
+         #xf1ef0400
+         #xeee8f30b
+         #xf81218f9
+         #xa09e9ea
+         #xefe0700
+         #x1216fc0c
+         #xfbf51413
+         #x71f1405
+         #xedf70002
+         #xf5ecf907
+         #xfe1c09ee
+         #x15fde2ed
+         #xfe090b
+         #x130a0012
+         #xf6001b0e
+         #xd1f0f05
+         #xeffafa09
+         #xfbecfd02
+         #x31bfbef
+         #x14eee6f2
+         #xf4010e19
+         #x12030a0d
+         #xf90e1609
+         #x161b0a02
+         #xf1f9fd14
+         #xf9ed00ff
+         #x513f5f7
+         #x6e5f0f3
+         #xf209161f
+         #xe051000
+         #x5180a08
+         #x1d130500
+         #xf0f80a18
+         #xf3f202fa
+         #x50bf7fa
+         #xfaeaf6f2
+         #xfc10191f
+         #xc0c0af3
+         #x12170009
+         #x18080302
+         #xf300140f
+         #xf2f8fff6
+         #x608faf8
+         #xf6f3f6f3
+         #x9111918
+         #xa0f00f2
+         #x160c000b
+         #x9010408
+         #xfc0b1302
+         #xf8faf9f8
+         #x808faf6
+         #xfaf8f4f7
+         #xf0e1510
+         #x80cf8fc
+         #x11060609
+         #xfdfe050c
+         #x80f09fc
+         #xfdf6f8ff
+         #x806f6f8
+         #xfef8f7fd
+         #xb09110d
+         #x607fc05
+         #xc080a04
+         #xf8fc060e
+         #x100c02f8
+         #xf9f2fd07
+         #x704f5fb
+         #xfdf8ff00
+         #x5050d0e
+         #x4060307
+         #xb0a0700
+         #xf4f8070d
+         #x120702f4
+         #xf3f8040e
+         #x600f4f9
+         #xfafd0801
+         #x3030b0d
+         #x40b0903
+         #xb0a0200
+         #xeefb0a0a
+         #x100502f0
+         #xf7020610
+         #x6f9f3f7
+         #xf9070c02
+         #x5000909
+         #x61205ff
+         #xa050200
+         #xed000808
+         #xf0700f2
+         #x2080312
+         #x1f1f4f8
+         #xfe110c05
+         #x6fc0601
+         #x915fefe
+         #x70103ff
+         #xf4020309
+         #x110afbfa
+         #x1002ff17
+         #xf7edf800
+         #x8170d07
+         #x6fb03fd
+         #xd13fb03
+         #x1fe0600
+         #xfffdfe0f
+         #x1305f4fb
+         #x9f50c18
+         #xecf80010
+         #x13130df9
+         #xfcfffdff
+         #x13fc020b
+         #xfc05000a
+         #xfafb0e07
+         #x11fdf4f7
+         #xf7f4141a
+         #xee03080f
+         #x121109eb
+         #xfefcf906
+         #x9f80a0c
+         #xfd0b070b
+         #xf50313ff
+         #x6f7f7fa
+         #xec001812
+         #xff0d0703
+         #xe0dfee7
+         #x1fafc0f
+         #x1ff0e08
+         #x4110809
+         #xfa0b0ffa
+         #xf7fdfe
+         #xef071009
+         #xf0bfff8
+         #x707f4f1
+         #x4f70110
+         #x80d07
+         #xa0e0607
+         #xf0bfb
+         #xfb0001
+         #xf7030206
+         #x1600f8f5
+         #xfd01f303
+         #x7f70808
+         #x210080a
+         #xa070805
+         #x51307fd
+         #xfb0207
+         #xf5f6ff0e
+         #x10fdf8f3
+         #xfa00fb0f
+         #x4fc0bfd
+         #x7120810
+         #x3040f03
+         #xe1600fb
+         #xf9fc0711
+         #xecef0814
+         #xb02f5e9
+         #xfb000312
+         #xff0007f3
+         #xe120c14
+         #x71000
+         #x1810f5fb
+         #xf1030f16
+         #xe5f6170d
+         #xb0aeae0
+         #xfdfd0911
+         #xfb0500f2
+         #x1a131414
+         #x10c0902
+         #x19ffec00
+         #xf511100d
+         #xec031afc
+         #x1302e2e1
+         #xfaf90f10
+         #xfc05fcfd
+         #x1f13180b
+         #x30aff0e
+         #x9f0f304
+         #x31607fd
+         #xf7090ff5
+         #x14f3e0e7
+         #xf4fb1413
+         #x2fd04
+         #x1e161600
+         #x305fd18
+         #xf9f30003
+         #xe0efaf3
+         #xfe0504fe
+         #x9e5e0f3
+         #xef021712
+         #x4010504
+         #x1b1a0dfb
+         #x401041d
+         #xf4000800
+         #x7fdf3f7
+         #xfc000709
+         #xfae0e8fc
+         #xf10c130a
+         #x7040afc
+         #x1c1d03fc
+         #x6ff0a1b
+         #xfd090500
+         #xf8f3f6ff
+         #xfb030e08
+         #xf2e7f3fd
+         #xfb0f0cfe
+         #x8080af8
+         #x1d18fe01
+         #x5ff0c16
+         #x4090409
+         #xecf5fd02
+         #x80df8
+         #xf5f6f5fb
+         #x20900f5
+         #x90a06fc
+         #x1f110006
+         #x2fd0714
+         #x4070b11
+         #xf0fefeff
+         #x80900e9
+         #xfef8f402
+         #xfff9f4
+         #xa0a0604
+         #x1c0b0507
+         #xfffc0117
+         #xb1810
+         #xfafffbfb
+         #x9ffefe9
+         #xf4fc0f
+         #xf7faf8f7
+         #xc080b08
+         #x170d0805
+         #xfdf8031a
+         #x161d0a
+         #xfff9f8fd
+         #xefe7f7
+         #xfbf40c14
+         #xf2fff8f9
+         #xf090f00
+         #x14130304
+         #xfdf50819
+         #x51f1802
+         #xf7f3fb03
+         #xf4e5ee04
+         #xf601180b
+         #xfa05f4f4
+         #xf080df7
+         #x1715fe09
+         #xfaf31015
+         #xe1f1003
+         #xedf6fe07
+         #xede5fa05
+         #xf91416fd
+         #x804ecef
+         #x90709f7
+         #x1a0cfd11
+         #xf4f71612
+         #x141f0d07
+         #xebfefb0a
+         #xeeea02fe
+         #x21f06f2
+         #x11f9e6ee
+         #x50502
+         #x19010513
+         #xf1011811
+         #x181e0b07
+         #xf1fff511
+         #xf1ef04f6
+         #xd1af8f3
+         #xcebe8f2
+         #xf8050917
+         #x14fe100c
+         #xf60f1113
+         #x1d170aff
+         #xf5faf918
+         #xeff304f3
+         #x110ef3fa
+         #xffe6eef6
+         #xf809131f
+         #xd0412ff
+         #x3160811
+         #x1f1206fa
+         #xf3f8061c
+         #xeaf804f3
+         #x1002f8fd
+         #xf2ebf2f9
+         #xf1d1b
+         #x90e09f2
+         #x1314020e
+         #x1d0b00fe
+         #xf2001213
+         #xecfc00f1
+         #xdfffcf9
+         #xf0f4f0fa
+         #xa141f10
+         #xc13fbf3
+         #x1708030d
+         #xf040109
+         #xf80b1205
+         #xf3fdfbf1
+         #xb00fbf5
+         #xf6f7eefd
+         #xe151d07
+         #xd0bf4fe
+         #x1002070b
+         #x2020511
+         #x41209fd
+         #xf9f8f7f7
+         #xb02f8f8
+         #xfcf7f100
+         #xc101605
+         #xb01f908
+         #x8040a08
+         #xfc02080f
+         #xe0c01f9
+         #xf6f4fc02
+         #xafff7fd
+         #xfbf7f902
+         #x60d1209
+         #x800020a
+         #x90a0705
+         #xf900080b
+         #xe0600f4
+         #xf0f6030c
+         #x9fbf9fc
+         #xf9fcff03
+         #x3081009
+         #x6050706
+         #xc0a0202
+         #xf3000809
+         #xa0500ef
+         #xf1ff0911
+         #x7f7f9f7
+         #xf9040105
+         #x2061002
+         #x90d0402
+         #xd070001
+         #xf002070a
+         #x908fbef
+         #xfe050811
+         #x2f3f6f5
+         #xd0308
+         #x1030dfc
+         #xf10fe02
+         #x9030100
+         #xf403050c
+         #xd0af5f6
+         #xb000613
+         #xf9f1f5fd
+         #x9110707
+         #xff0208f9
+         #x1409fb06
+         #x2020001
+         #xfcff050d
+         #x1308f4fc
+         #xdf90918
+         #xeef4fc0b
+         #x12130cff
+         #xfc0100fb
+         #x14ff000b
+         #xfe030006
+         #xfdf90a0c
+         #x11faf6f4
+         #xf3ff1718
+         #xf1fb0a12
+         #x141206ee
+         #xfdfdf90c
+         #x7fb0c03
+         #x1030013
+         #xf30911fc
+         #x7f4f5f4
+         #xe8071c17
+         #xfd041005
+         #x1211f8e9
+         #xfef8ff10
+         #xfe020e03
+         #x70a070e
+         #xf8120cf7
+         #xfef4f9fb
+         #xef11150d
+         #xb0607f6
+         #xf0aebf4
+         #xfff7050f
+         #xfe0b0c04
+         #xd0a0806
+         #x21404fb
+         #xfbfafc01
+         #xfb0e0905
+         #x1100fdf2
+         #x901ea05
+         #xfdfa0c08
+         #x40e0808
+         #xc070802
+         #x9130100
+         #xfcfdfd08
+         #xff000205
+         #xcfbf8f5
+         #x2fcf712
+         #xfa010dfd
+         #xb0c080d
+         #x5050b01
+         #x1111ff03
+         #xfbfe0013
+         #xf2f6090a
+         #x5fef7f3
+         #xfd0514
+         #xfa0706f6
+         #x100a0f10
+         #xa0a01
+         #x1b0bf700
+         #xf701081b
+         #xe6fb1402
+         #x801eee9
+         #xffff0d0e
+         #xfc09fdf6
+         #x150a170e
+         #x20f0406
+         #x1dfdf2fe
+         #xfa0d1016
+         #xe50a19f4
+         #x11fce1e0
+         #xfb00100e
+         #x4f6fc
+         #x190d1906
+         #x80dfe10
+         #xfedf400
+         #x7150d03
+         #xf2140ced
+         #x15ebe0e4
+         #xf5021116
+         #x600fb00
+         #x1a161300
+         #x906001b
+         #xfaeeff00
+         #x120ffff6
+         #xfc0e00f7
+         #xae1e2ee
+         #xf209131a
+         #x6ff04fd
+         #x191b0aff
+         #x6000a1e
+         #xf3fb0300
+         #xe01f4f7
+         #xfd040006
+         #xf9e0ebf9
+         #xf7101314
+         #x40409f3
+         #x1c1b0100
+         #x3ff131b
+         #xfb060001
+         #xfff5f400
+         #xfa040a09
+         #xede2f4fb
+         #x130d05
+         #x50a06ef
+         #x1f12fe04
+         #x1011219
+         #x6050007
+         #xf3f5fa05
+         #xfb0b0efc
+         #xefedf8f9
+         #x70e04fa
+         #x70c02f4
+         #x1e090007
+         #x1020d1a
+         #x802060c
+         #xf2fbfe01
+         #x20f03eb
+         #xf9f3f7fd
+         #x604faf7
+         #x90a01ff
+         #x1a060608
+         #x81c
+         #x206110d
+         #xfafefbfe
+         #x906f1e9
+         #xfdeffd07
+         #xfefef5fd
+         #xb080803
+         #x140a0708
+         #xfdfa091c
+         #x1131607
+         #xfefbf600
+         #x3f5e9f4
+         #xf9f00a0f
+         #xf8fdf600
+         #xa0a0efd
+         #x130f0409
+         #xfaf81019
+         #xa1f1304
+         #xf7f6f509
+         #xf7e7efff
+         #xf300170c
+         #xfd00f6fc
+         #x90f0df1
+         #x180d000b
+         #xf4f81315
+         #x171e0c04
+         #xf0f8f711
+         #xebe7fdfe
+         #xf81314ff
+         #x6fff2f4
+         #x71004f3
+         #x1c050210
+         #xeffd1414
+         #x1d1a0a06
+         #xf0fcf715
+         #xe6ef05f4
+         #x51d08f5
+         #xcf7edf0
+         #x40cff01
+         #x19fc0b11
+         #xee061218
+         #x1f150b00
+         #xf7fcf719
+         #xe7f805eb
+         #x1419fbf4
+         #x6eceaf5
+         #xfe070213
+         #x10fb1309
+         #xf510101a
+         #x1f140bf7
+         #xfbf6fc1d
+         #xe8fd00ed
+         #x1a06f8f8
+         #xf9e8ebff
+         #x6101c
+         #x70712fe
+         #x4140c16
+         #x1f1305f2
+         #xf7f4071f
+         #xe800fef0
+         #x16fbfbf8
+         #xefeced04
+         #x30e1e15
+         #x51207f5
+         #x100f0a0f
+         #x1e0cfff9
+         #xf2fb141a
+         #xeb01fcf0
+         #xdfa00f4
+         #xeff2ee06
+         #x8171f06
+         #xe13f8f6
+         #x1406080a
+         #x1403fd08
+         #xf709130c
+         #xf300f7ed
+         #x9fefdf0
+         #xf6f4ed06
+         #xd1b1cfd
+         #x1208f300
+         #xb000a0c
+         #x8010414
+         #x3110902
+         #xf8fbf4f0
+         #x8fff9f3
+         #xfbf2f106
+         #xe1b16fe
+         #x10fcf909
+         #x4030b0e
+         #x2030a11
+         #xe0e00fe
+         #xf6f6f6fc
+         #x8fcfafb
+         #xfbf2f607
+         #xa161103
+         #x7f9040b
+         #x609090b
+         #x4090a
+         #xe06fefb
+         #xeff7ff08
+         #x6f9fefa
+         #xf8f8fb08
+         #x6111103
+         #x4010906
+         #xc0a0407
+         #xfc030608
+         #x804fcf5
+         #xeffd070e
+         #x4f8fef4
+         #xfb00fe09
+         #x40e11ff
+         #x7090603
+         #xe060104
+         #xf902040c
+         #x608f7f3
+         #xfa040b0d
+         #xf7f8f0
+         #x205000a
+         #xe0ef9
+         #xf090002
+         #xa030004
+         #xf902060f
+         #xd09f0f6
+         #x6030b0c
+         #xfaf4f3f9
+         #xb080509
+         #xfe0d06f8
+         #x14040004
+         #x502fe07
+         #xfd00080e
+         #x1304eef9
+         #x6fe0d10
+         #xf2f3f808
+         #x110b0b00
+         #xfd09ff00
+         #x13fb0405
+         #x202fd0f
+         #xfc000c07
+         #x13fdf4f6
+         #xfbfd1416
+         #xeff80513
+         #x13100bf3
+         #xfc02f907
+         #xbf80a05
+         #x103fd12
+         #xf5041100
+         #x5f2f2f5
+         #xee0e1b1b
+         #xf9001401
+         #x1310f6ee
+         #xf70012
+         #xfb0909fe
+         #x3000e0d
+         #xfd1305fd
+         #xfbf1f3fd
+         #xf4171a13
+         #x3080ef1
+         #x1608e8f6
+         #xfcf70810
+         #xfe0e0800
+         #x8050e04
+         #x913fefe
+         #xf7f7f706
+         #x3160e06
+         #x906ffec
+         #x11fbe905
+         #xf7ff0d0b
+         #x60f0704
+         #xa070a00
+         #x100dfc06
+         #xfbfbfa0d
+         #x80a0501
+         #x700f7f3
+         #x8f3f711
+         #xf5060b05
+         #xc0a0a06
+         #x6070600
+         #x150afe08
+         #xfdfdfd15
+         #xfefe0601
+         #xfdf7f9
+         #xf60911
+         #xf90b03ff
+         #xe061106
+         #x1090406
+         #x1a06fe04
+         #xfcfe071c
+         #xed000eff
+         #x3fff5f1
+         #xfefe110b
+         #x9fafc
+         #xe081604
+         #x50d000b
+         #x1afdf9fe
+         #xfe041319
+         #xe80d0ff5
+         #xaf9ebe5
+         #xfd040f0b
+         #x703f5fe
+         #xf111602
+         #xb0cff12
+         #xdf1f8fe
+         #x60e1706
+         #xf41804ef
+         #xfe8e0e0
+         #xfb070d16
+         #xafdfa00
+         #x11190f01
+         #xc040319
+         #xf8eefd00
+         #x110f09f6
+         #x112f7fa
+         #x4e0e2e8
+         #xfa0b121e
+         #x6fd01f8
+         #x151c0701
+         #x6ff111a
+         #xeef80002
+         #x1204f9f5
+         #x506f808
+         #xf4e0e9f3
+         #xfe10181a
+         #x10405ef
+         #x1b180204
+         #x1011918
+         #xf6000003
+         #x5f8f4ff
+         #xff01050d
+         #xe6e1f4f7
+         #x6141609
+         #x20c00ec
+         #x1f0e0106
+         #xff061719
+         #x300ff05
+         #xf8f3fb06
+         #xfe0a0a02
+         #xe6ecf8f6
+         #xd110bfa
+         #x70cf9f4
+         #x1c050306
+         #x9111b
+         #x5ff0407
+         #xf4f70003
+         #x21003f3
+         #xf0f2f7f7
+         #xc0800f7
+         #xb08faff
+         #x17030607
+         #x50e1e
+         #x1020c08
+         #xf9fcfeff
+         #xa0bf2ec
+         #xf7effa00
+         #x400f8fe
+         #xb060203
+         #x11070808
+         #xfeff101f
+         #xd1106
+         #xfdfbf703
+         #x9f9e8f4
+         #xf3f20509
+         #xfefbf901
+         #x90a08fd
+         #x110b060a
+         #xf8fd1519
+         #xb180f03
+         #xfbf6f40e
+         #xfcebeefc
+         #xefff1109
+         #xfefafefe
+         #x81206f5
+         #x1609050c
+         #xf3001615
+         #x1a1a0b02
+         #xf5f4f718
+         #xeceafbfa
+         #xf4121300
+         #x4fcfcf4
+         #xa14fef5
+         #x1901080d
+         #xef041218
+         #x1f130900
+         #xf5f6fd1d
+         #xe4f501f0
+         #x51b09f5
+         #x7f6f4f1
+         #xc0cf702
+         #x13fc0e0c
+         #xf10a101d
+         #x1f100cf8
+         #xfaf6011f
+         #xe5fffeea
+         #x1513fef0
+         #x1efedf8
+         #xb04fd12
+         #x9011408
+         #xf80e111e
+         #x1e110bef
+         #xfcf1071f
+         #xea03f7ee
+         #x1b04fbf0
+         #xf8eaeb06
+         #x6010d19
+         #x10c0f00
+         #x4111217
+         #x1d1204ec
+         #xf6f0111f
+         #xee02f4f5
+         #x14fbffef
+         #xefebee10
+         #x40c1d0d
+         #x41603fa
+         #xf0e130c
+         #x1c0dfbf6
+         #xf0f8191b
+         #xf301f5f5
+         #x9fb00ed
+         #xf0eef311
+         #x7191eff
+         #xe13f8fa
+         #x11080f07
+         #x1503f906
+         #xf3061911
+         #xf900f4ef
+         #x200fcea
+         #xf5eff60d
+         #xd1f17f7
+         #x1605f400
+         #x9020b0b
+         #xafe0313
+         #xf0c06
+         #xfcfdefee
+         #x301f7ef
+         #xf8edf909
+         #x131f0ffa
+         #x12f8fa08
+         #x30b11
+         #x4020d11
+         #xc0b0203
+         #xfaf7eff8
+         #x4fdf7f5
+         #xf7edfc09
+         #x131b0b00
+         #x7f6030a
+         #x80b11
+         #x3070d07
+         #xd03fe02
+         #xf3f5f806
+         #x3fafdf8
+         #xf6f2fe0a
+         #xf160c02
+         #xff0907
+         #x90b090b
+         #x3060605
+         #x701fdff
+         #xf0fb030c
+         #xfffbfef1
+         #xf8f8000b
+         #xa140dfd
+         #x3080704
+         #xd070505
+         #x1030c
+         #x604f7fb
+         #xf8020a0a
+         #xfdfdf8ec
+         #xfffd040b
+         #x81509fa
+         #xb080302
+         #xa030205
+         #xffff0611
+         #xd05eff9
+         #x1070b06
+         #xfafaf1f3
+         #x7000807
+         #x51301fc
+         #x10020201
+         #x501ff0b
+         #xfe000c0f
+         #x13ffedfa
+         #x3040a0a
+         #xf5f4f402
+         #xa040d01
+         #x50cfb03
+         #xdfd0500
+         #x400ff13
+         #xfd020e0a
+         #x12f7f0f7
+         #xfa030f15
+         #xf2f3020b
+         #xd0b0af7
+         #x603f90b
+         #x5fe09ff
+         #x4fe0417
+         #xf9090e03
+         #x9f3f3f4
+         #xef0a181c
+         #xf4fb1208
+         #x1211feef
+         #x2fafe11
+         #xfd0308fe
+         #x2fe0911
+         #xf9120afd
+         #xf8efee03
+         #xff181d17
+         #xfc0f0ced
+         #x1604ecf5
+         #xfaf90a12
+         #x100200
+         #xff0514ff
+         #x110dfe03
+         #xf4f2f30d
+         #xd1b1607
+         #x511fbe9
+         #x13f5ec00
+         #xf5000d12
+         #x80f0500
+         #x4090bfc
+         #x1708fc07
+         #xf7f6fa11
+         #x141209fe
+         #x507f1f5
+         #x6ecfb0a
+         #xf6080b10
+         #xd0a08ff
+         #x5090401
+         #x1603000a
+         #xfcf80015
+         #xa0503fe
+         #xfff4ff
+         #xfcf10c0d
+         #xfe0c040a
+         #xc080cfd
+         #x4090107
+         #x15010206
+         #xfdf90a18
+         #xf70106ff
+         #xfffdfafb
+         #xf8fe1407
+         #x707fc04
+         #x80c0ffd
+         #x70a010c
+         #x13ff00ff
+         #xfbff1815
+         #xf10b06fb
+         #x4fcf4eb
+         #xfc070f06
+         #xc00f800
+         #x7140eff
+         #xc08030e
+         #x9f6fbfe
+         #x91d06
+         #xfc13fef7
+         #x7efe7e1
+         #xa0c11
+         #xaf9fafe
+         #xc1b0a02
+         #xe020910
+         #xf8f3fc02
+         #xa1114f4
+         #xc0df2fd
+         #xfde1e0e6
+         #x10b101c
+         #x5fa00f9
+         #x131d0606
+         #x6001111
+         #xeaf6ff06
+         #xf0a00f0
+         #xffff20b
+         #xece0e3f1
+         #x30f1c16
+         #x400f1
+         #x1b140408
+         #xff041914
+         #xf0fd0005
+         #x9fcf7fa
+         #x7fbff12
+         #xe1e3edf8
+         #x8131f06
+         #x10af9f1
+         #x1f0b0406
+         #xfe0c1718
+         #xfdfe0003
+         #xfbf4fc02
+         #x40b0a
+         #xe0eef4f7
+         #xe1417f5
+         #x908f1f9
+         #x19050604
+         #x210121d
+         #x1fc0302
+         #xf4f60300
+         #x50d04fb
+         #xe9f4f4f5
+         #xf0f07f1
+         #xe02f303
+         #x12030706
+         #x40b131f
+         #xfdff0903
+         #xf6fb02fd
+         #xe0bf6f2
+         #xf2f4f5fb
+         #xa03fef7
+         #xd00fc08
+         #xd070709
+         #x106161c
+         #xfc090e03
+         #xfbfcfb00
+         #x10fbeaf4
+         #xf0f3fe05
+         #x1fbfeff
+         #x9060403
+         #xd0a080b
+         #xfb031817
+         #x6120d02
+         #xfbf6f70e
+         #x2eceefc
+         #xed000909
+         #xfefa04fb
+         #x90e01fb
+         #x1208080a
+         #xf6071614
+         #x16140bfe
+         #xf7f1fd1a
+         #xf0ebf8fb
+         #xf30d0e03
+         #xfefb03f2
+         #x1010fafa
+         #x13030a09
+         #xf50b1218
+         #x1e110af9
+         #xf5f1071f
+         #xe5f6fdf3
+         #x41709f6
+         #xfbfaef
+         #x1608f404
+         #xe010e0a
+         #xf70c111e
+         #x1b0e0bf1
+         #xf6f2101c
+         #xe900f7f0
+         #x161300ec
+         #xfef5effa
+         #x14fefb0e
+         #x3060f09
+         #xfd0d161c
+         #x161108ea
+         #xf6f2161b
+         #xf201eff4
+         #x1906fae9
+         #xf6eeec0a
+         #xcfd0b0f
+         #xff110b06
+         #x40f1c14
+         #x151400ea
+         #xf1f31a1c
+         #xf9fdedfb
+         #x11fef9e9
+         #xf0eaf316
+         #x4091b07
+         #x4180301
+         #xb0f1b08
+         #x180ff5f5
+         #xebfb1f1b
+         #xfefaf2f9
+         #x401f9e9
+         #xefeafe15
+         #x6191bfb
+         #x1011fbff
+         #xc0d1204
+         #x1502f405
+         #xee071e13
+         #xfbf3f2
+         #xff04f5ea
+         #xf1ec030e
+         #xf1f12f6
+         #x1802f600
+         #x909090b
+         #xbfcff10
+         #xfc0f1408
+         #x1f9efee
+         #x204f1ef
+         #xf3ed0407
+         #x191f08f9
+         #x11f5fa06
+         #x1070915
+         #x1000f0e
+         #x90c0703
+         #xfef3ebf7
+         #x3fff2f5
+         #xf1ee0307
+         #x1d1b05ff
+         #x4f5020b
+         #x90d15
+         #x1091102
+         #xb020205
+         #xf8f0f104
+         #x1fcf7f6
+         #xf0f10408
+         #x1a140800
+         #xfdff070c
+         #x50b0f0c
+         #x60b08ff
+         #x5fe0105
+         #xf4f4fe0d
+         #xfefffbf2
+         #xf3f60609
+         #x13140afd
+         #x80608
+         #xa0a0b04
+         #x6030207
+         #x300fe00
+         #xf7fe0809
+         #xfd02f6ec
+         #xf9f90907
+         #xf1505fa
+         #x8090304
+         #x9060403
+         #xfd070f
+         #x901f7fc
+         #xff060905
+         #xfd00eff0
+         #xfefd0d04
+         #x111400fe
+         #xd040101
+         #x602010a
+         #xfcfd0e10
+         #x11fbf2f9
+         #x307060a
+         #xfaf6f0fd
+         #x10f00
+         #x120bfb06
+         #x9000200
+         #x4000312
+         #xf9051209
+         #xff2f1f8
+         #xfe050815
+         #xf5f1ff06
+         #x5090afa
+         #x1002fd0b
+         #x1020200
+         #x2fd0b14
+         #xfb0b0e06
+         #x6edf1f9
+         #xf809111e
+         #xf2fa0e02
+         #xc0e00f3
+         #x9fa000e
+         #xfc090200
+         #xfd140d
+         #x100804
+         #xfceeeeff
+         #xfa131c1d
+         #xf80911f3
+         #x150af0f3
+         #xfef80811
+         #xfd0f0200
+         #xfd011702
+         #xa110002
+         #xf1edf512
+         #x121d1e07
+         #x516f4ee
+         #x10f5f2f8
+         #xf4020e17
+         #xc0902fe
+         #x1109fc
+         #x16030001
+         #xf2f1ff14
+         #x1a1810fb
+         #xb0ae9fa
+         #x2ebfc02
+         #xf7070e19
+         #xf0904fa
+         #x70e0100
+         #x12ff0205
+         #xf8f50612
+         #x130c04fb
+         #x6fcef07
+         #xf5f10b06
+         #x90b13
+         #xc0904f7
+         #x7080008
+         #xd000605
+         #xf9f70e12
+         #x20302ff
+         #xf8fa06
+         #xf2001103
+         #xa060509
+         #x80e03f9
+         #x806030c
+         #xb000301
+         #xf6fd180f
+         #xf90603ff
+         #xfcfcf7
+         #xf90b0d01
+         #xeff0000
+         #x71503ff
+         #xc060709
+         #x5fdfe00
+         #xf90a1e04
+         #x10cfefb
+         #x2f9ede8
+         #x20d0909
+         #x8f8fffe
+         #xd190306
+         #xb020b07
+         #xf9f8fb05
+         #x21516f5
+         #x1006f6fd
+         #xfdece1ea
+         #x60a0f12
+         #xf9fffc
+         #x15160409
+         #x5020f09
+         #xeef7fe0b
+         #xd1301ed
+         #x15f9f407
+         #xeae0e0f7
+         #x40c1e10
+         #xfc01fef7
+         #x1c110909
+         #x8140f
+         #xeefb0009
+         #xa04f6f4
+         #x9f3ff10
+         #xe0e2e800
+         #x7131fff
+         #x205f5f8
+         #x1d090a06
+         #x1101319
+         #xf8fd0002
+         #xf8fafd
+         #xfffc0b0d
+         #xe0ebf1ff
+         #xc1a1bef
+         #xc01effe
+         #x17060803
+         #x512121e
+         #xfdfd01ff
+         #xf4f703fd
+         #x2090901
+         #xe7f3f3f9
+         #x11190ae8
+         #x11faf106
+         #xe060506
+         #xa0f151f
+         #xf9fe0400
+         #xf4fe03f9
+         #xe08fcf6
+         #xf1f4f1fc
+         #xe0cfef0
+         #xcf8fb0c
+         #xa08060b
+         #x50a1b1a
+         #xf8050802
+         #xf900fdfc
+         #x12fdf1f5
+         #xf1f4f606
+         #x600fff7
+         #x7fe0209
+         #xb09080d
+         #xc1b13
+         #xd0a01
+         #xfbfaf908
+         #x6edeffb
+         #xeefa020e
+         #xfdfc05f6
+         #x8080202
+         #xf080a0b
+         #xfd0d1712
+         #xe1209fc
+         #xf7f20115
+         #xf3ebf7fc
+         #xf4080b07
+         #xfa0005ee
+         #x120afbff
+         #xe060a09
+         #xfe0f1116
+         #x161007f5
+         #xf1f10f18
+         #xe9f4faf8
+         #x3120af9
+         #xfc02fbed
+         #x1802f702
+         #xa060a0b
+         #xd141c
+         #x141006ee
+         #xeff51915
+         #xedfdf5f5
+         #x141100eb
+         #xfdfceefa
+         #x16f8fc07
+         #x30c090f
+         #x10c1b18
+         #xf1301eb
+         #xeefa1b13
+         #xfafceef8
+         #x1709f7e7
+         #xf9f2ee0b
+         #xaf90b09
+         #x12090f
+         #x40f1f0d
+         #x1115f8ed
+         #xecfe1c16
+         #xf5eefc
+         #xf02f2e9
+         #xf2ebf917
+         #x61602
+         #x813060b
+         #x8121d03
+         #x160eeff6
+         #xe9041e1a
+         #x1f1f4f9
+         #x403f0ed
+         #xedea0716
+         #x1817f9
+         #x140f0103
+         #xc141203
+         #x1700ee03
+         #xed0d1f13
+         #xf4f7ef
+         #x5edf0
+         #xecef0f0a
+         #x101f0df6
+         #x1800fd01
+         #xa0f060d
+         #xcf8fb0b
+         #xf9141908
+         #xf5f2ea
+         #x403ebf5
+         #xecf30e03
+         #x1e1c03f9
+         #x10f7fb06
+         #x5090517
+         #xfd0a0a
+         #x6120d00
+         #xfff2ebf2
+         #x6fceefa
+         #xecf60904
+         #x1f1401fc
+         #x1f6000d
+         #x2080e17
+         #xfe0a0f01
+         #x8070503
+         #xf9ecef01
+         #x3f8f4fb
+         #xecf70606
+         #x1f1005fc
+         #xfaff0512
+         #x50b130c
+         #x60f07fb
+         #x3000508
+         #xf4edfb0b
+         #xfffdf7f7
+         #xeefa0805
+         #x1a1108f8
+         #xfd070712
+         #x90d0f01
+         #x9070000
+         #x504
+         #xf4f80709
+         #xff02f4f0
+         #xf2fc0a03
+         #x151405f7
+         #x709050c
+         #xa0b0600
+         #x2fe040b
+         #x40000fc
+         #xfc020803
+         #x2ffedf1
+         #xf6000d00
+         #x171100fd
+         #xb040208
+         #x8050107
+         #xf8ff0e0d
+         #xafcfaf6
+         #x2060307
+         #xf5edfa
+         #xfa050bff
+         #x190afe02
+         #x8020007
+         #x4000610
+         #xf5061209
+         #x9f3f4f6
+         #x3030416
+         #xf9effa02
+         #xfe0a08fd
+         #x16000105
+         #x104fe07
+         #xff0f0f
+         #xfa0f0f06
+         #xffecf1fb
+         #xff030f1e
+         #xf2f807ff
+         #x80e00f7
+         #xcfb0608
+         #x7fe09
+         #xfd021708
+         #x2100a05
+         #xf5ebf003
+         #xc1a19
+         #xf40a08f4
+         #x120af6f2
+         #xfb0a0c
+         #x209ff07
+         #xfa0917ff
+         #xc0c0503
+         #xf1ecf20e
+         #xb181f0d
+         #xff17fced
+         #x14fbf0f5
+         #xf5ff0d13
+         #x80b0201
+         #xfe0f0efb
+         #x15070001
+         #xedee0512
+         #x1a1f16f7
+         #x1205e801
+         #xeff7fe
+         #xf907121b
+         #xf0401f6
+         #xa10fb06
+         #xc0102fc
+         #xf1f50d0d
+         #x191506f5
+         #xff4ee10
+         #xf1f30206
+         #x91515
+         #xd08fef4
+         #xc08fd0b
+         #x6000502
+         #xf4fa0f0a
+         #xa0700fc
+         #x3f0fe11
+         #xee010a06
+         #x9081104
+         #xa0cfbfa
+         #x904030b
+         #x4030402
+         #xf4001509
+         #x302fe
+         #xfff80202
+         #xf90e0802
+         #x90209fa
+         #xb0ffc03
+         #x8030907
+         #x3020002
+         #xf40b1a03
+         #x20601fa
+         #x1fdf5f3
+         #x50f0403
+         #x4fe02f9
+         #x100fff09
+         #x9040a04
+         #xfdfcfc08
+         #x1813f8
+         #xd03fcf8
+         #xf4e4f2
+         #x90a0b0a
+         #xfcfc00fd
+         #x180e050c
+         #x4050a06
+         #xf4f8ff0c
+         #xc1901f0
+         #x10f9f8ff
+         #xf4e6e1ff
+         #x60b1909
+         #xf900fe00
+         #x1a0a0b08
+         #x90a0f
+         #xf2fa0209
+         #x110df3f2
+         #x4f10009
+         #xe3e0ea0a
+         #x5151ffc
+         #xff02f7fe
+         #x1a080b02
+         #x4100d18
+         #xf8fd0302
+         #x5fdf5f9
+         #xf8f90c0b
+         #xe0e4f407
+         #xd1e18ea
+         #xbfcf100
+         #x14090802
+         #xd13111d
+         #xfbfd0000
+         #xf9fafffa
+         #xfa050e03
+         #xe7edf6fe
+         #x131f06e4
+         #xef4f306
+         #xd0a0508
+         #xe10181c
+         #xf9ff0001
+         #xf50001f7
+         #x70a02f7
+         #xf1f1f3fd
+         #x1616f8ea
+         #x7f2fc0c
+         #xa09050e
+         #xb0d1c16
+         #xf7020305
+         #xfa03faf8
+         #xe00f7f3
+         #xf3f0f507
+         #xc07faf3
+         #x1f9040d
+         #xb080a0f
+         #x40f1c11
+         #xff090604
+         #xfdfdf702
+         #x6f2f3f7
+         #xf1f3ff11
+         #x20200f4
+         #x2020607
+         #xd080c0b
+         #x3131610
+         #x90e06fe
+         #xf8f5ff0e
+         #xf4edf8fb
+         #xf4fe0b0e
+         #xfc0501ee
+         #xc060000
+         #xd080a08
+         #x5121214
+         #x111003f6
+         #xeff50f12
+         #xeaf3fbf9
+         #x10a0dfe
+         #xfe09f7ee
+         #x1500fdff
+         #x80a070d
+         #x60d1516
+         #x1010fff3
+         #xebfd1810
+         #xeff9f7f5
+         #xf0f02ee
+         #x103ecfa
+         #x11f8ff00
+         #x50b0815
+         #x50c1d14
+         #xf11f9f3
+         #xeb05180f
+         #xfbf8f2f3
+         #x150af4e9
+         #xf6ed0b
+         #x4f90801
+         #x60d0a17
+         #x4101f09
+         #x1210f1f5
+         #xed0a1615
+         #xf0f3f4
+         #xf04ecef
+         #xf6ecfd16
+         #xfa061100
+         #xd0e0d11
+         #x7171a02
+         #x1a07eafa
+         #xee0e171b
+         #xfeedf8f0
+         #x800ebf6
+         #xeced0d13
+         #xfe1711fa
+         #x14090a07
+         #xc190d03
+         #x1bfbec02
+         #xf2131c16
+         #xf8f2fbe8
+         #x4ffecfa
+         #xe8f61409
+         #x101f08f6
+         #x17020200
+         #x1014020e
+         #xff2f708
+         #xfc191909
+         #xf8f7f5e4
+         #x7faedfc
+         #xe9fe0f03
+         #x1e1701f5
+         #xffbfd06
+         #xd0a0619
+         #xf90508
+         #x7170e00
+         #xf9f4ecec
+         #x9f5f0fe
+         #xeb000704
+         #x1f0f00f5
+         #xf8fe10
+         #x6061117
+         #xfc070c03
+         #xb0f0401
+         #xf8ebedfc
+         #x4f2f600
+         #xee000508
+         #x1f0b03f4
+         #xf8fd0519
+         #x409170a
+         #x51004fe
+         #x404040a
+         #xf0eafa06
+         #xf7f9fc
+         #xef000706
+         #x190d05f1
+         #xfd030b1b
+         #x9101100
+         #xe0afcff
+         #xfe03090a
+         #xedf40504
+         #xfdf7f5
+         #xf2010902
+         #x161103f1
+         #x5060b16
+         #xd0e0600
+         #x9fffd06
+         #x507fe
+         #xf4010700
+         #x4fdf0f2
+         #xf5040900
+         #x181000f6
+         #xa04070f
+         #xb070006
+         #xfafe090b
+         #x501fff3
+         #xff050204
+         #x4f2eef8
+         #xf9090602
+         #x1a0900fa
+         #x702020f
+         #x601050d
+         #xf4080f09
+         #x4faf5f3
+         #x4010310
+         #xfdecf600
+         #xff0d0301
+         #x140103fc
+         #x4010012
+         #x1000f0d
+         #xfa110e06
+         #xfcf1f0fb
+         #x1ff0f19
+         #xf2f40101
+         #x80e00fc
+         #x90007fe
+         #x2000012
+         #xfc051505
+         #x5120a04
+         #xf1ecf105
+         #x61c15
+         #xf30502fa
+         #xf09faf4
+         #xfe000804
+         #x601030f
+         #xfc0f1200
+         #xd0d0801
+         #xecebf70d
+         #x6161f06
+         #x11f8f4
+         #x1100f4f1
+         #xf7030b10
+         #xa010606
+         #x1507fe
+         #x100705fc
+         #xecec0012
+         #x141e1bfa
+         #xf0debfc
+         #x6f1f4f9
+         #xf6060f1a
+         #xe0403fa
+         #x914fe02
+         #xf0302fb
+         #xecf71109
+         #x1d1d07f0
+         #x12ecf412
+         #xf4f5f90c
+         #xc1a0f
+         #xa06fcf4
+         #x1104fd0d
+         #x402ff01
+         #xf1fe1005
+         #x150ffef5
+         #x3e70319
+         #xf0ff020d
+         #x40d18ff
+         #xb07f6f9
+         #xa00040d
+         #x1040205
+         #xf3031006
+         #x50400fa
+         #xfaf40b0c
+         #xfb0b0406
+         #x60d0ef2
+         #xd05f703
+         #x6020909
+         #x3040005
+         #xf50c1103
+         #x402f7
+         #xfdff01fd
+         #x70d0202
+         #x10704f3
+         #x1104ff0a
+         #x6060706
+         #x100fe07
+         #xff160efd
+         #x605fff1
+         #x1faeff9
+         #xe090405
+         #xfb01fefe
+         #x1502090b
+         #x506030a
+         #xfbfa000b
+         #xf1a00f5
+         #x8fef9f6
+         #xfce8e803
+         #x8091108
+         #xf900fe03
+         #x16060d05
+         #x3080311
+         #xf6f90509
+         #x1710f3f5
+         #xf6fc02
+         #xede0f10d
+         #x51419ff
+         #xfefffd02
+         #x140a0d00
+         #x50b0819
+         #xf8fe0602
+         #xffff1f8
+         #xf2f9070b
+         #xe2e0fe0b
+         #xf1f11ed
+         #x7faf800
+         #x100d0600
+         #xc0e0e1c
+         #xfbff01ff
+         #xfffaf9fa
+         #xf2050e04
+         #xe4e800ff
+         #x1a1fffe4
+         #x7f2f704
+         #xd0c0308
+         #x100e1918
+         #xfafdfe05
+         #xf800fcf7
+         #xb07fa
+         #xedeffafb
+         #x1d17f2e8
+         #xf1fd0a
+         #xc09060f
+         #xd0f1d13
+         #xf8ff000a
+         #xfd04f7f8
+         #xa05faf2
+         #xf2eef703
+         #x1809f1f1
+         #xf9f7050f
+         #xc070d10
+         #x9131a0f
+         #xfc030509
+         #x1fff500
+         #x4f9f5f5
+         #xf0ed0010
+         #x903faf4
+         #xfc00080c
+         #xb08100a
+         #x815150f
+         #x6090402
+         #xfdf7fb09
+         #xf6f1f6fa
+         #xf2f60c0f
+         #x208fcf1
+         #x5040602
+         #xb0b0c07
+         #xa131211
+         #xe0c00fc
+         #xf2f7070f
+         #xebf3fbfa
+         #xfb041100
+         #x50bf4ef
+         #xe0100fc
+         #xa0c080c
+         #xa0e1413
+         #x110dfbfa
+         #xed011210
+         #xeef8faf3
+         #x90d06f1
+         #xa04eafa
+         #xbfc00fc
+         #x90a0917
+         #x70d1d10
+         #x120af5fd
+         #xf00c1012
+         #xf8f7f6ed
+         #x110cf7ed
+         #x6f6ee08
+         #xfffc03ff
+         #xa08101a
+         #x4141d09
+         #x1606f0fd
+         #xf6110d18
+         #xfcf2f5ea
+         #xf01ecf4
+         #xfbedfe13
+         #xf6060900
+         #xd081712
+         #x61a1605
+         #x1dffecfe
+         #xfa11111e
+         #xf6f0f8e8
+         #xaf9edfc
+         #xeef10f12
+         #xfd1309fc
+         #x11091304
+         #x101d0807
+         #x1cf4ed00
+         #xfd131819
+         #xeff5f9e4
+         #x7f5f1ff
+         #xe8fc140b
+         #xf1905f5
+         #x120709ff
+         #x16160011
+         #xfedf505
+         #x3191b0b
+         #xf0fbf2e1
+         #x8f1f5fd
+         #xec070f06
+         #x1f1500ef
+         #xc01ff06
+         #x12090319
+         #xfff20009
+         #xc1a10ff
+         #xf6f7e9ea
+         #x7eef7fd
+         #xf2090409
+         #x1f0dfeed
+         #xfdff12
+         #x9041314
+         #xfa010707
+         #x10130300
+         #xf6eee8f8
+         #x2eefaff
+         #xf606020c
+         #x1c0900ec
+         #xf9fb051c
+         #x4091b09
+         #x30b0402
+         #xb09000a
+         #xefe9f402
+         #xfdf3fefe
+         #xf7030609
+         #x150c00eb
+         #xfbff111f
+         #x61113fe
+         #x1009fb00
+         #x203080f
+         #xe8f20101
+         #xfef9fcf7
+         #xf6030804
+         #x140ffeed
+         #x204141b
+         #xe1205fe
+         #xefff905
+         #x70c05
+         #xec0005fc
+         #x2f8f6f1
+         #xf8060603
+         #x180efcf0
+         #x8061016
+         #xf090005
+         #xfb010b
+         #x40903f6
+         #xf90500fd
+         #x3f2f2f3
+         #xfd090305
+         #x1909fcf2
+         #x7030915
+         #x800030c
+         #xf6030b0c
+         #x501f4f4
+         #x2010108
+         #xfcebf6fc
+         #x20b0207
+         #x120500f4
+         #x4000618
+         #x1000e0c
+         #xfd0e0c09
+         #xf7ecfd
+         #xfd0c11
+         #xf2f1fe01
+         #x80a0201
+         #x70402f7
+         #x3fd0919
+         #xfe081107
+         #x9120905
+         #xf4eeee07
+         #xfb051d0d
+         #xf10001ff
+         #x1008fff6
+         #xff060200
+         #x4fb0e13
+         #xff100d03
+         #x100e07ff
+         #xececf80d
+         #xff151f00
+         #xff0afaf9
+         #xf01f7f0
+         #xfb07050c
+         #x6fd0e08
+         #x7150303
+         #x100b05fa
+         #xe9ee030e
+         #xb1f18f4
+         #xf03effc
+         #x6f8f1f8
+         #xfc070c16
+         #x80109fc
+         #x1012fc07
+         #xb0801f9
+         #xeaf40e0b
+         #x191f0def
+         #x15f3f00c
+         #xf9f3f507
+         #xfe091616
+         #xa05fef5
+         #x1208fa0c
+         #x605fefd
+         #xf0030e05
+         #x1f13f9ef
+         #xfee60518
+         #xf4f90015
+         #x3161afc
+         #x902f5fa
+         #xafd070c
+         #x400fe0d
+         #xf5060b04
+         #x1206faf4
+         #xf1f31115
+         #xfc02070b
+         #x5170eef
+         #xbfcf701
+         #x3000a0c
+         #x403010a
+         #xf90a0b05
+         #x404fff2
+         #xf5020c04
+         #x8070500
+         #x41100f2
+         #xcfa0006
+         #x406070b
+         #x5010008
+         #x120902
+         #x307feef
+         #xff01fcfc
+         #xd050301
+         #x207f9ff
+         #xdfd0906
+         #x607020d
+         #xfc0109
+         #xf1602fb
+         #x604f6f2
+         #xffeff101
+         #x9050806
+         #xfe00fc08
+         #xd041002
+         #x5050113
+         #xfafb0608
+         #x180df8f7
+         #xfcf500
+         #xf2e1f90a
+         #x70f1004
+         #xffff0006
+         #xd0b0bfd
+         #x6050818
+         #xf8fe0803
+         #x1500f3f9
+         #xf5f9fe0d
+         #xe5e20408
+         #xf1c0df7
+         #x1fdff00
+         #xd0f04fe
+         #x9071118
+         #xfa010401
+         #x5f8f7fb
+         #xf101080d
+         #xe0ec09fc
+         #x1b1efde9
+         #x3f7fb00
+         #xe0f0307
+         #xc0c1815
+         #xfbfeff06
+         #xfcfcfaf8
+         #xfd0c0800
+         #xe7f400f5
+         #x1f14eee7
+         #xfaf4fd0d
+         #xe09090f
+         #xb0f1b11
+         #xf9fb000e
+         #xff00f5f8
+         #x809fdf5
+         #xedf2fafe
+         #x1e07edee
+         #xf3f80314
+         #xd060f0d
+         #xa14170f
+         #xfafe050d
+         #x4fef2fd
+         #x6fef4f6
+         #xedee0009
+         #x11fff5f4
+         #xf5ff0a14
+         #xa091305
+         #xc17130e
+         #x1050707
+         #xf6f906
+         #xfaf5f4fd
+         #xecf40e0d
+         #x803f8f2
+         #x50909
+         #xa0e0e02
+         #xe14110f
+         #xa070102
+         #xf8f7020d
+         #xeff5f9fc
+         #xf2021401
+         #x907f3f1
+         #x60503ff
+         #xb0e0908
+         #xd10140e
+         #x1006fc03
+         #xf1ff0b11
+         #xeff9faf4
+         #xe0af2
+         #xf01ecf6
+         #x700fefc
+         #xc090b14
+         #x70e180d
+         #x1203f803
+         #xf60b0c14
+         #xf6faf6ea
+         #xc0efaee
+         #xcf4f003
+         #xfefffe03
+         #xb051516
+         #x416190b
+         #x16fdf501
+         #xff0f0b1a
+         #xf8f6f2e6
+         #xf03f0f4
+         #xffecfe0e
+         #xf8040206
+         #xa071c0e
+         #x91e1008
+         #x19f7f3fe
+         #x40e101d
+         #xf1f4f1e7
+         #xaf5f1fc
+         #xeff20e12
+         #xff0c0501
+         #xc0f1a00
+         #x141d050a
+         #x15eff2fe
+         #x50e1b17
+         #xecf8f0e8
+         #x5eff8fd
+         #xeb00120e
+         #xf1103f6
+         #xc100bfc
+         #x1a140110
+         #x8eaf604
+         #x8141e09
+         #xeefcebe8
+         #x2eefdf8
+         #xf10c0d0b
+         #x1d0ffeec
+         #xa0aff04
+         #x17080715
+         #xfaeeff0c
+         #xf1a15fd
+         #xf6f8e3ee
+         #xeefcf6
+         #xfb0d040d
+         #x1f0bfae8
+         #x301ff16
+         #xa031312
+         #xf4fb060d
+         #x151504fd
+         #xf9eee3fb
+         #xfbf0fefa
+         #x7050d
+         #x1708f9ea
+         #xfdfc0b1f
+         #x1091a07
+         #xff050507
+         #x120aff08
+         #xf1e9ed03
+         #xf7f400fc
+         #xff030a0a
+         #x1109f8ec
+         #xfafd151f
+         #x41313ff
+         #xc05ff01
+         #x8020611
+         #xe8effc04
+         #xf7fa00f6
+         #xfd040a04
+         #x120bf6ee
+         #xff041b1d
+         #xd1506fc
+         #x10fdfb03
+         #x2060e0a
+         #xeafd00fe
+         #xfdfbfbee
+         #xfd060603
+         #x160af5f0
+         #x40b1818
+         #x110b0002
+         #x2f7ff0b
+         #x50c08fb
+         #xf604fdfb
+         #xf5f4ed
+         #x70306
+         #x1807f6f1
+         #x6091119
+         #xa010309
+         #xf8fd070f
+         #x908f6f6
+         #x101fc01
+         #xfaeef4f6
+         #x407030a
+         #x1305f8f1
+         #x4020f1c
+         #xff0c0b
+         #xfd080b0d
+         #x6fbea00
+         #xfd070a
+         #xf0f2fbff
+         #x9060703
+         #x905f9f8
+         #x1fd121a
+         #xfd081008
+         #xa0d0a05
+         #xfbeeed0b
+         #xf8041609
+         #xeffb0000
+         #xc0505f8
+         #x408fa00
+         #xfd1512
+         #x2110b05
+         #x120c07ff
+         #xefe9f90f
+         #xf8161dfe
+         #xfb03fefa
+         #xd03fcf0
+         #x306fd0b
+         #xff011609
+         #xc130306
+         #x110a03fb
+         #xe9ed040e
+         #x71f14f1
+         #xafff6f9
+         #x7fcf1f9
+         #x3050813
+         #x60dff
+         #x140e0008
+         #xd0afffd
+         #xe9f60c0b
+         #x181f07eb
+         #xff0f403
+         #xfcf5f009
+         #x3081310
+         #x30901f9
+         #x1605000a
+         #x906fb05
+         #xed000f07
+         #x1f19fbed
+         #x4e60015
+         #xf5f6fb14
+         #x2101b03
+         #x706f6f7
+         #xdfe040c
+         #x602fb0a
+         #xf8090806
+         #x1d04f4ef
+         #xeaf70f1a
+         #xf8fc1009
+         #x91c0af4
+         #x8f9f6fe
+         #x1010c0b
+         #x4fd030f
+         #xfd080706
+         #xd01f9f1
+         #xed07120f
+         #x2030dfb
+         #xd17fbf5
+         #x5f5fe02
+         #x1060a0d
+         #x5000408
+         #x10c0805
+         #x606f9ef
+         #xfc090401
+         #xa0305f9
+         #xc08f401
+         #x2fb0703
+         #x606050e
+         #x3fe0408
+         #xb0f0500
+         #x905f3f3
+         #xfcfa00
+         #x8020401
+         #x7fffa0b
+         #x3040a00
+         #x7030611
+         #xfdfc0608
+         #x170cfdf9
+         #x7fdef01
+         #xf6eafb05
+         #x4070a06
+         #x2fd020a
+         #x60f08fd
+         #x5010b12
+         #xf8000905
+         #x1400f8f9
+         #xfdf6f710
+         #xe5ea0605
+         #xe140cfc
+         #x1ff0202
+         #xc1101fd
+         #x5041312
+         #xfa030503
+         #x8f7f8fb
+         #xf6fb0314
+         #xe0f60afb
+         #x1c1a02ed
+         #xfdfe04
+         #xf0c0002
+         #x70a1711
+         #xfc000106
+         #xfdf8fbfa
+         #xfb06090a
+         #xe40001f1
+         #x1f11f3e4
+         #xfaf8fc0f
+         #x11070809
+         #xa111810
+         #xfafb010d
+         #xfffdf7f7
+         #x80900fd
+         #xebfbf8f7
+         #x1e02ede9
+         #xf2f7021c
+         #xe071207
+         #xb151310
+         #xf7fd080d
+         #x3fbf4f9
+         #xb00f5fb
+         #xedf3fc04
+         #x14faf2ef
+         #xf3fe0a1e
+         #x90c1300
+         #xd17100f
+         #xfb020b09
+         #x1f4f700
+         #xf7f301
+         #xeaf60909
+         #x9fdf8f0
+         #xfb040e14
+         #x9120dfb
+         #x1115100d
+         #x3070506
+         #xf8f3000a
+         #xf5f4f801
+         #xec041100
+         #xb02f5ee
+         #x3070707
+         #xd110701
+         #xf11110d
+         #xb040008
+         #xf4fc080f
+         #xf2f7fbf8
+         #xf8120af4
+         #xffff1f0
+         #x504ff04
+         #xd0a0a0b
+         #xb12140d
+         #xefffe08
+         #xf8060b12
+         #xf6fbf6ec
+         #x714fbed
+         #xcf3f1fb
+         #xfb0a
+         #xa051412
+         #x817140c
+         #xefafe04
+         #x20a0e15
+         #xf8f9efe9
+         #xe04f2f4
+         #xffedfe07
+         #xfcff0010
+         #x60b1e09
+         #xd1d0e0b
+         #xdf6fcfd
+         #x8081616
+         #xf5f6eaee
+         #xaf6f4fa
+         #xf1f30a0f
+         #x104050a
+         #x71518fe
+         #x171b070b
+         #x9f1f8fc
+         #x70a1e0f
+         #xf0f6e8f3
+         #x1effcf8
+         #xed02110f
+         #xd0a05f9
+         #xb1b0afb
+         #x1f13040c
+         #xfeedf705
+         #x7111f02
+         #xf3f7e5f5
+         #xfcf2fff2
+         #xf60d0d0d
+         #x180bffec
+         #xd13fe05
+         #x18070b0f
+         #xf2effd10
+         #xd191af7
+         #xfbf3e2f8
+         #xf8f6fdef
+         #x10d090b
+         #x1a08f7e8
+         #x904ff16
+         #xb04130e
+         #xedf70413
+         #x151808f6
+         #xfeeae200
+         #xf5f7faf4
+         #x707090a
+         #x1605f2ee
+         #x1fb0c1f
+         #x10b1908
+         #xf600090d
+         #x150c0002
+         #xf5e3ea08
+         #xf2fafdfa
+         #x3030f06
+         #x1004f1f4
+         #xfcff191f
+         #x5141000
+         #x5040402
+         #xc02060d
+         #xebe9f70a
+         #xf4fe00f6
+         #x41000
+         #x1104f0f6
+         #xfb071f1b
+         #xc1603fc
+         #xbfefe00
+         #x202110b
+         #xeaf7ff04
+         #xfa00fdec
+         #x70aff
+         #x1503f0f5
+         #x101d17
+         #x130efffe
+         #x2f7fe07
+         #x40c0efd
+         #xf6fffafe
+         #xfcfdf4e9
+         #x2070502
+         #x1600f1f4
+         #x6111619
+         #xc020204
+         #xf6f90610
+         #xb0bfef6
+         #x1fdf700
+         #xf8f6f0f0
+         #x5040706
+         #x1200f2f6
+         #x60a151d
+         #x1010a07
+         #xf7020d0e
+         #xcfdeeff
+         #x1f9fe08
+         #xf0f3f5fc
+         #x6030c02
+         #xd00f2fb
+         #x102181c
+         #xfe080e07
+         #x5090d05
+         #xedf00b
+         #xf8000d0a
+         #xeefaffff
+         #x8050bf7
+         #xa00f303
+         #xfc041b12
+         #x3100b05
+         #xe0b08fd
+         #xf3e6fd10
+         #xf7131502
+         #xf70000f9
+         #x80600f1
+         #xa00f90b
+         #xfb091608
+         #xd110604
+         #xf0a02fc
+         #xe8eb080f
+         #x61f0ff5
+         #x4fffaf4
+         #x700f2f7
+         #xaff0411
+         #xfb100d03
+         #x150c0402
+         #xd07fd02
+         #xe8f70c0d
+         #x1a1f01ec
+         #x7f4f5fc
+         #xf6f107
+         #x603100f
+         #xf02ff
+         #x12040602
+         #xc03fb0b
+         #xed000c0b
+         #x1f15f5ea
+         #xfdecfc0c
+         #xf9f2fd13
+         #x4101604
+         #x608f9fd
+         #xb000904
+         #xafdfd13
+         #xf6080907
+         #x1f09f2ed
+         #xeef10b19
+         #xf6f70c10
+         #x51a11f7
+         #x9fef6fd
+         #x2ff0c09
+         #x6fd0112
+         #x70704
+         #x13fcf4f0
+         #xec07141d
+         #xfa0515f4
+         #x1715faf8
+         #x1f5fa01
+         #x80b0b
+         #xa07
+         #x1070805
+         #x801f6f2
+         #xfb0f0d0c
+         #x20807f0
+         #x1706f300
+         #xfcf90004
+         #x509090b
+         #x2000605
+         #x70a0801
+         #xb02f1f6
+         #x404ff03
+         #x40400fb
+         #xffbfa0b
+         #xfd040405
+         #x7040909
+         #xfefe0707
+         #xf0a03fb
+         #xcfaed00
+         #xfdf7fc05
+         #x3030503
+         #x5fa040c
+         #x30d0302
+         #x3000e0a
+         #xf9000907
+         #x1103fcf8
+         #x5f1f410
+         #xebf20307
+         #x60b0dff
+         #x705
+         #xb0ffeff
+         #x3130a
+         #xf9050804
+         #x7fbfafa
+         #xfbf30317
+         #xe2fe0700
+         #x151308ee
+         #x10005
+         #x110bfe00
+         #x20a150d
+         #xfd040304
+         #xfef8fbfb
+         #xfaff0c0f
+         #xe80700f6
+         #x1f10fae3
+         #xfefdfd13
+         #x11040403
+         #x6101310
+         #xfcff0207
+         #xfcfbfaf7
+         #x4060702
+         #xf104f5f5
+         #x1c01eee2
+         #xf6f7021e
+         #xd050d02
+         #xd151112
+         #xf7fd090b
+         #xfaf5f5
+         #xb01fb00
+         #xf2faf700
+         #x10f8efea
+         #xf4fa0e1f
+         #xa100efb
+         #x11160f10
+         #xf6040d09
+         #xf4f6fb
+         #x5f7f503
+         #xedf80208
+         #x7f9f5ec
+         #xfa02141c
+         #xa1509f7
+         #x13130f0b
+         #xfe090a08
+         #xf7f2fd03
+         #xfaf1fa05
+         #xec050c04
+         #x6fef6e9
+         #x1090f10
+         #x101402fb
+         #x12110f0a
+         #x606040a
+         #xf2f8060a
+         #xf5f5fefd
+         #xf71307f8
+         #xcfef2e9
+         #x506040b
+         #x100b0604
+         #xd110f0c
+         #x800030b
+         #xf6010c0c
+         #xf6faf9f1
+         #x614fcf1
+         #x9f5f1f2
+         #x400ff12
+         #xc080f09
+         #xc160f0e
+         #x6fd0304
+         #x6100b
+         #xf9f9eeee
+         #x1107f3f3
+         #xfeeff800
+         #xfb0217
+         #x60e1707
+         #x121b0d0c
+         #x2fb01fd
+         #x606180a
+         #xf8f3e7f6
+         #xbf8f5f8
+         #xf1f5040c
+         #x1fe0a0c
+         #x71c12ff
+         #x1b180908
+         #xfff9fafe
+         #x40a1f05
+         #xf6efe6fe
+         #xf3fcf6
+         #xef010d0f
+         #x7030afb
+         #xd1f06fe
+         #x1f0f0807
+         #xf7f4f707
+         #x2111ffb
+         #xf8ede700
+         #xf7f9fdf0
+         #xf90b100b
+         #x100902ec
+         #x1416fc04
+         #x19080b09
+         #xeef1fb15
+         #xa1b16f1
+         #xfdeae6ff
+         #xf4fef8ef
+         #x50d0e06
+         #x1307f6ec
+         #x12060014
+         #xc06100b
+         #xeaf60518
+         #x141c07f0
+         #xfee5e702
+         #xf4fff4f5
+         #x9080f02
+         #x1101eef4
+         #x8fc0d1d
+         #x20b120a
+         #xf0ff0b0f
+         #x1710fdfa
+         #xf6e0ed0b
+         #xf3fef7fb
+         #x40512ff
+         #xffeedfd
+         #xfefe1b1d
+         #x6150f04
+         #xfe050903
+         #xd030306
+         #xeae3f80f
+         #xf500fdf9
+         #x711fa
+         #xffbeffe
+         #xfa0d1f19
+         #x111704fd
+         #x5020100
+         #x3021007
+         #xe8ef000a
+         #xf902fcef
+         #xa0af9
+         #x12faf1fb
+         #xff181e17
+         #x150efefb
+         #x1fbfd05
+         #xb12fe
+         #xf3fafe01
+         #xfe01f3e8
+         #x30a06fd
+         #x12faf1f9
+         #x8181919
+         #xf04ffff
+         #xf6f8040e
+         #xa1003f4
+         #xfff9f800
+         #xfbfbecef
+         #x5060801
+         #xffaf1fb
+         #xa12191d
+         #x2010504
+         #xf2000e0e
+         #xe03f5f8
+         #xf5f908
+         #xf5f5f0fb
+         #x4050eff
+         #xcfaf1ff
+         #x60c1c1b
+         #xff090a07
+         #xfc0a1003
+         #x4eff404
+         #xf9f8050e
+         #xf1f6fb00
+         #x3090ef6
+         #xcf9f304
+         #xff0c1c15
+         #x5100a04
+         #x70d09fa
+         #xf3e7010c
+         #xf7090e09
+         #xf6fe00f9
+         #x60c02f0
+         #xcf7f909
+         #xfc14170d
+         #xf100800
+         #xb0b02fb
+         #xe6ec0d0d
+         #x61b0cfd
+         #xff00fbf1
+         #x805f5f5
+         #x9f8020c
+         #xff170e09
+         #x120b06fc
+         #xa07fd03
+         #xe4f90f0c
+         #x1d1c00ee
+         #x3fbf1f7
+         #x4f9f102
+         #x4000e0c
+         #x5130307
+         #x100607fb
+         #xa00fd10
+         #xec020c0b
+         #x1f10f3e9
+         #xfbf2f409
+         #xfbf0000d
+         #x20b1306
+         #xa0bfe03
+         #x80307fe
+         #x9fb0115
+         #xf6060a09
+         #x1f03eeeb
+         #xedf40219
+         #xf4f41109
+         #x8180efd
+         #xafffa00
+         #x30704
+         #x4f90812
+         #xff080704
+         #x1afcf2ef
+         #xe901131f
+         #xf60018fa
+         #x121800f7
+         #x5f6f900
+         #x60a0a
+         #xfd0a0b
+         #x1060900
+         #x5fbf4f5
+         #xfc0d181a
+         #x1103ea
+         #x1c03f7fb
+         #xf9f8fc0b
+         #x50a0a05
+         #xfd040a01
+         #x3080a00
+         #x8fff3f6
+         #x90c0a0a
+         #x60af8f5
+         #x13f7fc05
+         #xfa00000e
+         #x7070a03
+         #xfe010705
+         #x90a07fc
+         #xdf8efff
+         #x4feff0a
+         #x303fe02
+         #x4f80608
+         #x108020b
+         #x3040c01
+         #xfa020907
+         #xc06fff8
+         #x6eff50b
+         #xf6f7010d
+         #x2060800
+         #xfd000b05
+         #xb0a0005
+         #x60e03
+         #xfa060905
+         #x700fafb
+         #xf9ee0313
+         #xeaff0708
+         #xc0f0af0
+         #xff040504
+         #x1205fe00
+         #xff0a0f0b
+         #xff070502
+         #xfefbfbfd
+         #xf5fa100f
+         #xef0801fd
+         #x1710fde2
+         #x10
+         #x11020001
+         #x5100f10
+         #x20302
+         #xfafcfbfa
+         #xfb050e04
+         #xfa06f7f8
+         #x1906eee1
+         #xfdf8041e
+         #xc040700
+         #xc130f12
+         #xfb000505
+         #xfdfbf6f4
+         #x70402ff
+         #xfdfbf4ff
+         #xff9e9e9
+         #xf6f8121f
+         #x80e09fb
+         #x11120f10
+         #xf7050b08
+         #xfdf6f2f7
+         #x4f9fc03
+         #xf4f7fe09
+         #x4f8eeed
+         #xf6021b1d
+         #xc1603f5
+         #x14110f0b
+         #xfd0c0a0a
+         #xf8f3f7ff
+         #xfbf2fe05
+         #xf0000807
+         #x2fcf2e9
+         #xfe0b1a13
+         #x1314fff8
+         #x13100d0a
+         #x40a060c
+         #xf2f70005
+         #xf3f502fe
+         #xf80e08ff
+         #x6fdf0e5
+         #x50a0c0e
+         #x150c00ff
+         #x10100b0e
+         #x604060c
+         #xf4ff0a06
+         #xf4fbfdf3
+         #x811fdf6
+         #x6f8eced
+         #x6010613
+         #xe070806
+         #xf120c10
+         #x2010708
+         #xfc060f03
+         #xf8faf3f1
+         #x1206f5f5
+         #xfef3effd
+         #x2fb0915
+         #x70f0f06
+         #x13130d0d
+         #xfe020301
+         #x1081300
+         #xfaf2eaf9
+         #xef9f5f9
+         #xf3f4fc0a
+         #xfffc120d
+         #x91c0e01
+         #x1a140d07
+         #xfc00fb01
+         #xe18fe
+         #xf8e9ea01
+         #xf6faf8
+         #xf200080e
+         #x411fb
+         #x131f0500
+         #x1d0e0a03
+         #xf8faf50d
+         #x11818f8
+         #xf7e6ef01
+         #xf8fbfaf4
+         #xfb090f08
+         #x60a06ee
+         #x1a17ff05
+         #x17080805
+         #xf2f3fa18
+         #x91f0eef
+         #xf8e4f0fe
+         #xf601f4f3
+         #x50d1000
+         #xc09f7ef
+         #x1a03000f
+         #xb07090e
+         #xecf4051c
+         #x151f00ec
+         #xf7e2ef00
+         #xf900f0f9
+         #x90b10fc
+         #xe00edfa
+         #xdfb0f18
+         #x50c0c10
+         #xeefd0f12
+         #x1b14f7f4
+         #xefe0f209
+         #xfafbf4ff
+         #x50a0ff9
+         #xdf7ee03
+         #x21c1a
+         #x7120b0a
+         #xf9060d03
+         #x1206fc00
+         #xe5e2fc11
+         #xfafcfdfd
+         #x10d0cf6
+         #xcf4f303
+         #xfb101f17
+         #x11140600
+         #x20703fe
+         #x4030904
+         #xe2ec040e
+         #xfc00fdf2
+         #x31006f7
+         #xbf4f6fe
+         #x11d1c16
+         #x170dfff9
+         #x1fffd06
+         #xc0ffe
+         #xebf60304
+         #x2f5ea
+         #x50d01fa
+         #xaf5f5fb
+         #xb1d1a18
+         #x1303fdfb
+         #xf9fa000f
+         #x81406f3
+         #xf9f9fcff
+         #x1fcebee
+         #x70904ff
+         #x8f5f4fe
+         #x10171a1b
+         #x6000002
+         #xf2fe0c10
+         #x100bf7f3
+         #xfbf3fa05
+         #xfcf2edfb
+         #x3080afe
+         #x7f4f401
+         #xb121e1b
+         #x1050607
+         #xf7080f04
+         #x9f8f4fd
+         #xf6f4010f
+         #xf6f1f800
+         #x30e0af8
+         #x8f3f603
+         #x4151e16
+         #x50c0805
+         #x21009fa
+         #xf5eb0007
+         #xf3ff0d0f
+         #xf6f900fc
+         #x71200f1
+         #x7f3fc04
+         #x2191812
+         #xe0f08ff
+         #x90efffa
+         #xe4f10c0a
+         #x20f0e00
+         #xfe00fbf2
+         #xb0af4f3
+         #x2f50306
+         #x61b1111
+         #x120b06f9
+         #xa07fb06
+         #xe2fe0f0a
+         #x181704ef
+         #x200f0f7
+         #x9fdf2fe
+         #xfefd0b09
+         #xc150b0e
+         #xe0801f8
+         #x800ff0f
+         #xec060d09
+         #x1f0df6e5
+         #xfdf5ed0a
+         #xfdf2ff06
+         #xfd091007
+         #x11090609
+         #x807fffe
+         #x6fc0613
+         #xf7080b06
+         #x1e00eee7
+         #xf2f1fd1c
+         #xf2f61002
+         #x6140d00
+         #xd000103
+         #x4060004
+         #xfb0d10
+         #xfe070a01
+         #x14f7eeee
+         #xedfa0f1f
+         #xf10415f5
+         #x141503f9
+         #x6f9fd02
+         #x208030a
+         #xfc001007
+         #x1060900
+         #x7f9f3f4
+         #xf5091a1f
+         #xfb100bea
+         #x1e0af8f9
+         #xfcf6fb07
+         #x50a090a
+         #xfc040c01
+         #x20907fe
+         #x1faf3f9
+         #x7101910
+         #xb0feff3
+         #x10fafbfb
+         #xf7fa0218
+         #xa0a09fe
+         #xfe070503
+         #x50c08fc
+         #x8f9f2fa
+         #xb05090b
+         #x902f202
+         #xf80403
+         #xff000815
+         #x60707fd
+         #xfc040707
+         #xb0a00f9
+         #x3f0f504
+         #xfffb0511
+         #x3020105
+         #xf9010b02
+         #x9030709
+         #x1070700
+         #xfb080905
+         #x903fafb
+         #xf7ee010c
+         #xf4fc0a0e
+         #x60b07f9
+         #xfd080701
+         #xe010301
+         #xb0708
+         #xa0600
+         #x1fef900
+         #xedf90f0b
+         #xf5040902
+         #x1111fde8
+         #x2040209
+         #xeff0000
+         #x50e0a11
+         #x40602ff
+         #xfdfdfaff
+         #xf4051004
+         #x5fef9
+         #x1609ebe7
+         #xfb0719
+         #x9010201
+         #xc100d13
+         #x10202
+         #xfdfdf8f9
+         #xff0909fe
+         #x3fbf7fc
+         #x11fce3ef
+         #xf8fb151f
+         #x70a05ff
+         #x1010100f
+         #xfc030507
+         #xfef8f1f8
+         #x4000000
+         #xfcf3fc06
+         #x6f4e8f5
+         #xf3051f1e
+         #xc1301f8
+         #x110f100a
+         #xff0a080b
+         #xf8f3f1ff
+         #xfbf80101
+         #xf4fb0809
+         #xf8edef
+         #xf9121f12
+         #x1610fcf6
+         #x100e0c0b
+         #x60a070f
+         #xf3f4fa05
+         #xf1f906fd
+         #xf9070a01
+         #x3fbece9
+         #x312160c
+         #x1809fbfb
+         #x100e0910
+         #x907070f
+         #xf3fc0304
+         #xf0ff01f3
+         #x80d02f8
+         #x5f9e6ed
+         #x8080d0f
+         #x10050102
+         #xf0d0b14
+         #x405080c
+         #xfa040800
+         #xf7fef7f0
+         #x1205f9f5
+         #xf3e7fe
+         #x1001112
+         #xa0b0906
+         #x120f0f0f
+         #x50408
+         #xb0aff
+         #xfaf4eff7
+         #x10fbf7f8
+         #xf8f2f20c
+         #xfb00170a
+         #xb170a04
+         #x150f1007
+         #x3fd0a
+         #x10f0cff
+         #xf8e9efff
+         #x2f6f9fb
+         #xf5fa0210
+         #xf90a16fb
+         #x151c0601
+         #x170e0b02
+         #xfcf712
+         #x4190bfb
+         #xf1e5f6fe
+         #xf9fcfaf9
+         #xfc050e08
+         #xff1008f1
+         #x1e110003
+         #x140a0409
+         #xfbf2fc1d
+         #xd1f04f4
+         #xede7f9fa
+         #xfa00f6f7
+         #x40c0ffe
+         #x80cf8f3
+         #x1c030309
+         #xd080311
+         #xf3f1081e
+         #x181cf9ee
+         #xebe7f6fc
+         #xfffcf2fa
+         #x90e0cfa
+         #xd00effe
+         #x10fd0f11
+         #x6090718
+         #xeffb1313
+         #x1e12f1f2
+         #xe6e5f606
+         #xf5f7ff
+         #x70f08f9
+         #xbf4f205
+         #x41915
+         #x90e0b10
+         #xf7061006
+         #x1905f3fc
+         #xe1e6fd11
+         #xfef5fffc
+         #x51103f9
+         #x6f0f904
+         #xfc141e15
+         #x11100a02
+         #x10a0601
+         #x9010003
+         #xe0ee0612
+         #xfdfc00f2
+         #x91200f9
+         #x1f2fdff
+         #x41f1b14
+         #x150c02f9
+         #x502fc07
+         #x2090800
+         #xe4f80805
+         #x100f8e9
+         #xd0ffbfb
+         #xf6fbfd
+         #x101e1a16
+         #x1103fcfb
+         #xfefafe12
+         #x71203f7
+         #xf0fc01fd
+         #x4fceeeb
+         #xc09fdff
+         #xf5f7ff
+         #x15191b18
+         #x9fffb02
+         #xf6fc0813
+         #x120ff7f2
+         #xf6f7fb01
+         #xf1eef7
+         #x7080201
+         #xf3f802
+         #x11161f17
+         #x1000109
+         #xf6070e09
+         #xefdf1fa
+         #xf1f3000d
+         #xf9ecf8fe
+         #x50d05fd
+         #xf2fa02
+         #xb1a1f15
+         #x5070708
+         #x10e06fe
+         #xfcf2f804
+         #xeffa0b10
+         #xf5f400fa
+         #xa12fff7
+         #xfef2fe00
+         #x91e1c13
+         #xb0a0800
+         #xc0cfcff
+         #xe8f5040a
+         #xf8081101
+         #xf9fffdf2
+         #x110df4f5
+         #xfaf60201
+         #xe1d1712
+         #xf0b04fb
+         #xe04f706
+         #xe6010b0a
+         #xe1209ec
+         #xf0f6
+         #xffff1fb
+         #xf6fd0707
+         #x1314130f
+         #xe09fdfc
+         #xafefe11
+         #xf00a0a07
+         #x1e0efbe1
+         #xf5ed0b
+         #x2f4fc02
+         #xf8060c09
+         #x140b1008
+         #xb07f702
+         #x5fc0712
+         #xfb0b0a03
+         #x1c00eee2
+         #xf8ebfc1e
+         #xf4f80a01
+         #x2100c03
+         #xf040b03
+         #x804f809
+         #xff00100c
+         #x80aff
+         #xef6ecec
+         #xf0f0101f
+         #xf1070ef7
+         #x111206f9
+         #x7ff0202
+         #x704fe0d
+         #xfa061106
+         #x709fc
+         #x1f5eff4
+         #xf3001b1d
+         #xfb1303ec
+         #x1a0afef3
+         #xfffbfd0a
+         #x806050a
+         #xfb0b0d01
+         #x10808fe
+         #xfaf3f7
+         #x10e1e15
+         #x913f4ee
+         #x18fef9f7
+         #xf8f80015
+         #x90a0902
+         #xfe0a0700
+         #x50b04ff
+         #x3f8f2fa
+         #xb121509
+         #x11feec00
+         #xfffcfe02
+         #xf9f90f17
+         #xa0803fb
+         #x1060408
+         #xa0d01fb
+         #x3f3f3fe
+         #x5020b0f
+         #x6f9fc09
+         #xf7010604
+         #xff110c
+         #x50601ff
+         #xff080807
+         #xc06fafd
+         #xf6f0fc07
+         #xf9fe100f
+         #x3030501
+         #xfc090501
+         #x7010a00
+         #x2080207
+         #x20b0601
+         #x6fff802
+         #xecf90809
+         #xf7021103
+         #xc0dfef3
+         #x4090202
+         #x90003fe
+         #x60a0710
+         #x80901fe
+         #xfcfb04
+         #xef070e04
+         #x607f6
+         #x170aecee
+         #x400040f
+         #x5000101
+         #xc0d0d12
+         #x703ff00
+         #xfffcfaff
+         #xfd0d08fe
+         #x4fffcf5
+         #x14fbe2f6
+         #xfaff131b
+         #x4040301
+         #xe0e110e
+         #x106
+         #xfaf4fc
+         #x30802fe
+         #xf6fbfe
+         #x8f0e6fe
+         #xf3091f1a
+         #xa0a02fc
+         #xf0f1109
+         #x4050c
+         #xfcf3ef00
+         #xfeff0100
+         #xf6f60406
+         #xf0eef9
+         #xf7161f13
+         #x140dfdf4
+         #xe0f0d0b
+         #x608080f
+         #xf5f0f507
+         #xf3fe05fc
+         #xf6030b01
+         #xf5ecef
+         #x31c1b0b
+         #x1905f9f6
+         #xe0d0a14
+         #xb070a10
+         #xf3f6ff07
+         #xf10203f5
+         #x30b08f7
+         #x4f5e5f0
+         #xb13110c
+         #x1201fcff
+         #xe0b0c17
+         #x8060a0e
+         #xf8000303
+         #xf702f9f0
+         #xf07fef2
+         #x2efe2fe
+         #x508130e
+         #x9050305
+         #xe0b1112
+         #x407070d
+         #xff070202
+         #xfbf8f1f4
+         #xdfdf9f6
+         #xfbecee0d
+         #xfb091809
+         #xc0e0805
+         #x100e110a
+         #x504000e
+         #x40d0203
+         #xf7edf2fa
+         #x3f9fafa
+         #xf6f10011
+         #xf81117fe
+         #x16130800
+         #x120f0a06
+         #x7fbfd14
+         #x9140302
+         #xedeaf9fb
+         #xfbfbfcfb
+         #xf9fe0d0a
+         #xfe1709f5
+         #x1e0f04fd
+         #x110d020b
+         #x1f1011c
+         #x121800fa
+         #xe6eefbf7
+         #xfdfef9f7
+         #x2090e00
+         #xa10f9f6
+         #x1a030401
+         #xd080017
+         #xf6f00d1c
+         #x1c16f8f1
+         #xe4f0f7fb
+         #xfaf8f7
+         #x80f06fa
+         #xf01f2ff
+         #xf000a09
+         #x905071d
+         #xeffa1714
+         #x1f0ceff0
+         #xe2edf408
+         #x1f2fcf8
+         #xa0f00fe
+         #xbf4f606
+         #x81310
+         #x8081015
+         #xf3081508
+         #x1b00effa
+         #xe0ebfb15
+         #xfdf302f5
+         #xc0ffe00
+         #xf1fe05
+         #xff141912
+         #xd0c0f05
+         #xc0804
+         #xefbf803
+         #xe0ef0617
+         #xfbfb03ed
+         #xf0ffcfe
+         #xfaf50000
+         #x71e1a11
+         #x120b07fa
+         #x604000b
+         #x4030304
+         #xe1fa0c0b
+         #xfe01fbe5
+         #x110bf9fd
+         #xf8f9fefe
+         #x141f1a10
+         #xf05fcfc
+         #x2faff13
+         #xa0d01fb
+         #xec000500
+         #x3fdf0e5
+         #x1006fa00
+         #xf9f9fa03
+         #x191a1c10
+         #x7fff906
+         #xf9f90814
+         #x120df8f5
+         #xf4fdfb00
+         #x2f3eeef
+         #xc05ff04
+         #xfaf6f905
+         #x16191f10
+         #x1fdfe0c
+         #xf6030f0d
+         #x1401eff9
+         #xf2f5fd0c
+         #xf9edf7f9
+         #x9080103
+         #xfbf4fe03
+         #x101c1e0f
+         #x1060b
+         #xc0803
+         #x3f4f305
+         #xedf80812
+         #xf2f300f6
+         #xe0efffc
+         #xf8f5fe00
+         #x111f1d0f
+         #x7070805
+         #xd0afc01
+         #xf1f4fd0e
+         #xf1041104
+         #xf4fffeef
+         #x140af8f6
+         #xf4f9ff02
+         #x151e1b0e
+         #xc0a0401
+         #x1200f709
+         #xec00060e
+         #x2110cec
+         #xfe02f3f1
+         #x12fff3f9
+         #xf3fd0109
+         #x1818190a
+         #xd09fb01
+         #xcf8fe11
+         #xf6090808
+         #x1411fbe0
+         #x1f5ef05
+         #x6f5fa00
+         #xf703060f
+         #x16111703
+         #xc05f508
+         #x4fa0811
+         #xa0702
+         #x1705ece2
+         #xfbe8fd1b
+         #xf9f80303
+         #x10b0a09
+         #xf0d0ffe
+         #xbfff70e
+         #xff000e0e
+         #x50807fe
+         #xcf8e5ec
+         #xf0ea131f
+         #xf40508fc
+         #xe0f08fa
+         #x7090500
+         #x9feff0e
+         #xfc090f08
+         #x30705fd
+         #xf3eaf6
+         #xeefe1e1b
+         #xff11fff2
+         #x160c00f0
+         #x10009
+         #x700060b
+         #xff0e0b05
+         #x10802fe
+         #xfbf5f0f9
+         #xfa0f1f11
+         #xe11f0ef
+         #x1202f9f3
+         #xfbfb0214
+         #x8040902
+         #x20d0605
+         #x40b0400
+         #x1f9f2f9
+         #x815190a
+         #x1404eafb
+         #x5fdfafe
+         #xf8f80c1a
+         #xa0806fe
+         #x3090307
+         #xb0a0000
+         #x2f3f1fe
+         #xa120f0a
+         #x7f1f907
+         #xfafe000e
+         #xf902170a
+         #x704fffc
+         #x405070b
+         #xd09fb00
+         #xfaf0f604
+         #xff04120e
+         #xfff90607
+         #xfc070406
+         #xff070efe
+         #x4030002
+         #x40a0805
+         #xa00f905
+         #xeff5010a
+         #xf9081502
+         #x50703fb
+         #x6090002
+         #x20604fc
+         #x5060609
+         #xa0a02ff
+         #x3fbfd09
+         #xf0020907
+         #xfd0d0df5
+         #x1107f4f4
+         #x9040008
+         #x2020000
+         #x9080d0e
+         #xb04fe00
+         #xfffc0005
+         #xfd0c0600
+         #x408feef
+         #x15fae8f9
+         #xb16
+         #x10203
+         #xc0c120b
+         #x4fffe06
+         #xfffafaff
+         #x60a01ff
+         #xfdf9f8
+         #x9ecec01
+         #xf7081a1b
+         #x60504fd
+         #xd0e1108
+         #x30b
+         #xfef5f500
+         #x4030000
+         #xf9f90000
+         #xfeeaf400
+         #xfa191f13
+         #xd0700f4
+         #xd0f0c0a
+         #x204080d
+         #xf7edf706
+         #xf9000300
+         #xf4000800
+         #xfbf0f4f5
+         #x71f1b0b
+         #x1504f8f2
+         #xe0d0913
+         #x8060b0e
+         #xf1f0ff09
+         #xf50402f8
+         #xfd0a06f6
+         #xfff2e9f1
+         #x121b130a
+         #x1200f7fb
+         #xc0a0e19
+         #x8070d0e
+         #xf3fa0306
+         #xfb04faf2
+         #x90afff0
+         #xebe5fd
+         #xd11110d
+         #x900fe04
+         #xb0a1415
+         #x6070b0d
+         #xfc010005
+         #xfcf1f3
+         #xb02f7f3
+         #xfae5ee0c
+         #x10160b
+         #x9060605
+         #xb0e130b
+         #x704060e
+         #x4050008
+         #xfaf1f1f9
+         #x2fcf8f9
+         #xf3e9010f
+         #xfd161402
+         #x120c09ff
+         #xe120909
+         #x8fe0411
+         #x9070106
+         #xefeff6fb
+         #xfcfcfcfa
+         #xf3f70f08
+         #x31a0afb
+         #x1a0c04f8
+         #x110e0110
+         #x2f50816
+         #x100d02fe
+         #xe5f2f9fa
+         #xfdfdfdf5
+         #xfc040e00
+         #x1114fcf9
+         #x180700fa
+         #xf07001a
+         #xf5f31218
+         #x1c0cfdf1
+         #xe5f5f401
+         #xfafcf0
+         #x50d05fe
+         #x1402f500
+         #xc040204
+         #xa020a1f
+         #xebfe1a12
+         #x1e05f4ed
+         #xe7f3f20e
+         #xfff6fdee
+         #xc0dfd00
+         #xcf6f905
+         #x2080a0e
+         #x7031617
+         #xee0a180b
+         #x18fbeff5
+         #xe5edf81c
+         #xf9f700ec
+         #x100bfc03
+         #xfef30006
+         #x1131310
+         #x80a1605
+         #xfc100d07
+         #xcf5f501
+         #xe2ef051e
+         #xf6ff00e6
+         #x1208fd00
+         #xf5f90203
+         #xa1b170d
+         #xc0d0afc
+         #x608030a
+         #x3faff05
+         #xe4fa0d12
+         #xfa06f9e1
+         #x1305fdfe
+         #xf5fe0005
+         #x161d1908
+         #xd08fdfe
+         #x5fd0312
+         #x50504ff
+         #xec020904
+         #x104efe0
+         #x1001fcff
+         #xf8fdfb08
+         #x1c1b1806
+         #x800f709
+         #xfaf80b15
+         #x100afcf6
+         #xf600fe04
+         #x1f7ebe7
+         #xb00ff05
+         #xfaf8fc0b
+         #x191c1a08
+         #x1fbfe11
+         #xf501110d
+         #x1401f2f8
+         #xf7f9fa0e
+         #xfaf0f2f2
+         #x9030305
+         #xf8f7ff08
+         #x141e1b08
+         #xfefe060f
+         #xfc0a0e05
+         #x9f4f103
+         #xf0f50516
+         #xf0f5fcf3
+         #xc0703ff
+         #xf6f8ff04
+         #x161f1908
+         #x1040909
+         #x9090101
+         #xf8f1fc0e
+         #xef00100a
+         #xf100fcec
+         #x1307fef6
+         #xf4fafd07
+         #x1b1f1a06
+         #x70a0306
+         #xffefc06
+         #xf1fa060f
+         #xfa0f0df4
+         #xfb03f3ec
+         #x12fff8f5
+         #xf4fcfe10
+         #x1c1d1a02
+         #xc09fc09
+         #x9f5000d
+         #xf9030a07
+         #xc14fbe3
+         #x2f9eefa
+         #x7f5f8fd
+         #xf8ff0315
+         #x181917fd
+         #xc04f70e
+         #xf70a10
+         #x3070900
+         #x1508e8e6
+         #xfce9fc11
+         #xfbf70003
+         #x40b0f
+         #x11180ff9
+         #xbfcfb11
+         #xfb00100e
+         #x70605fe
+         #xef8e1f2
+         #xefeb131e
+         #xf7010500
+         #xa0b0a00
+         #xc1405fd
+         #x6f8030f
+         #xfd090f0c
+         #x50502ff
+         #x1eee5fb
+         #xe7ff1f19
+         #xc00f4
+         #x120c01f2
+         #x70aff06
+         #x1fb0a09
+         #x20e0b0a
+         #x3060003
+         #xfbefedfc
+         #xf1141f0d
+         #x100bf4ee
+         #x1005f7f4
+         #x512
+         #x2000a03
+         #x80d0709
+         #x5080005
+         #xfef4f1fa
+         #x21e1a04
+         #x16ffedf5
+         #x7fef401
+         #xfbfb1017
+         #x50506fe
+         #xa08040a
+         #x90b0003
+         #x3f5f1fa
+         #xc181007
+         #xdf2f202
+         #xfcfefc0c
+         #xf7ff1811
+         #x80500fd
+         #x606050c
+         #xd06fe03
+         #xfceef405
+         #xa0f0f0b
+         #xf9f30507
+         #xff00060f
+         #xfb1110fe
+         #x300fffa
+         #x6070b09
+         #xb01fb07
+         #xf2effc0b
+         #xfe0d1405
+         #xfc0108ff
+         #x6060403
+         #x11002f9
+         #x2010401
+         #xa0a0702
+         #x4fbff0b
+         #xf2fa050b
+         #x150df7
+         #xa06fdf6
+         #xc040005
+         #x307fd00
+         #x5060c05
+         #xc050000
+         #xfffb0409
+         #xfd050605
+         #x513ffef
+         #xffcf2f7
+         #x6000411
+         #x1010006
+         #x90b1007
+         #x6fffe04
+         #xfefc0201
+         #x7070100
+         #x605f4f5
+         #x7edf200
+         #xfd05121b
+         #x1030501
+         #xb0e1005
+         #xfffe010a
+         #xfdf8fcfe
+         #x803ff01
+         #xfdfcf9ff
+         #xf9e9fb01
+         #xff141c17
+         #x70600f6
+         #xd0f0b07
+         #xff01070c
+         #xf7f1fa01
+         #x1000001
+         #xf7ff0200
+         #xf3effdf9
+         #xc1f1b0b
+         #xc05f8f2
+         #xe0d090f
+         #x3060b0c
+         #xefef0006
+         #xfb0302fd
+         #xfa0904f8
+         #xf8f2f3f2
+         #x191e1307
+         #xe00f2fa
+         #xc0a0d17
+         #x6080d0c
+         #xeef60406
+         #x4fcf4
+         #x50cfcf1
+         #xfbebeaf9
+         #x1715100a
+         #x8fdf905
+         #x90b1615
+         #x60a0d0b
+         #xf6fe0306
+         #x5fef3f3
+         #xb07f5f3
+         #xf6e3f106
+         #xb13140c
+         #x6000107
+         #x910150e
+         #x6080b0b
+         #xff000108
+         #xf4f1f8
+         #x5fff4fa
+         #xede5020c
+         #x5181307
+         #xc080700
+         #xd130b0a
+         #x7020a0b
+         #x6000506
+         #xf3f0f4fd
+         #xfffcfafc
+         #xebf40f07
+         #xd1a0bfe
+         #x130c02f8
+         #x1210020f
+         #xfc0d0e
+         #x90207fd
+         #xeaf3f701
+         #xfdfefdf4
+         #xf3030f00
+         #x181300fa
+         #x150afcf9
+         #x11050319
+         #xf3fc1312
+         #xf0504ef
+         #xebf6f406
+         #xfefceb
+         #x10d05fe
+         #x1905fafd
+         #xd07fa03
+         #xaff0e1e
+         #xe8041911
+         #x1603f9e9
+         #xeff2f314
+         #xfefbf8e8
+         #xb0afe01
+         #xef9fd03
+         #x507010e
+         #x4021a16
+         #xec10170c
+         #x12faf0f1
+         #xeeebfb1e
+         #xf9fcf8e8
+         #xf04ff04
+         #xfef60107
+         #x50d0c11
+         #x30b1908
+         #xfa140f08
+         #x7f2f100
+         #xe8ec091f
+         #xf503f8e5
+         #x10020200
+         #xf4fd040a
+         #xd15150a
+         #x8100dff
+         #x70d0608
+         #xfef4fd05
+         #xe6f81218
+         #xfa09f3e1
+         #xf0102fa
+         #xf600000b
+         #x171a1501
+         #xc0cfe01
+         #x601060d
+         #xfefd0400
+         #xed020f09
+         #x105eae0
+         #xc0000fb
+         #xfbfeff10
+         #x1c1c14ff
+         #xa02f80c
+         #xfcfd0c10
+         #x70501f6
+         #xf9030204
+         #x4fbe5e4
+         #x7fe0002
+         #xfdf90012
+         #x1b1d1100
+         #x2fafe13
+         #xf302130d
+         #xe01f6f5
+         #xfcfafc0e
+         #xfdf3eaee
+         #x4000505
+         #xf9f8020e
+         #x191f1202
+         #xfdfb0813
+         #xf90c1105
+         #x9f6f2ff
+         #xf6f50316
+         #xf2f5f5f2
+         #x70408ff
+         #xf6fa0209
+         #x191f1502
+         #xfd030b0e
+         #x50b0700
+         #xfbeffb0b
+         #xeffc1011
+         #xf200f9ee
+         #xc0504f5
+         #xf6fcff0a
+         #x1d1f1500
+         #x409040c
+         #xb010000
+         #xf1f5090b
+         #xf70b0ffd
+         #xfc03f1e9
+         #xe01fcf2
+         #xf8fbff13
+         #x1f1f14fd
+         #xc09fd0f
+         #x3f80306
+         #xf5ff0f02
+         #x711feed
+         #x2fbecf2
+         #x7faf8fa
+         #xfafa0519
+         #x1d1f12f9
+         #xd01fc13
+         #xf8f90a0b
+         #x50cfb
+         #x1407e8ed
+         #xfeedf505
+         #xfbf7fd03
+         #xfeff0e14
+         #x171f0af7
+         #x8fa0012
+         #xf402100d
+         #x50506fa
+         #x13f4e0f9
+         #xefee0b15
+         #xf7ff0401
+         #x5070f02
+         #x141c01fc
+         #x2f7070f
+         #xfa0a0f0d
+         #x40400ff
+         #x6e8e601
+         #xe5011e16
+         #x704f5
+         #xc0c04f6
+         #x1011ff05
+         #xfdfa0b0a
+         #x20d0d0c
+         #x203ff05
+         #xfbe7ef01
+         #xed191f0d
+         #xd08fbe9
+         #xf07f7f8
+         #xa03030e
+         #xfb000b05
+         #xa0b0b09
+         #x4040009
+         #xfaedf3fd
+         #x11f1603
+         #x12fdf1ec
+         #xafdf207
+         #xff0f14
+         #x50601
+         #xc070808
+         #x9060108
+         #xfef0f2fd
+         #xf1e0d03
+         #x9f1f2f9
+         #x2f7f915
+         #xfa05190f
+         #x40500fd
+         #x904080a
+         #xc070004
+         #xffeff201
+         #xe140d0a
+         #xfbef0006
+         #xfdfd0314
+         #xf90d1402
+         #x401fffa
+         #x6050a0c
+         #xb01ff06
+         #xf2ecfb0c
+         #x9101107
+         #xf4ff0704
+         #x1030c02
+         #x51603fd
+         #xf9
+         #x70b0c03
+         #x5fc000b
+         #xeef3040e
+         #x5170efb
+         #x10902f9
+         #x90302ff
+         #x80bfb01
+         #x10405ff
+         #xb0903ff
+         #xfefc070a
+         #xf7ff0808
+         #xc17fff3
+         #xc01f6f7
+         #x8ff020b
+         #x500fe08
+         #x60a0b02
+         #x801ff02
+         #xfcff0803
+         #x3040402
+         #xd0bf4f6
+         #x5f4f4fe
+         #xd17
+         #x1000407
+         #x90e0b02
+         #xfd0007
+         #xfcfe01fd
+         #x8010001
+         #x6fdf400
+         #xf6edfd02
+         #xd1b16
+         #x30603fd
+         #xc0f0903
+         #xfc00060a
+         #xf8f8fdff
+         #x3ff0202
+         #xfcfcfe04
+         #xeff300fd
+         #xc1a1c09
+         #x906f8f7
+         #xe0d0808
+         #xff040a0b
+         #xf0f4ff02
+         #x103fe
+         #xfc0401ff
+         #xf2f8fbf5
+         #x1a1e1500
+         #xa00f0fd
+         #xd0a0c10
+         #x3080b0b
+         #xebf70304
+         #x20300f5
+         #x40cfbf7
+         #xf7f1eff6
+         #x1d180f04
+         #x7f8f309
+         #x90b1513
+         #x60b0c0b
+         #xf1fd0405
+         #x6fff7f0
+         #xc07f2f7
+         #xf2e7f201
+         #x14141208
+         #x3faff0d
+         #x911170e
+         #x70b0c08
+         #xf9ff0306
+         #x2f6f2f4
+         #xafef2fe
+         #xe9e60009
+         #xe161406
+         #x5030505
+         #xd140e0a
+         #x7080b07
+         #xfffe0704
+         #xf7f0f4fc
+         #x2f9f900
+         #xe4f40d07
+         #x11190ffd
+         #xd0a00fc
+         #x1310060d
+         #x40b0a
+         #x1000afb
+         #xeff1f702
+         #xfcfdf8
+         #xed040c01
+         #x1b1406f5
+         #x100af8ff
+         #x13050815
+         #xf5030f0f
+         #x40506ef
+         #xf0f3f808
+         #xfffaed
+         #xfd0c0500
+         #x1c09fff6
+         #xf05f509
+         #xbff1019
+         #xed091412
+         #xa06f9e9
+         #xf4f0f912
+         #xff00f3e8
+         #x90a0001
+         #x11fefefe
+         #x900fe14
+         #x1001a15
+         #xef13150f
+         #xbfeecf1
+         #xf3ea001c
+         #xfb00f0ea
+         #xd030101
+         #xfffb0206
+         #x8050a13
+         #xd1b0b
+         #xfe170f08
+         #x4f5ecfe
+         #xeaec0e1e
+         #xfa02efea
+         #xa0006fe
+         #xf7ff040c
+         #xd0d1309
+         #x6140d03
+         #xa120905
+         #xfaf2f806
+         #xe5f81a15
+         #xfd05ede4
+         #x80105f7
+         #xf9010410
+         #x151612fe
+         #xe10ff06
+         #xa070608
+         #xf8fa0201
+         #xeb041609
+         #x602e6e0
+         #x60100f9
+         #xfeff0412
+         #x1a1a0dfb
+         #xd03fa0e
+         #x10b0c
+         #x102f7
+         #xf8070b04
+         #x8f9e1e4
+         #x400fe00
+         #xfffa0613
+         #x1c1c09fd
+         #x5fb0015
+         #xf706100b
+         #x802f8f3
+         #xfefe000a
+         #x1f0e3ee
+         #x1ff0205
+         #xfcf90910
+         #x1b1e0a00
+         #xfcfa0815
+         #xf80e1106
+         #x6f9f2fc
+         #xf7f50513
+         #xf7f1edf5
+         #x2030800
+         #xf7fd090b
+         #x1d1e0c00
+         #xfb010c13
+         #x40f09ff
+         #xfdf1fa06
+         #xeffa1112
+         #xf4fbf4f2
+         #x60706f6
+         #xf7fe040a
+         #x1f1e0ffe
+         #x1080813
+         #xa0701fd
+         #xf1f30707
+         #xf2081303
+         #xfe00f1eb
+         #xa06fdf1
+         #xfafa0311
+         #x1f1f0dfa
+         #xa070115
+         #x3fe0001
+         #xf2ff10fd
+         #x31003f3
+         #x5f9eaee
+         #x5fff6f9
+         #xfaf80a17
+         #x1f1f0af9
+         #xe000218
+         #xf5fd0608
+         #xfa080cf4
+         #x1306eff1
+         #x1efeefd
+         #xfefaf803
+         #xfafd1312
+         #x1d1f04f9
+         #x8fa0516
+         #xf0040c0d
+         #x10903f4
+         #x15f1e4fb
+         #xf2ed000f
+         #xf9fc0103
+         #xfd061504
+         #x1d1dfffb
+         #xf80a12
+         #xf70c0e0e
+         #x205fefc
+         #x6e3eb03
+         #xe7001516
+         #xfe0406f5
+         #x50d08f8
+         #x1c0ffd02
+         #xf9fd0b0f
+         #x10e0e0b
+         #x103fe04
+         #xf7e2f403
+         #xef181b0e
+         #x807ffe6
+         #xc09fafa
+         #x1303020b
+         #xf903080b
+         #x90d0d06
+         #x2020109
+         #xf2eaf9ff
+         #x31f1305
+         #xe01f2e5
+         #xcfcf309
+         #x7010e11
+         #xfe060407
+         #xb0a0c01
+         #x5030509
+         #xf6eff5fe
+         #x151f0a02
+         #x6f5eef4
+         #x4f3fb16
+         #xfe07150f
+         #x2050101
+         #x8070b04
+         #x9040506
+         #xf8edf402
+         #x18150807
+         #xf9f0f602
+         #xfef50815
+         #xfd141406
+         #x302fffa
+         #x5070c06
+         #xb030004
+         #xf5ecf809
+         #xe10100a
+         #xf1f90407
+         #xe08
+         #x21807fd
+         #xfff7
+         #x50a0e06
+         #x6ff0208
+         #xe9f1040e
+         #xc1511ff
+         #xfc060202
+         #x20908f7
+         #xf0afd01
+         #x3fdfe
+         #x90e07fd
+         #xfd070b
+         #xedfc0a0a
+         #x111805f5
+         #x807f9fb
+         #x6010000
+         #xaffff0a
+         #x4080102
+         #xa07fffe
+         #xfc010a05
+         #xfa020803
+         #x160bf7f6
+         #x6fbf201
+         #xff0a10
+         #x2fd060a
+         #x90c0503
+         #x3ffff04
+         #xfd0405fe
+         #x2020300
+         #xefcf5ff
+         #xfaf3f806
+         #xfe051713
+         #x1020602
+         #xc0e0501
+         #xfdfe0408
+         #xfc00fefc
+         #x2000300
+         #x1f7fd05
+         #xeff60004
+         #x6161d05
+         #x606fcfc
+         #xe0d0503
+         #xfd03080a
+         #xf5fafd00
+         #x5fe
+         #xfdfe0103
+         #xf2fdfdfb
+         #x151d15fa
+         #xafff300
+         #xd0b090a
+         #x207090b
+         #xeffa0003
+         #x303f4
+         #x205fefe
+         #xf8faf5f7
+         #x1d1a0dfa
+         #x7f4f40c
+         #xa0b100f
+         #x6090a0b
+         #xf0ff0206
+         #x502fbec
+         #xc04f6fd
+         #xf5eef1fe
+         #x19140d02
+         #xf3ff14
+         #x911160e
+         #x80b0a09
+         #xf7000307
+         #x2faf4ef
+         #xdfaf401
+         #xe8eafc09
+         #x13161301
+         #xfd060d
+         #xf151109
+         #x90b0806
+         #xfbff0605
+         #xf9f3f3f7
+         #x6f5fa03
+         #xe3f4070a
+         #x151812f8
+         #x6060204
+         #x1411090a
+         #x5090709
+         #xfc0108fe
+         #xf1f1f8fe
+         #xfff8fffd
+         #xeb040905
+         #x1b170aed
+         #xe07f903
+         #x1306090f
+         #xfe070910
+         #xfe0702f4
+         #xf0f3fc02
+         #xfefaf0
+         #xfb0b0301
+         #x1a0e01ed
+         #x1000f510
+         #x9001214
+         #xf70a0e15
+         #x409f6ef
+         #xf3f1ff08
+         #xf2ec
+         #x7080001
+         #x1104fdf7
+         #xcf9fe18
+         #x51a14
+         #xf9111212
+         #x902e7f5
+         #xf2ed0511
+         #xffecef
+         #xa020201
+         #x3000003
+         #x7fb0c17
+         #xff0e1a0e
+         #x4161009
+         #x4f5e602
+         #xe8f01315
+         #xfffcedf0
+         #x60106fe
+         #xfa00040c
+         #x906150a
+         #x5160e08
+         #x10130902
+         #xfbeff20a
+         #xe2fd1d11
+         #x1fcedea
+         #x30403f8
+         #xfd02070f
+         #xf110ffe
+         #xf110209
+         #x110b0603
+         #xf4f50006
+         #xe70b1c04
+         #x8fbe7e3
+         #x305fdfa
+         #x10a0f
+         #x171807fb
+         #x1106fe10
+         #x605070a
+         #xfa0000fc
+         #xf60e0fff
+         #xaf3e1e4
+         #x302fa01
+         #xfe0d0f
+         #x1b1803fe
+         #x6fb0416
+         #xfd070c0d
+         #x303f8f6
+         #xff050602
+         #x4eae1ee
+         #x100ff08
+         #xfcff0f0b
+         #x1d160300
+         #xfdfa0c18
+         #xfd0e0d08
+         #x6fceffc
+         #xfafa060d
+         #xfae9eaf8
+         #x30605
+         #xf7010e08
+         #x1e180700
+         #xfa010f16
+         #x5110900
+         #xfdf3f506
+         #xeffd110e
+         #xf6f2f3f6
+         #x40805fa
+         #xf9020a07
+         #x1f1808fd
+         #x70c18
+         #xb0b01fc
+         #xf2f30307
+         #xef081604
+         #xfdfaf2ed
+         #x809fcf5
+         #xfbff070b
+         #x1f1b08fa
+         #x706081a
+         #x702fdff
+         #xefff0cff
+         #xfe1109f6
+         #x5f7ebec
+         #x903f3fb
+         #xf9fb0d10
+         #x1f1d04fa
+         #xa00081b
+         #xfbff0007
+         #xf80b06f3
+         #xe09f7f0
+         #x2edeaf9
+         #x2fbf503
+         #xf600160e
+         #x1f1b01fa
+         #x6fb0c1b
+         #xf403060e
+         #x10dfcf2
+         #x10f4ecf6
+         #xf6ebf60b
+         #xfcfb0004
+         #xf60a1804
+         #x1f15fefb
+         #xfffb0d19
+         #xfa0a0b0f
+         #x508f6fb
+         #x2e4f000
+         #xebf90b17
+         #xfd0106f8
+         #xff120dfa
+         #x1f0bfeff
+         #xf9fe0b16
+         #x40d0d0b
+         #x303f904
+         #xf0e3fa00
+         #xf2111811
+         #x50800e7
+         #x90dfefb
+         #x19010105
+         #xf9030717
+         #xa0e0e02
+         #x1000008
+         #xe7ecfefe
+         #x61e1505
+         #xa04f0e5
+         #xcfff806
+         #xc000a0d
+         #xff060612
+         #xb0d0bfd
+         #x3020608
+         #xebf2fbfd
+         #x1a1c0bff
+         #x6f9e5f3
+         #x4f3ff12
+         #x109130f
+         #x4050407
+         #x80c09fe
+         #x5040705
+         #xf1f0f600
+         #x1f120802
+         #xfaf1ec06
+         #xfaf50d12
+         #x113120a
+         #x40200fe
+         #x50c0a02
+         #x7040403
+         #xf0ecf908
+         #x170c0d05
+         #xf2f6fa0d
+         #xf7001405
+         #x8170a02
+         #x100fef9
+         #x50d0c02
+         #x7000105
+         #xebee010d
+         #xc111102
+         #xf6020407
+         #xff080df9
+         #x101100ff
+         #x1fcfc
+         #x80f0bff
+         #x100050b
+         #xe7fb0b0a
+         #x13170af2
+         #x505fc05
+         #x408fff9
+         #xefe0004
+         #x401fb09
+         #xe0bfffd
+         #xfe020a0a
+         #xf2030a04
+         #x190ffdf0
+         #x9fff306
+         #x1000207
+         #x3f9070b
+         #x9060008
+         #x901fc02
+         #x70701
+         #xfd0504ff
+         #x12fef7f9
+         #xfff5f60f
+         #xfc03110d
+         #xff010b05
+         #xc090203
+         #xfd0107
+         #x500fc
+         #x202fe
+         #x6f5fd01
+         #xf5f6ff0e
+         #x121904
+         #x30503ff
+         #xd0a0201
+         #xfd00070a
+         #xfdfffbfe
+         #xfd0204fc
+         #xfcfa0403
+         #xf4fd0002
+         #xe1e14f6
+         #x900f800
+         #xe090306
+         #x6090b
+         #xf6fcfe03
+         #xfe0503f5
+         #x10100
+         #xfafef9fc
+         #x1a1d0af5
+         #x6f4f80c
+         #xb0a0a0c
+         #x508090b
+         #xf5fe0006
+         #x206fded
+         #x700fb00
+         #xfaf6f3ff
+         #x1b1606fb
+         #xffef0115
+         #xa0e100d
+         #x809090a
+         #xf8000108
+         #x300f3ea
+         #xbf8fa03
+         #xefeef808
+         #x15140cfe
+         #xfaf70b15
+         #xe141108
+         #xa0a0807
+         #xfbff0409
+         #xfcf7f1f2
+         #x5f2fe05
+         #xe6f4030e
+         #x161910f3
+         #xff03070c
+         #x14120c05
+         #xa08040a
+         #xfb010505
+         #xf3f3f5f9
+         #xfef602ff
+         #xec00080a
+         #x1a1b0ae7
+         #x905ff0b
+         #x13090a09
+         #x6060511
+         #xfd0700fe
+         #xf0f4fcfb
+         #xfdfdfff5
+         #xfb090404
+         #x1b15ffe6
+         #xefcfb13
+         #x9030f11
+         #x1070c17
+         #x409f3f9
+         #xf1f500fe
+         #xf4f0
+         #x7070102
+         #x130af8f2
+         #xaf3031b
+         #xff061613
+         #x20c1113
+         #xa01e7fe
+         #xeef50504
+         #x1fbeef2
+         #x9020202
+         #x802fa01
+         #x3f50f17
+         #xfe101711
+         #xa111208
+         #x9f3e508
+         #xe6f80f0c
+         #x1f5eff3
+         #x4000500
+         #x1020b
+         #x1160c
+         #x718110c
+         #x13120c00
+         #xfdebf10f
+         #xe103190b
+         #x2f3f1ec
+         #x10602fe
+         #x3090b
+         #x8101000
+         #x1112060a
+         #x150d0501
+         #xf5efff0d
+         #xe7101903
+         #x5f3ede4
+         #x407fbff
+         #x2030c09
+         #x121606fc
+         #x1106040e
+         #xd060408
+         #xf6fa0203
+         #xf61610fa
+         #x7eee4e1
+         #x604f706
+         #x40f08
+         #x1912feff
+         #x8fe0814
+         #x305090f
+         #x1f8fd
+         #xe06fc
+         #x2e6e2ec
+         #x4fffd0c
+         #xfc051107
+         #x1c0f0001
+         #xfdfd0f18
+         #x10a0c0b
+         #x6fdf000
+         #xff030504
+         #xf9e3e9f6
+         #x100050a
+         #xf9091004
+         #x1d0e0500
+         #xf802121a
+         #x80e0901
+         #xf2f208
+         #xf3000d0c
+         #xf3e9f4f7
+         #x3070700
+         #xfa090c03
+         #x1d1206fb
+         #xfe080f1a
+         #xf0c02fb
+         #xf4f1ff0b
+         #xef0a1404
+         #xf8f3f5ef
+         #x90bfef9
+         #xfd050905
+         #x1f1403fa
+         #x5070e1c
+         #xc03fcff
+         #xf0fc0804
+         #xfb130ef7
+         #xf5eeea
+         #xc04f3fd
+         #xfb020c0a
+         #x1f1601fb
+         #x703101e
+         #x2fdfb06
+         #xf70903fa
+         #xb0ffeee
+         #xeee9f3
+         #x7faf406
+         #xf405140c
+         #x1f1400fb
+         #x2ff111d
+         #xfbfe030e
+         #x30df5f7
+         #xdfcf2f1
+         #xf6e8f206
+         #xf70007
+         #xf50f1605
+         #x1f0ffff9
+         #xfc00111c
+         #xfe030a0f
+         #xa06effe
+         #xffecf3fa
+         #xedf00313
+         #xfcfe08fc
+         #xfe170efe
+         #x1e08fef8
+         #xf9020e1c
+         #x6090e09
+         #x8fff306
+         #xeae9fcff
+         #xf1041611
+         #x10701ec
+         #xa1300fb
+         #x180200fe
+         #xfb040b1e
+         #xb0c0d00
+         #x3fefd09
+         #xe1f200fd
+         #x5161802
+         #x906efe9
+         #xe03fb04
+         #xd000607
+         #xff040b1c
+         #xc0e09fb
+         #x1000509
+         #xe5f8fcfc
+         #x19180ff8
+         #x9fce1f7
+         #x5f7010d
+         #x4070d0d
+         #x2030b12
+         #xb0e05fc
+         #x3040608
+         #xeef6f700
+         #x1f1008f8
+         #xffefe50c
+         #xf8f80f0d
+         #x412120b
+         #x4010703
+         #xa0d0300
+         #x6060406
+         #xeeeff904
+         #x170b0bfd
+         #xf5eff615
+         #xf2041602
+         #xd160d02
+         #x10000fe
+         #x90e0702
+         #x6040206
+         #xe8ef0009
+         #xf0f10fd
+         #xf6fa0110
+         #xf80f10f6
+         #x130f04fe
+         #xfb00
+         #xb1107ff
+         #x3000309
+         #xe6f8080c
+         #xf160ef6
+         #x50007
+         #x10e02f4
+         #x12030001
+         #x201fa06
+         #xe1102fb
+         #x30710
+         #xf0040a05
+         #x1914ffe9
+         #x8fdfb0d
+         #x703fa02
+         #x3fc0404
+         #x5fe000c
+         #x1202f902
+         #x2080808
+         #xfc070500
+         #x1506f7ef
+         #x2f4fa14
+         #xfe00070c
+         #xfc000b06
+         #x8020306
+         #x6fbff08
+         #x50701ff
+         #x401ff
+         #x6fafafa
+         #xf8f30315
+         #xfd0d1205
+         #x808ff
+         #xb050201
+         #xfefe050a
+         #x301fcfd
+         #xff0201ff
+         #xfcfa0100
+         #xf6fa080b
+         #xa1b0ffa
+         #x60500fd
+         #xc050203
+         #xfe03080b
+         #xfdfdfc01
+         #xfe0601fa
+         #xfb0004fe
+         #xfcff01ff
+         #x191d04f4
+         #x5f8fb06
+         #xb06050a
+         #x307090c
+         #xfafc0005
+         #x208fcf2
+         #x20100fe
+         #xfdfaf8ff
+         #x1d14fffa
+         #xfcf10313
+         #xb0a0c0c
+         #x707090b
+         #xfbfe0207
+         #x602f2ef
+         #x5fafe01
+         #xf7f3f807
+         #x190f03fd
+         #xf4f70d17
+         #xd0f0f06
+         #x8080809
+         #xfcff0309
+         #x1f9ecf2
+         #x1f30104
+         #xedf3010e
+         #x151509f4
+         #xf8010e13
+         #x12120d00
+         #xa07050a
+         #xfc00050a
+         #xf9f3f0f6
+         #xfaf80500
+         #xeefd0a0b
+         #x1a1b04e7
+         #x203060f
+         #x120d0903
+         #xa030412
+         #xfd040105
+         #xf2f5f7f7
+         #xf8ff02f7
+         #xfa050a04
+         #x1e17f9e5
+         #xbfc0115
+         #xb070b0b
+         #x6020a17
+         #x406f801
+         #xf1f8fcf8
+         #xfe00f9f1
+         #x5050501
+         #x1a0cf0f0
+         #x6f2091b
+         #x2091013
+         #x4061512
+         #xcfeee03
+         #xeffafffe
+         #x1faf2f2
+         #x7010402
+         #x1002f300
+         #xfdf61419
+         #x111411
+         #x90e1506
+         #xaf0ec0a
+         #xeafe0607
+         #x1f2f2f2
+         #x3020403
+         #x7fffd09
+         #xfa02170e
+         #x616120b
+         #x10120ffd
+         #xfee5f611
+         #xe6050f0c
+         #xfef0f5eb
+         #x2050202
+         #x4020809
+         #x111002
+         #x11140c07
+         #x140e05fe
+         #xf2ea0310
+         #xed121205
+         #xfef2f1e2
+         #x506fc03
+         #x4060c04
+         #xd1504ff
+         #x12090808
+         #xf070208
+         #xf1f60709
+         #xfc190cfc
+         #xf0e7e0
+         #x901fa08
+         #x2090d04
+         #x1710ff00
+         #x9010b0f
+         #x704070f
+         #xfbfeff01
+         #x91302f8
+         #xfde8e1e8
+         #x7fdff0d
+         #xff0c0d06
+         #x19070002
+         #xfd000f17
+         #x3070d0c
+         #x3faf503
+         #x6080000
+         #xf4e2e7f5
+         #x2fd080b
+         #xfe0e0d05
+         #x180704ff
+         #xf905131b
+         #x80b0c02
+         #xf1f50a
+         #xfc030608
+         #xeee6f2f8
+         #x1030b02
+         #xf0a03
+         #x180b04fc
+         #xfd09141d
+         #xe0b04fa
+         #xf6eeff0e
+         #xf4090f07
+         #xeff0f7f0
+         #x80903fa
+         #x10b0702
+         #x1a0f00fa
+         #x30a121e
+         #xe04fcfb
+         #xf0f70709
+         #xfd140efa
+         #xf9f5f0e8
+         #xd04f9fc
+         #x60808
+         #x1d0ffffc
+         #x507141e
+         #x6fcfb04
+         #xf6040400
+         #xb1200ef
+         #xfdf1e8ef
+         #xbfaf904
+         #xfa090e0c
+         #x1f0efffb
+         #x205161f
+         #xfff9010b
+         #x409f9fb
+         #xf03f3ef
+         #xf6e9ed00
+         #xf40308
+         #xf811120a
+         #x1e0bfff7
+         #xfd06141f
+         #xfdfe0b0b
+         #xd00f0ff
+         #x1f4f1f9
+         #xeceb000e
+         #xfafb0bfe
+         #x1170d03
+         #x1b06fdf3
+         #xfb07131f
+         #x2051005
+         #xaf7f305
+         #xedeff700
+         #xedfb110b
+         #xfe0604f1
+         #xe1403ff
+         #x1703fbf7
+         #xfd06121f
+         #x80b0ffe
+         #x2f5fe0a
+         #xe2f6fd01
+         #xfe0e18fd
+         #x808f2ec
+         #x1308fd01
+         #xd02ff01
+         #x4131f
+         #xa0d08fa
+         #xfb040b
+         #xe8fcfbff
+         #x11170fef
+         #xcfbe2f9
+         #x9fc010a
+         #x507070b
+         #x1041516
+         #xc0d02fc
+         #x101060b
+         #xf1faf700
+         #x1a1305ed
+         #x4ece50d
+         #xf9fb0c0d
+         #x60e0f0a
+         #x41009
+         #xd0c0000
+         #x505040b
+         #xf3f3f803
+         #x150d04f4
+         #xf7e7f819
+         #xf1091304
+         #xe140f00
+         #x20502
+         #xd0a0202
+         #x604020b
+         #xebf1fe07
+         #xe0e09f6
+         #xf3f10716
+         #xf9140df9
+         #x141107f8
+         #xff00fe05
+         #xf0d0400
+         #x502020d
+         #xe6f70508
+         #xd150af0
+         #xfbfd080d
+         #x51300f5
+         #x130601fa
+         #xfefc0d
+         #x120e00fe
+         #x1010511
+         #xec010a08
+         #x151803ea
+         #x500fd0a
+         #x907f8fc
+         #x9fd0102
+         #x3fefd0f
+         #x1409faff
+         #x2050b10
+         #xfc070702
+         #x180df2e9
+         #x1f60115
+         #x4fd000b
+         #xfc020604
+         #x2fe0705
+         #xcf9fd07
+         #x6080703
+         #x2050200
+         #xc00f3f4
+         #xf8f10a18
+         #xfe050c0b
+         #xfd0a08ff
+         #x4010500
+         #xfffa050a
+         #x70300fd
+         #x20002
+         #xfefdfcfc
+         #xf3f9100e
+         #x7140cff
+         #x50a01fa
+         #x7030200
+         #xfc01090b
+         #x1fdfdff
+         #x30000
+         #xfb0100fd
+         #xf8000b01
+         #x181902f8
+         #x501fc01
+         #x9030306
+         #x6090b
+         #xfcfb0004
+         #x406fcfa
+         #x400fc
+         #xfeff00fd
+         #x1f10fbfb
+         #xfcf8000f
+         #x9060909
+         #x507090c
+         #xfbfd0306
+         #x902f2f5
+         #x2fffe00
+         #xfaf7fd03
+         #x1b09feff
+         #xf2fa0c18
+         #xb0b0e03
+         #x607090b
+         #xfcff0407
+         #x8f9ecf6
+         #xfefa0103
+         #xf2f4030a
+         #x160c03fa
+         #xf3041217
+         #xf0f0cfb
+         #x706080c
+         #xfc000609
+         #xfff1edf7
+         #xf6fb0402
+         #xeffa0c08
+         #x181601ed
+         #xfd080e13
+         #x110f08fb
+         #x8030710
+         #xfd020707
+         #xf6f1f2f7
+         #xf60102fb
+         #xf7020e00
+         #x1f15f4e8
+         #x5000916
+         #xd0b0605
+         #x5010c13
+         #x1030003
+         #xf3f6f6f7
+         #xfc04fcf4
+         #x50afe
+         #x1f0aebf1
+         #x3f80b1b
+         #x50a0a0e
+         #x105150f
+         #x8fdf902
+         #xf3faf7fd
+         #x1fef5f1
+         #x3030600
+         #x18feed00
+         #xf8fa141b
+         #x40f120f
+         #x30e1704
+         #x6eff807
+         #xf1fcfd08
+         #xfff4f4f1
+         #x1030503
+         #xdfafa07
+         #xf4071813
+         #xa141306
+         #x9130ffc
+         #xfbe6fe0e
+         #xf001060f
+         #xfaf2f6ea
+         #x1050404
+         #x7fe0505
+         #xfb141109
+         #x10131000
+         #xf1105fe
+         #xede80810
+         #xf60c0d0a
+         #xf8f5f1e2
+         #x6060104
+         #x5050902
+         #xa160603
+         #x110d0b01
+         #xe0a0006
+         #xeaf50c0a
+         #x31509fd
+         #xf8f5e7e2
+         #x9000004
+         #x40b0803
+         #x140d0003
+         #xa060a09
+         #x803060f
+         #xf3fe0604
+         #xf1401f6
+         #xf8ede1ea
+         #x6fa0509
+         #x40d0807
+         #x16040103
+         #x1050d13
+         #x3040d0d
+         #xfffcfc02
+         #x1008fcfc
+         #xf2e4e2f6
+         #xfb0d08
+         #x40f0908
+         #x12020400
+         #xfb08121a
+         #x40a0e01
+         #xfef2fb08
+         #x4020105
+         #xeae5effc
+         #xff021000
+         #x70f0805
+         #x100702fd
+         #xff0c151b
+         #xa0c06f9
+         #xf5ee010d
+         #xfd060907
+         #xeaeff6f5
+         #x4080af8
+         #xa0d0503
+         #x130bfffc
+         #x40d171b
+         #xc06fefa
+         #xedf40a0b
+         #x100cfe
+         #xf1f7f1eb
+         #xb05fff7
+         #x6080406
+         #x180cfdfe
+         #x60c161c
+         #x7fdfb00
+         #xf3000902
+         #xd1202f1
+         #xf8f4e7ee
+         #x9fcfefe
+         #x108090d
+         #x1b08fffd
+         #x30b181e
+         #xfef90005
+         #x500fc
+         #x1308f5f1
+         #xf6ebe8fe
+         #xf60503
+         #xe0e0f
+         #x1b08fff8
+         #xc171f
+         #xf9fc0a06
+         #xafff7fc
+         #x8f9eefb
+         #xede8f90b
+         #xf7fc0dff
+         #x7140d08
+         #x1707fbf2
+         #xc171f
+         #xfb040f00
+         #x7f2f900
+         #xf5f1f406
+         #xeaf60c09
+         #xfb0607f2
+         #x13140600
+         #x1404f6f6
+         #x10a191f
+         #xb0efb
+         #xfff00005
+         #xeaf4fa09
+         #xf50913f9
+         #x408f7ed
+         #x17090000
+         #xe02f701
+         #x81b1e
+         #x50e09fa
+         #xf9f70609
+         #xeefbfc04
+         #x8170ae9
+         #xcfde8f6
+         #xeff0007
+         #x704000d
+         #x71e18
+         #xa0d01fb
+         #xfcff070c
+         #xf7faf901
+         #x1417fee7
+         #x5eaea08
+         #xfefe0a0e
+         #x70a0a0b
+         #xff09180c
+         #xd09ff00
+         #x103060d
+         #xf9f4f802
+         #x1411faee
+         #xf7e3fc16
+         #xf607100b
+         #xd100e00
+         #xff090c05
+         #xe060001
+         #x503050e
+         #xf1f1fd05
+         #xe0efff4
+         #xeceb0e16
+         #xfd130cff
+         #x141207f5
+         #xff040209
+         #xf070200
+         #x5010510
+         #xeaf60308
+         #xd1302ee
+         #xf2fa100e
+         #xb1301f7
+         #x140cfef5
+         #xffff0010
+         #x120900fe
+         #x2000715
+         #xedff0707
+         #x1317fee7
+         #xfe00080b
+         #x1108f8fc
+         #xc03fdfe
+         #xfd0412
+         #x1504fc00
+         #x1030a14
+         #xf8050804
+         #x1a14f5e7
+         #x3fa0010
+         #xafefa07
+         #x305
+         #x1fd060c
+         #x11fcfa04
+         #x4070f06
+         #x2050402
+         #x1500ebf3
+         #xf7f70d19
+         #xff090a
+         #xfe080503
+         #x208fe
+         #xfdf90507
+         #x70606fb
+         #x1010205
+         #x5fbf4fc
+         #xeffc1612
+         #x20b0d01
+         #x50e01fa
+         #x20303fc
+         #xf8000a08
+         #x300fffd
+         #x10205
+         #xff00fcfd
+         #xf4051104
+         #x141204f8
+         #x906f9ff
+         #x4020102
+         #xfe060909
+         #xfefd0002
+         #x303ff01
+         #x3fdfc
+         #xfc0605fd
+         #x1d0dfcf9
+         #x1fdfd0d
+         #x6030606
+         #x407090b
+         #xfafd0205
+         #xa00f8fc
+         #x302fbff
+         #xfdfefe00
+         #x1c03fcff
+         #xf7fc0819
+         #x7070c02
+         #x5060a0b
+         #xfb000405
+         #xaf7f1fa
+         #xfefe05
+         #xf6f80305
+         #x140401fe
+         #xf404121a
+         #xb0d0bf9
+         #x5060a0c
+         #xfc000606
+         #x2eff0fa
+         #xf9000306
+         #xf0fb0b03
+         #x130c00f4
+         #xfc0b1317
+         #xf0f04f5
+         #x5050a0e
+         #xfc020805
+         #xf8edf3f9
+         #xf7040300
+         #xf4040ffc
+         #x1d0ff5ec
+         #x4070e17
+         #x100b00fe
+         #x3030d11
+         #x40701
+         #xf4f2f3f8
+         #xfd05fdf8
+         #xfd080af9
+         #x1f04eaf1
+         #x100101c
+         #xb090508
+         #xfe07140d
+         #x30002ff
+         #xf5f6f3fd
+         #x300f7f4
+         #x10704fd
+         #x1bf8ecfd
+         #xf700141f
+         #x70b0f09
+         #xff111605
+         #x1f5fe01
+         #xf7f7f808
+         #xf8f4f2
+         #x1060302
+         #xff3f803
+         #xf30a191c
+         #xa101400
+         #x5180cfe
+         #xf5ed0109
+         #xf7fb010f
+         #xf9f5f4ee
+         #x1060503
+         #x5fb0402
+         #xfb151312
+         #x111310f9
+         #xd150300
+         #xe9ee090e
+         #xfa030b09
+         #xf5f9efe7
+         #x4050500
+         #x3040700
+         #x8150b0b
+         #x12100afb
+         #x100bff08
+         #xe5f80e0c
+         #x40d0cfb
+         #xf7fae5e6
+         #x7020400
+         #x50a0503
+         #x140c0507
+         #xd0b0504
+         #xa04030f
+         #xee000a05
+         #x110f03f2
+         #xf8f0e0ef
+         #x4fe0801
+         #x80b0509
+         #x12020405
+         #x5080810
+         #x3040b0c
+         #xf9000201
+         #x1308fcf5
+         #xf3e5e2fc
+         #xfeff0e02
+         #xb0c070b
+         #xd010402
+         #x10a0f18
+         #x20a0d02
+         #xfcf8ff05
+         #xc00fd00
+         #xeae2ec03
+         #xfa0412fd
+         #xd0c0905
+         #xa060200
+         #x20d1517
+         #x70e06fa
+         #xf3f2030a
+         #x2010605
+         #xe7ecf5fe
+         #x10c0cf4
+         #xe0b0601
+         #xd09fe00
+         #x6101816
+         #xb09fef9
+         #xebf60b0a
+         #x10a0afd
+         #xeef6f2f4
+         #x90a02f1
+         #xc080405
+         #x1207fc02
+         #x8101817
+         #x700fafe
+         #xee000d03
+         #xc1004f1
+         #xf7f7e8f3
+         #x900fef7
+         #x606060d
+         #x1505fe01
+         #x810181b
+         #xfef9fe02
+         #xfb0505fb
+         #x1409f7f0
+         #xf8ebe6ff
+         #xfffa03fe
+         #x5090c10
+         #x1604fefc
+         #x610191f
+         #xf6fd0602
+         #x400fef7
+         #xefbeffb
+         #xf0e6f40b
+         #xf7fe0bfd
+         #xa0f100a
+         #x1406faf7
+         #x40f1b1f
+         #xf6050bff
+         #x3f6fcfa
+         #xfef0f309
+         #xe9f0070c
+         #xf90909f4
+         #x13110aff
+         #x1204f2f9
+         #x50d1d1f
+         #xfb0e08fb
+         #xf8f100ff
+         #xf1f1fc0c
+         #xf0050dfb
+         #x40cfbec
+         #x170b03fc
+         #xe00f105
+         #x40d1f1c
+         #x21004fc
+         #xf2f70504
+         #xf2f60007
+         #x1605ec
+         #xb00eef1
+         #x10020103
+         #xafdfb10
+         #x10f1f16
+         #x80d00fd
+         #xf5ff0609
+         #xfaf9fe00
+         #x1219f6e8
+         #x5eeee01
+         #x2ff070e
+         #x8010811
+         #x121d0f
+         #xc09fefe
+         #xfd03070c
+         #xfcf5fc00
+         #x150ff0f0
+         #xf5e5fe0f
+         #xfa060f0e
+         #xc0b0e03
+         #x1111009
+         #xd0400fe
+         #x203090d
+         #xf4f1fe02
+         #x1109f5f6
+         #xe8ec0f13
+         #x100e04
+         #x121106f7
+         #x20b060a
+         #xb0401fd
+         #x301090e
+         #xecf40207
+         #xe0bfbf3
+         #xe9fc150d
+         #xf1204f7
+         #x150efaf5
+         #x30411
+         #xd0600fc
+         #x1000b13
+         #xedfc0607
+         #x1412f8e9
+         #xf6040c0a
+         #x1609fbf7
+         #xf06f600
+         #xff000913
+         #x1003fefd
+         #x20f14
+         #xf6020705
+         #x1a0fefe6
+         #xfe00060f
+         #x10fdfa00
+         #x501fd09
+         #xfe000d0d
+         #xefcfc00
+         #x306110c
+         #x60602
+         #x1905eaee
+         #xfbf70816
+         #x3fa030b
+         #xfd040507
+         #xff010b03
+         #x3f70106
+         #x60a0dfa
+         #x40405
+         #xdf5effc
+         #xf1001518
+         #xfe060eff
+         #x5090300
+         #x502fd
+         #xf5000902
+         #x50501f9
+         #xff010508
+         #x2f8f9fe
+         #xf20b150b
+         #xa0f09f4
+         #xc09fafd
+         #x204ff00
+         #xfb070904
+         #xfe00
+         #x20405
+         #x2fffcfd
+         #xfd0d0800
+         #x180cfff4
+         #x8fef90b
+         #x3030206
+         #x3080807
+         #xfcff0004
+         #x600ffff
+         #x400fa00
+         #x106ffff
+         #x1603fcfa
+         #xfefa051a
+         #x4060703
+         #x6060909
+         #xfc000304
+         #x8f9f9fb
+         #x3fefc05
+         #xfcfe0003
+         #xe0000fe
+         #xf701131d
+         #x70b08f9
+         #x4060b09
+         #xfd010303
+         #xf1f6fb
+         #xfefe020a
+         #xf5fe0801
+         #xd0601f8
+         #xfd0b1618
+         #xd0d00f3
+         #x3070c0b
+         #xfd020503
+         #xf6eef7fa
+         #xfc030607
+         #xf5040bfb
+         #x1409faf1
+         #x40d1316
+         #x100afbf9
+         #x3070d0e
+         #xfe050700
+         #xf1f0f6f7
+         #x602fe
+         #xfd0d06f6
+         #x1d01eef0
+         #x406121c
+         #xd05fe03
+         #x9110f
+         #x10403fc
+         #xf3f2f3fc
+         #x400fbf7
+         #x30c00fc
+         #x19f5edf8
+         #xfc06181f
+         #xa070a05
+         #xfe111209
+         #xfeffff
+         #xf6f1f603
+         #x3faf6f5
+         #x408ff02
+         #xcf0f7ff
+         #xf60b1b1f
+         #xa0d11fd
+         #x5180c03
+         #xf7f7ff08
+         #xf7f30009
+         #xfbf7f4f3
+         #x4070403
+         #xf70200
+         #xfd141b1a
+         #xe120df4
+         #x11150003
+         #xeaf6050f
+         #xf9fd0c04
+         #xf7f9efef
+         #x50607ff
+         #xff0204ff
+         #xa14120f
+         #x111204f7
+         #x150afd0a
+         #xe6fd0b0f
+         #x80ff6
+         #xf9f8e6ee
+         #x60507fb
+         #x3080302
+         #x120c0c09
+         #x100dff02
+         #x1002000f
+         #xed050a08
+         #xa0e06ea
+         #xfcefe0f5
+         #x30206fc
+         #x9090309
+         #x11040807
+         #xb09020e
+         #x702090e
+         #xf8050302
+         #x1109fced
+         #xf7e3e401
+         #xfd030aff
+         #xd07070a
+         #x9030606
+         #x6090c14
+         #x3090b04
+         #xfcff0003
+         #xc00faf8
+         #xede0ee0a
+         #xfc0a0cfc
+         #xe080a05
+         #x6050306
+         #x60c1414
+         #x70e05fe
+         #xf4f80109
+         #x2fe02ff
+         #xe6e6f907
+         #xf09f3
+         #xf0a08fe
+         #x906ff06
+         #x9101810
+         #xc0afcfc
+         #xecfa090a
+         #x509f9
+         #xecf3f7fd
+         #x90f00ed
+         #xd080401
+         #xe04fe08
+         #xb121711
+         #xa02f8ff
+         #xee020c05
+         #x70d05ef
+         #xf5f4edf9
+         #xb07fbf1
+         #xa050509
+         #x10000008
+         #xb131616
+         #x1fbfb03
+         #xf80809fb
+         #x120bf9eb
+         #xf9eae901
+         #x200fefa
+         #x6060b0f
+         #x10010002
+         #xb12171b
+         #xf8fc0103
+         #x205fff5
+         #xefdf0f6
+         #xf1e2f40d
+         #xf90104fd
+         #x90c1108
+         #xf03fbfd
+         #xa111c1c
+         #xf6040501
+         #x1fdfaf7
+         #x1f1f304
+         #xe9ea040f
+         #xfa0a05f6
+         #x10100ffd
+         #xf02f4ff
+         #x8111f1c
+         #xfb0b0300
+         #xf8f7fbfd
+         #xf4ee0009
+         #xebff0c03
+         #x50ffdec
+         #x140e05f7
+         #xefbf108
+         #x6111f1a
+         #x40eff00
+         #xf0fbfe03
+         #xf1f50602
+         #xfc1002f3
+         #xd04f1ed
+         #xe070100
+         #xaf5fb13
+         #x4141f18
+         #xb0cfd00
+         #xf2000108
+         #xf6fa05f9
+         #xe12f4ed
+         #x8f4effa
+         #x502040c
+         #x6f70813
+         #x51a1e12
+         #xe06fdfe
+         #xfb04050c
+         #xfaf800f8
+         #x1707ebf4
+         #xf6e9fa09
+         #xfe050e11
+         #x7030e08
+         #x81a150c
+         #xd04fefc
+         #x4090b
+         #xf4f5fffd
+         #x14fef1fa
+         #xe7f10b11
+         #x10d1103
+         #xe0e07fb
+         #x9110a0c
+         #xa03fffb
+         #x40c0b
+         #xecf60202
+         #x1000f9f7
+         #xe6001210
+         #xe110af4
+         #x140efaf9
+         #x6080811
+         #x904fffb
+         #x30e0d
+         #xebfc0604
+         #x1206f7ed
+         #xf30a0d0d
+         #x160affee
+         #x1204f303
+         #x2040c14
+         #xb03fcfc
+         #xff05120f
+         #xf4010803
+         #x1907eee8
+         #xfd070610
+         #x1000fbf7
+         #xafdfa0f
+         #x40f10
+         #x9fefbfd
+         #x8150a
+         #xfd040702
+         #x1affe8ee
+         #xfc000818
+         #x3fa0001
+         #x3ff030f
+         #x60d06
+         #x1faff00
+         #x50a12ff
+         #x50503
+         #x13f6ebf9
+         #xf4ff111a
+         #xfc000b03
+         #x1070604
+         #x506ff
+         #xf6fd0602
+         #x70c03f7
+         #xff040606
+         #x2f0f8fd
+         #xf60c1714
+         #x10f09f1
+         #xb0600fe
+         #x304fd02
+         #xfa070600
+         #x405fcff
+         #xff040806
+         #xfff8fcfc
+         #x130e08
+         #xf0f00ed
+         #xcfefa05
+         #x302fe08
+         #x3090502
+         #xff00ff04
+         #x2040400
+         #x2fdfbfe
+         #x70b0103
+         #x1206faf6
+         #x2f60316
+         #x4030308
+         #x7070705
+         #xff010104
+         #x3fefffc
+         #x3fcfd05
+         #x301ff04
+         #xa00fefd
+         #xfbfb121c
+         #x6080400
+         #x4060907
+         #x20202
+         #xfdf6fbfa
+         #xfb030b
+         #xfaff0404
+         #x50301fb
+         #xfc081b18
+         #xb0afff7
+         #x2080b08
+         #xff020202
+         #xf3f3fafa
+         #xfe000908
+         #xf90506fe
+         #xc07fdf4
+         #x40f1813
+         #xe07f8f8
+         #x30a0c0b
+         #xff030302
+         #xedf3f9f9
+         #x40900
+         #xff0b01f9
+         #x1402f5f1
+         #x70e1418
+         #xe01f900
+         #x30c0e0e
+         #x1060200
+         #xeff3f5f9
+         #x50201f8
+         #x70cfafc
+         #x13f6eff4
+         #x109181f
+         #x8010303
+         #x3100f0e
+         #x203fb01
+         #xf2f0f5ff
+         #x4fdfaf6
+         #xa08fb03
+         #x6f0f5fc
+         #xfc0e1d1f
+         #x7080bfc
+         #x9140b0a
+         #xfcfdf90a
+         #xf2f1ff03
+         #xfef9f7f6
+         #x8050104
+         #xfbf6feff
+         #x141f1a
+         #xa0f08f5
+         #x14110207
+         #xf3fb0013
+         #xf2f90afe
+         #xf9f8f4f5
+         #x60606ff
+         #xf90101ff
+         #xb151d10
+         #x1012fef6
+         #x1a08fe0b
+         #xeeff0814
+         #xf8070df0
+         #xfbf6edf3
+         #x70705fb
+         #x2060002
+         #x12111409
+         #x120df902
+         #x14010110
+         #xf2050a0d
+         #x10f05e5
+         #xfdece7f8
+         #x50702fc
+         #x9050107
+         #x10090c07
+         #xf06fd0e
+         #xa00080f
+         #xfb080605
+         #xb0cf8e6
+         #xf9e1e902
+         #x10703ff
+         #xc040708
+         #x8050808
+         #x9040712
+         #x4050b09
+         #xff020004
+         #xb02f4f1
+         #xeee0f50c
+         #xb06fe
+         #xc070b01
+         #x407060a
+         #x709120f
+         #x70b0503
+         #xfafc0009
+         #x2fefcf9
+         #xe5e3ff0c
+         #x41104f5
+         #xb0a08fc
+         #x706030c
+         #x80f150c
+         #xd0afe00
+         #xf1fb050d
+         #xfd0305f6
+         #xe7ef0003
+         #xe11feec
+         #xc0a03fe
+         #xb01020c
+         #xb12140c
+         #xe00f903
+         #xf1020a08
+         #x30c03ec
+         #xf2f3f7fe
+         #xf0af6ee
+         #xa060306
+         #xbff040d
+         #xe131311
+         #x5fafa05
+         #xf90908ff
+         #xc0cf9e8
+         #xf8ebf101
+         #x803f6f7
+         #x705090c
+         #xa000509
+         #xf131516
+         #xfcfaff07
+         #x20900f7
+         #x1000eff0
+         #xf2e1f70d
+         #x1fefe
+         #x60a1108
+         #xa020003
+         #xd121a18
+         #xf8000105
+         #x301f6f8
+         #x4f3f2fe
+         #xe7e70511
+         #x902f8
+         #xb1210fd
+         #xc00f902
+         #xb121f17
+         #xfe060005
+         #xfdfbf4ff
+         #xf6f0fe03
+         #xe7f90d09
+         #x70dfdee
+         #x101206f6
+         #xdf8f609
+         #x8151f17
+         #x707fe05
+         #xf5fbf706
+         #xeef708fe
+         #xf60b06fa
+         #x1008f2ea
+         #x100bfefe
+         #x8effe13
+         #x8191f18
+         #xe05fe04
+         #xf6fffc0c
+         #xf10007f3
+         #xa0bf7f2
+         #xaf8edf5
+         #x804010c
+         #x1f20b13
+         #xa1d1e14
+         #x1003fe00
+         #xfb01000d
+         #xf50000ef
+         #x1400eff5
+         #xfbeff406
+         #x1040b0f
+         #xff1009
+         #xe1e180e
+         #xf01fdfd
+         #x3060c
+         #xf4fbfcf6
+         #x12f5f2fb
+         #xeaf30312
+         #x20c1203
+         #x70b09fe
+         #x11170f0c
+         #xa01fcfc
+         #x1040a0a
+         #xeefafffe
+         #xbf6fbf9
+         #xe9010d14
+         #xc120cf0
+         #x100dfcfc
+         #xd0d0b0f
+         #x802fbff
+         #x70c0a
+         #xecfd0300
+         #xcfdfaef
+         #xf50c0c11
+         #x131000e7
+         #x1203f605
+         #x7070e14
+         #x902faff
+         #x80f0c
+         #xf1020600
+         #x1200f1e9
+         #xb0712
+         #x1004f8ed
+         #xcf7fc11
+         #x2071114
+         #x8fef9fe
+         #x10b1307
+         #xfa0506ff
+         #x15f9e9ed
+         #x40819
+         #x3fdfcfa
+         #x3f80713
+         #x30a0e0d
+         #x1fbfbff
+         #x40e12fe
+         #xfe050400
+         #x11f0ebf6
+         #xf901101f
+         #xfb0005fd
+         #x1000c0a
+         #x3090803
+         #xf9fd0000
+         #x70e08f7
+         #xff050505
+         #x6edf4fd
+         #xf508171a
+         #xfd0b0bf5
+         #x70704ff
+         #x3050000
+         #xf7050500
+         #x908faff
+         #x70805
+         #xf9f5fbfa
+         #x212170d
+         #xb0ffbed
+         #xa00fe00
+         #x400fd09
+         #x4070201
+         #x401fc06
+         #x2080702
+         #xfdfbfbfa
+         #xc100a06
+         #x1108f4f4
+         #x3f5010e
+         #x300010d
+         #x9060302
+         #x1000105
+         #x30501fd
+         #xfafc01
+         #xa040106
+         #xa00f7ff
+         #xfaf91016
+         #x5030507
+         #x5050605
+         #x1010202
+         #xfffefcfc
+         #xfff90307
+         #x1ff0306
+         #x401fe00
+         #xf9061b13
+         #x80601fd
+         #x2080906
+         #x2010001
+         #xf4f9fafd
+         #xfcfe0d06
+         #xfc020501
+         #x605fef9
+         #x1131a0e
+         #xd04f9fa
+         #x40b0a0a
+         #x10003
+         #xeff8f9fc
+         #xff040dfd
+         #x108fffd
+         #xe04f7f3
+         #x9131511
+         #xbfff8ff
+         #x70c0b0d
+         #x1030004
+         #xf0f8f7fb
+         #x30706f5
+         #x908f9ff
+         #xdfaf2f6
+         #x80f171a
+         #x6fcfe03
+         #x80d0d0f
+         #x403fb05
+         #xf2f3f5fc
+         #x402fef4
+         #xd03f904
+         #x3f3f3fd
+         #x20e1e1e
+         #x30307ff
+         #xc100d0d
+         #x2fff80d
+         #xeff1faff
+         #xfffdfaf5
+         #xa010005
+         #xf8f6f901
+         #x2161f17
+         #x70d03f8
+         #x150d0709
+         #xfcfafe16
+         #xedf904fc
+         #xfaf9f8f5
+         #x8030600
+         #xf7fefd02
+         #xb1a1f0d
+         #xd10faf8
+         #x1905020a
+         #xf6fb0817
+         #xf00607f1
+         #xfbf6f4f3
+         #x70704fb
+         #x2fe04
+         #x11181905
+         #x120af402
+         #x13fe050d
+         #xf7010d0f
+         #xfd0fffe7
+         #xfcedf0f5
+         #x708fffc
+         #x8020007
+         #xf131005
+         #x1002fa0b
+         #x8fe0a0f
+         #xfe060a07
+         #x90df2e7
+         #xf8e3f0fe
+         #x607fe00
+         #xa010506
+         #x90d0b09
+         #xa00050e
+         #x2040c0d
+         #x2040304
+         #xc02ecf1
+         #xece0f908
+         #x6090100
+         #x8050901
+         #x50a090c
+         #x6040f0b
+         #x5080808
+         #xfffe0009
+         #x4fcf3f9
+         #xe2e6030b
+         #x90d03f7
+         #x80b06fc
+         #x607080d
+         #x60d1208
+         #xc070105
+         #xf8fc050e
+         #xfe00fdf7
+         #xe2f10705
+         #xf0efeed
+         #xa0c01fd
+         #x903080e
+         #xb130f08
+         #xd00fd05
+         #xf4000a0b
+         #x9ffee
+         #xecf700ff
+         #x140af4eb
+         #xb06ff06
+         #x8000a0e
+         #xf130e0d
+         #x7f9fd07
+         #xfb070902
+         #xa0bf5e8
+         #xf4f0f900
+         #xe00f2f4
+         #x704050d
+         #x6010a0c
+         #x10131211
+         #xfdf70009
+         #x30902fa
+         #xf02ecee
+         #xf0e7fb08
+         #x5fff8fc
+         #x5090d09
+         #x5030707
+         #xf121711
+         #xf9fb020b
+         #x704f7fa
+         #x7f4edfb
+         #xe5e80611
+         #x20401f9
+         #x7120fff
+         #x9010004
+         #xc141c12
+         #xfe00020a
+         #x2fcf200
+         #xf8f1f900
+         #xe2f8100b
+         #x90a00ee
+         #xf1405fa
+         #xaf9fe08
+         #xb181d14
+         #x6010108
+         #xfcf8f508
+         #xeef904fd
+         #xef070cfe
+         #x1108f5e8
+         #x120dfb00
+         #x4f1020f
+         #xa1d1d15
+         #xc000105
+         #xf9f9fc0d
+         #xef0404f3
+         #x40afff3
+         #xefcecf1
+         #xd03fd0d
+         #xfbf20c12
+         #xf1f1c13
+         #xdff0102
+         #xfdfc010e
+         #xf605fcef
+         #xffef4f2
+         #xfff1f103
+         #x6020811
+         #xf800120c
+         #x151f190c
+         #xb000000
+         #xfe060c
+         #xf800f6f4
+         #xdf2f5f6
+         #xf1f2fe12
+         #x40b1105
+         #xff0c0c02
+         #x161b1408
+         #x900fd01
+         #x1090a
+         #xf4fcf8fc
+         #x4f0fcf8
+         #xeefe0a16
+         #x9140ef1
+         #xb0efffe
+         #x12110f0b
+         #x7fffa03
+         #x1060b09
+         #xf1fefeff
+         #x1fafdef
+         #xf9090e11
+         #x121400e6
+         #x1001f806
+         #xb0b1011
+         #x7fefa04
+         #x2090c0a
+         #xf40202fe
+         #x8fff4e9
+         #x40b0c12
+         #x1209f3eb
+         #xaf6ff10
+         #x60b1215
+         #x7fcf902
+         #x40c0f08
+         #xfb0602fd
+         #xdf9ebea
+         #x7050b17
+         #x8fff3f8
+         #xf50b13
+         #x50c1210
+         #x3f9f900
+         #x7100e00
+         #xff0601ff
+         #xaefebf3
+         #x2121e
+         #xfe00fefd
+         #xfdff110b
+         #x70c0b08
+         #xfcfafc01
+         #xa1107f9
+         #x50202
+         #xebf2f8
+         #xfa071a1c
+         #xfd0803f7
+         #x1070c01
+         #x7080403
+         #xfaff0001
+         #xb0cfcfc
+         #x70605
+         #xf9f0fafa
+         #xff101a12
+         #x51100ee
+         #x904fffd
+         #x402fd06
+         #x1070200
+         #xa01fb07
+         #x6090705
+         #xf7fbf8fa
+         #xb131503
+         #x1306eff7
+         #x3fbfe06
+         #x2fd030c
+         #x9030003
+         #x4fe0108
+         #x7090301
+         #xfdfbf9fe
+         #xd090a03
+         #x10fcf002
+         #xf9f80a12
+         #x1ff080a
+         #x7030204
+         #x2000303
+         #x303fd00
+         #xfcf90003
+         #x4010705
+         #x6fcfb06
+         #xf5061710
+         #x4020700
+         #x3050606
+         #x2000101
+         #xfcfdfb00
+         #xfafd0902
+         #xff020703
+         #x401ff00
+         #xfe14180a
+         #x702fffa
+         #x4090808
+         #xff0005
+         #xf5fafb01
+         #xfc070cfa
+         #x10502fe
+         #xa03faf8
+         #x919120a
+         #x8fef9fd
+         #x80b0a0c
+         #x7
+         #xf5faf9ff
+         #x10c06f2
+         #x904fcff
+         #xbfef3f9
+         #xc131413
+         #x3fafd02
+         #xb0c0c0e
+         #x300ff09
+         #xf6f6f7fe
+         #x409fef1
+         #xc00fb03
+         #x3f5f301
+         #x9121d19
+         #xfffe0102
+         #xd0d0e0c
+         #x4fdfb0d
+         #xf2f2f700
+         #x103faf3
+         #x7fc0105
+         #xf9f4f707
+         #x6161f14
+         #x30701fd
+         #x110c0c08
+         #xf70114
+         #xecf6fe00
+         #xfdfefaf3
+         #x4000601
+         #xf7f9fb08
+         #xb1d1f09
+         #xc0cf8fb
+         #x14070806
+         #xfaf80c15
+         #xef0100f8
+         #xfcfaf8f0
+         #x50604fd
+         #xfffdfd07
+         #x121f1901
+         #x1106f301
+         #xe00070a
+         #xf7ff140e
+         #xfc0bfaf0
+         #xfbf4f4ef
+         #x808fffd
+         #x6fe0007
+         #x131c0f02
+         #x10fef80a
+         #x4000a0e
+         #xfd051004
+         #xa09edee
+         #xf5ebf3f7
+         #x905fd00
+         #x6ff0407
+         #xe140a09
+         #x9fd040c
+         #xff030d0f
+         #x1050802
+         #xfffe7f4
+         #xeae6f902
+         #x9040000
+         #x5030704
+         #x90e0b0c
+         #x4020c09
+         #x80c0c
+         #x1000307
+         #x9f5ecfb
+         #xe1eb030a
+         #xa0705f6
+         #x50a0500
+         #x80a0d0d
+         #x40a0e05
+         #x7070707
+         #xfbfc060c
+         #xf8f6fb
+         #xe0f70906
+         #xf0a00ea
+         #xa0bff01
+         #x8060d0c
+         #x9110b06
+         #xa010205
+         #xf7ff0d0b
+         #x1f9f4
+         #xe8ff05ff
+         #x1307f6e6
+         #xc07fd09
+         #x6050d0c
+         #xf12090a
+         #x5fb0007
+         #xfa050e02
+         #x907f2ed
+         #xf2fafdfe
+         #x1000f0ee
+         #x9010211
+         #x3060e0c
+         #x11110d0c
+         #xfcf8020a
+         #x30905fb
+         #x11ffe9f1
+         #xf0f0fd06
+         #x8faf7f8
+         #x5050b0f
+         #x3070b09
+         #x1011120b
+         #xf7fa040c
+         #x805fcf9
+         #xbf3e9fb
+         #xe5ef050e
+         #x2fe00f7
+         #x60f0c06
+         #x6050605
+         #xe14150b
+         #xfafe060c
+         #x5fcf4fe
+         #xfceef301
+         #xe1fa0f0d
+         #x60502ec
+         #xd1405ff
+         #x8fe0106
+         #xe19180f
+         #xff060a
+         #xfff6f805
+         #xf1f6ff00
+         #xec080e00
+         #xe07f8e4
+         #x150cfb04
+         #x2f7040c
+         #x101d1812
+         #x5000606
+         #xfbf50008
+         #xf10200f9
+         #xfe0b04f4
+         #xfffedeb
+         #x1301fb0f
+         #xf8f70a11
+         #x121f1a0f
+         #x5000502
+         #xfaf70708
+         #xfb07f8f5
+         #xb02f8ef
+         #x4f3edfe
+         #xafe0813
+         #xf302100e
+         #x181f1a07
+         #x3000102
+         #xfcfa0a08
+         #xf1f8
+         #x6f6f6f3
+         #xf6f1fb0d
+         #x5061109
+         #xfa0e0c06
+         #x1c1d1500
+         #x300fe06
+         #xfdff0c08
+         #xfdfaf2fe
+         #xfdf3f9f4
+         #xf1fa0a11
+         #x9130ff7
+         #x60f0302
+         #x18161102
+         #x4fdfc0a
+         #xff030b08
+         #xf8faf900
+         #xf8fafbf0
+         #xf904110e
+         #x1116ffea
+         #xe04fd05
+         #xf100f0b
+         #x4fbfd0b
+         #x2080c08
+         #xf8fefefe
+         #xfe00f4eb
+         #x309110a
+         #x160befef
+         #x9f7000f
+         #x90e1213
+         #x4f9fd07
+         #x50b0d07
+         #xfd03fffe
+         #x6fdeceb
+         #x7071010
+         #xffeedfb
+         #xfef60b13
+         #x80f1411
+         #x1f7fc04
+         #x90e0d02
+         #x104fd00
+         #x5f1e9f1
+         #x1041517
+         #x4faf601
+         #xf701140e
+         #x90f1107
+         #xfdf6fc04
+         #xc1006fc
+         #x303ff02
+         #xfceceff7
+         #xfd081d17
+         #x1fefc
+         #xfd0b0f02
+         #x90b0901
+         #xfaf9ff05
+         #xe0dfefd
+         #x2040205
+         #xf4f1f6f9
+         #xff101f10
+         #x60afcf4
+         #x40b03fd
+         #x6050303
+         #xff000104
+         #xc05f904
+         #x4080705
+         #xf4f9f8f9
+         #x9151a06
+         #x110af2f3
+         #x700fc01
+         #x3ff000a
+         #x8050002
+         #x6fd0308
+         #xa080407
+         #xfbf9f600
+         #xe140ffd
+         #x12f6ef03
+         #xfbfb020f
+         #xff0b07
+         #x6000104
+         #x1ff0604
+         #x9050004
+         #xfcf8fb04
+         #x8080901
+         #x8f3f90a
+         #xf4020f12
+         #x20cff
+         #x2010406
+         #x201
+         #x2fffe05
+         #xf9fd0403
+         #x50901
+         #x3fa0105
+         #xfc14130a
+         #x20405f7
+         #x2060707
+         #xff0004
+         #xfcfbfe04
+         #xfa0707fc
+         #x606fe
+         #x500fefe
+         #x91a0f07
+         #x400fdf9
+         #x7090909
+         #xfefe0009
+         #xfafafe02
+         #x10f02f5
+         #x70400fc
+         #xafef7fd
+         #x11160d0d
+         #x1fcfb01
+         #xc0b0b0b
+         #xff010b
+         #xfaf8fb00
+         #x70efaf2
+         #x8feff00
+         #x4f7f404
+         #xe121713
+         #xfefc0005
+         #xc0b0e09
+         #x1fd020c
+         #xf7f4f901
+         #x706f7f4
+         #x3fb0203
+         #xfcf3f90c
+         #xb191f11
+         #xff020002
+         #xd0c0e04
+         #xfff8040f
+         #xf0f3fc03
+         #x201f8f3
+         #xfe0801
+         #xf8f5fd0c
+         #xd1f1e06
+         #x806faff
+         #xe0b0b01
+         #xf7f70f0f
+         #xeffcfe00
+         #xfffef7ee
+         #x20504fe
+         #xfdf90009
+         #x141f1500
+         #xf02f501
+         #xa070807
+         #xf4ff1809
+         #xfb03f9f8
+         #xfdfaf4ec
+         #x607fffd
+         #x2fb0107
+         #x181f0e01
+         #xefaf908
+         #x204090d
+         #xf9071401
+         #xa01eff4
+         #xf6f4f0f2
+         #xa04fe00
+         #x3fd0508
+         #x171a0907
+         #x6f8020b
+         #xfd060c10
+         #xff090aff
+         #x11f7e8f8
+         #xeceff400
+         #x90102fd
+         #x1010708
+         #x11110b0b
+         #x1ff0909
+         #xff080d0d
+         #x1050402
+         #xbeeebfe
+         #xe3f1ff0a
+         #x80306f4
+         #x3070506
+         #xd0c0e0a
+         #x2080907
+         #x3090a07
+         #xfdfe0607
+         #xeff4ff
+         #xe2fc080a
+         #xa0803e7
+         #x9090006
+         #xa0b0f09
+         #x90e0606
+         #x6050604
+         #xf8000d07
+         #xfef8f8f9
+         #xea030601
+         #xf07f7e2
+         #xe03fe0d
+         #x70a0e0b
+         #xf0e0508
+         #x2000305
+         #xf9060f00
+         #x5fff3f2
+         #xf30200ff
+         #xf00efe7
+         #xaff0314
+         #x40b0e0d
+         #x110d0908
+         #xfbfc0309
+         #xa09f9
+         #xffaeaf3
+         #xf4fafb04
+         #x7f9f2f2
+         #x5010c14
+         #x40c0d0b
+         #x100e0d07
+         #xf5fd060d
+         #x607fff7
+         #xbefe8fb
+         #xebf6020e
+         #xfafef3
+         #x50a0e0c
+         #x70a0906
+         #xf120f07
+         #xf6ff090d
+         #x6fff9fa
+         #xffeaf103
+         #xe5fd0d0f
+         #x10001ea
+         #xd100805
+         #x7040405
+         #xf15100b
+         #xfa010a0a
+         #xfff6faff
+         #xf1f0fc05
+         #xec090f04
+         #x907f9e1
+         #x160bfe05
+         #x3fd030a
+         #x131a130f
+         #xfe020906
+         #xf7f30201
+         #xf3fdff00
+         #xfc0e06f6
+         #xc01ece6
+         #x15fffc0f
+         #xf9fd0911
+         #x181d170c
+         #xfe030705
+         #xf6f70901
+         #xfd02f9fb
+         #x807fbf0
+         #x7f6e9f7
+         #xafb0714
+         #xf3040e12
+         #x1b1e1902
+         #xfe040205
+         #xf6fc0b01
+         #x5fdf2fb
+         #x5fdf3f3
+         #xfaeff608
+         #x304130d
+         #xf90e0e0c
+         #x1d1d14fa
+         #xff02ff0a
+         #xf7000b02
+         #x3f5f1fe
+         #xfbf8f5f7
+         #xf3f6080c
+         #x71010fc
+         #x60f0606
+         #x1b1a0dfc
+         #xfffe10
+         #xfa040c03
+         #xfdf3f7ff
+         #xf5fcf7f6
+         #xf6021306
+         #x111401f1
+         #xe050007
+         #x16150a06
+         #xfb0011
+         #x70c03
+         #xf9f8fdfe
+         #xfa02f4f1
+         #xa1300
+         #x180bf0f2
+         #x8fa010e
+         #xf120e0f
+         #xfff9020b
+         #x40a0d02
+         #xfdfefdfe
+         #x2feebef
+         #x60a1005
+         #x14fbecfe
+         #xfdf90b14
+         #xc12130e
+         #xfdf80006
+         #x80d0c00
+         #x200fc00
+         #x3f3e8f3
+         #x309140e
+         #x9f4f304
+         #xf6031212
+         #xd121305
+         #xfaf6ff05
+         #xc0e08fb
+         #x4fffd05
+         #xfbececf9
+         #xfd0a1d11
+         #x1f9fd00
+         #xfa0f1008
+         #xc100dfc
+         #xf6f70007
+         #xe0c00fa
+         #x3000007
+         #xf2eff3fb
+         #x131f0a
+         #x602fcf8
+         #x5100500
+         #x90a06fe
+         #xf9fb0207
+         #xe05fd00
+         #x4030309
+         #xf2f7f5fb
+         #x7181c00
+         #xf03f4f8
+         #x906fc01
+         #x4030305
+         #x305
+         #x8fe0007
+         #x9090508
+         #xf8faf6fe
+         #xe1713fd
+         #x15fbeeff
+         #x1fcff0b
+         #xff080a
+         #x6020004
+         #x1000803
+         #xb050309
+         #xfcf4fa07
+         #xf1307ff
+         #x4eefa0a
+         #xf8ff0a14
+         #xfe050dff
+         #x303
+         #x30500
+         #x7000206
+         #xf9f80008
+         #x60b0700
+         #xfdf50408
+         #xfb0d110f
+         #x808f5
+         #x20703
+         #x10002
+         #xfc0305
+         #xfa030401
+         #x20a07fc
+         #xfe0300
+         #xa170d08
+         #x206fdf7
+         #x4070904
+         #xfeff0008
+         #xfbfb0302
+         #x10c00fa
+         #x50801f9
+         #x400fcfe
+         #x14140a0a
+         #x100f900
+         #xa0a0a06
+         #xfdfe040b
+         #xfbfb00ff
+         #xb0cf7f6
+         #x601fefd
+         #x4f8f804
+         #x1410100f
+         #xfefcfc09
+         #xb0b0c05
+         #xfeff060b
+         #xf9f7fd00
+         #xd04f4f8
+         #xfd0102
+         #xfef3fc0b
+         #xf16190e
+         #xfeff0008
+         #xb0d0c01
+         #xfdfc080c
+         #xf3f4fd02
+         #x9fff7f8
+         #xfcff0504
+         #xf8f4030a
+         #x101f1a07
+         #x301ff03
+         #xb0e09ff
+         #xf7fb0e0c
+         #xeff70003
+         #x3fff8f1
+         #xff050400
+         #xfaf80507
+         #x161f1100
+         #x9fff902
+         #xa0c0502
+         #xf2021307
+         #xf7fdfefc
+         #xfdf2eb
+         #x608ffff
+         #xfcfb0505
+         #x1c1f0900
+         #x9f9fa09
+         #x408050c
+         #xf60c1100
+         #x4fcf6f5
+         #xfcf9edf1
+         #x904feff
+         #xfdfe0607
+         #x1e190806
+         #x3f7010e
+         #x70910
+         #xff1008fe
+         #xbf4eff5
+         #xf3f3ef00
+         #x80002fc
+         #xfd01070a
+         #x19120b09
+         #xfefc050e
+         #x90d0d
+         #x20b0100
+         #x5ebf0fb
+         #xeaf3fa0c
+         #x50206f2
+         #x5060a
+         #x130e0f08
+         #x4050b
+         #x40a0b06
+         #x40304
+         #xfbeaf6ff
+         #xe8fa050d
+         #x60801e6
+         #x706030a
+         #xe0f0e06
+         #x6090309
+         #x6090802
+         #xfa010905
+         #xf6f2fcfb
+         #xef040905
+         #xc09f5e0
+         #xc01020d
+         #xb0f0c09
+         #xd0a0308
+         #x4050404
+         #xf9070d00
+         #xfff9f7f4
+         #xf9050200
+         #xd01eae4
+         #x9fe0713
+         #x80f0d0d
+         #xf080607
+         #xfe010309
+         #xff0d07f9
+         #x6f7eff3
+         #xfb00fd05
+         #x7f8ebee
+         #x2ff0e15
+         #x80f0e0d
+         #xf0a0905
+         #xf800060d
+         #x70bfff6
+         #x7edebfa
+         #xf4f9010e
+         #xfef7f6f2
+         #x108120f
+         #xa0e0c08
+         #xe0d0a05
+         #xf701090e
+         #x703f9f7
+         #xfbe7f202
+         #xedfd0c11
+         #xfe00fcea
+         #xa0e0d07
+         #xa0a0605
+         #x10100a08
+         #xf9040b0c
+         #xfbf9fa
+         #xefebfb06
+         #xf0071209
+         #x406f6e1
+         #x130a0405
+         #x6030309
+         #x13130d0c
+         #xfc070a09
+         #xf7f600fc
+         #xeff70003
+         #xfd0f0af9
+         #xc03e8e3
+         #x15ff000c
+         #xfd000713
+         #x1717140a
+         #xfe080707
+         #xf2fa03fd
+         #xfbfdfdfd
+         #x80bfcf2
+         #x8f7e4f3
+         #x8fb0911
+         #xf7050e16
+         #x1b1a15ff
+         #xff07020b
+         #xf30005ff
+         #x4faf7fa
+         #x801f4f6
+         #xfeeff002
+         #xff02140f
+         #xfb0c1010
+         #x1d1b10f7
+         #x4ff0f
+         #xf6040500
+         #x3f3f6fa
+         #xfdfaf3fe
+         #xf3f30407
+         #x1101202
+         #x60e0c09
+         #x1d1a07f8
+         #x2000014
+         #xf9060601
+         #xfbf0fafa
+         #xf8faf6fe
+         #xf4001000
+         #xf1505f6
+         #xe070507
+         #x1a160303
+         #x1fd0316
+         #xfd090800
+         #xf6f4fdf9
+         #xfafdf5fa
+         #xfd0c10fa
+         #x190bf6f5
+         #xafe040e
+         #x1512070d
+         #xfefd0510
+         #x30b0aff
+         #xf8fafdfb
+         #x2fceff5
+         #x5100bfd
+         #x17faeffc
+         #xfefa0a17
+         #x12120e0d
+         #xfbfc0409
+         #x60c0afc
+         #xfffcfc00
+         #x3f2ebf7
+         #x50e0c05
+         #x9f0f604
+         #xf7031217
+         #x11131203
+         #xf8fb0208
+         #x90e07f8
+         #x1fbfd04
+         #xfdebedfd
+         #x20f140b
+         #xfff4ff02
+         #xfb0e120e
+         #x10130cfa
+         #xf4f90208
+         #xd0c02f6
+         #xfb0108
+         #xf3ecf2ff
+         #x1151d06
+         #xfffd00fb
+         #x8120905
+         #xd0e04fa
+         #xf3fc0509
+         #xd07fff9
+         #x1ff040a
+         #xf2f2f5ff
+         #x91d19fd
+         #x900f7f8
+         #xd0a0004
+         #x8080101
+         #xf9000506
+         #x8010000
+         #x404050b
+         #xf7f5f500
+         #x111e10f8
+         #xef8f2fe
+         #x8fffe0c
+         #x3030508
+         #xff010304
+         #x2ff0704
+         #xb07040a
+         #xfcf5f905
+         #x121709fd
+         #x9f0f507
+         #xfbfb0714
+         #xfe020c05
+         #x1000203
+         #x10605ff
+         #x8020606
+         #xf7f4010b
+         #x110f03ff
+         #xf4f40309
+         #xfb051310
+         #xb06f8
+         #xfe020600
+         #x2050000
+         #x1ff0704
+         #xf8fc0508
+         #x90c05fc
+         #xf5ff0601
+         #x7101107
+         #x40bfcf6
+         #x607ff
+         #x5
+         #xfb000701
+         #x60200
+         #x80a01f9
+         #xff0200fe
+         #x14100b06
+         #x503f600
+         #x70a0700
+         #xfefe040a
+         #xf90004fe
+         #xa07fbfb
+         #x705fcfb
+         #x2fdfc02
+         #x150d0c0b
+         #x1fdf90b
+         #xa0b0802
+         #xfd00070b
+         #xf9fe00fc
+         #x1000f6fb
+         #x200fc05
+         #xfef60008
+         #x1010140c
+         #xfefd000d
+         #xb0c0900
+         #xfc00090a
+         #xf5faffff
+         #xbfaf8fb
+         #xfd000009
+         #xf8f70607
+         #x121c1507
+         #xff0109
+         #xb0e06fe
+         #xf9000b0b
+         #xf1f80000
+         #x6fbfaf6
+         #xfd040207
+         #xf6fc0a00
+         #x181f1000
+         #x4fe0007
+         #xc0d0201
+         #xf5050f0a
+         #xf2fb01fc
+         #x2fef5ee
+         #x4070003
+         #xf8ff0800
+         #x1f1f09ff
+         #x3f9fc0b
+         #xb09010a
+         #xf90e0a05
+         #xfcfcfdf3
+         #xfaecf0
+         #xa04fe01
+         #xf8010704
+         #x1f170803
+         #xfef60014
+         #x705060f
+         #x1110302
+         #x1f6f5f1
+         #xfbf3eefe
+         #x80001fe
+         #xfa03070a
+         #x1e100b05
+         #xfbfa0416
+         #x5070b0c
+         #x80efe02
+         #xfeeef3f6
+         #xf2f0f90b
+         #x30203f6
+         #xfe05090b
+         #x160f0e03
+         #xfd000413
+         #x70a0d06
+         #x506ff05
+         #xf3ecf7fc
+         #xeff6060e
+         #x408feeb
+         #x4060809
+         #x11110d03
+         #x304040f
+         #x80a0801
+         #x30306
+         #xedf1fcfc
+         #xf3000c06
+         #xa09f1e4
+         #x802060a
+         #xe120b07
+         #x804040c
+         #x7070404
+         #xfd070803
+         #xf4f8faf5
+         #xfd0607ff
+         #xe02e5e6
+         #x7ff090f
+         #xd110b0d
+         #xb030509
+         #x3030309
+         #x10d05fe
+         #xfff8f3f2
+         #x10002
+         #x8f7e4f0
+         #x1113
+         #xd100e0d
+         #xb050706
+         #xfe01050e
+         #x70dfdf9
+         #xfff0eef5
+         #xfbfb030b
+         #xf3eef5
+         #xff071510
+         #xd100e08
+         #xb080605
+         #xfb01090f
+         #xb07f7f8
+         #xf6e8f100
+         #xf4fc0e10
+         #xfbfbf6f0
+         #x50f1206
+         #xe0d0904
+         #xd0b0609
+         #xfc050b0e
+         #x4fef6fa
+         #xebebfb05
+         #xf4051408
+         #x203f1e7
+         #xf0d0902
+         #xa080408
+         #x100d0a0c
+         #xfe080a0c
+         #xfbfaf9fc
+         #xe9f40103
+         #xfe0f0ffb
+         #xb02e5e6
+         #x10030506
+         #x3030611
+         #x14101009
+         #x10a070d
+         #xf5fcfdff
+         #xf3fc01fd
+         #x90f00f3
+         #xcf7e0f2
+         #x8fe090f
+         #xfd030f17
+         #x16151300
+         #x308020f
+         #xf600fd00
+         #xfefcfdf6
+         #xb03f6f7
+         #x1ecea00
+         #xfc04130e
+         #xfe091512
+         #x1a190cf8
+         #x5030115
+         #xf904fd02
+         #xfff6faf4
+         #x3faf400
+         #xf5effd05
+         #xfd101506
+         #x70d1208
+         #x1c1802f9
+         #x6ff0318
+         #xfd070003
+         #xf7f2fbf4
+         #xfbf7fa04
+         #xf3fe0a00
+         #xb1608fa
+         #xd0a0904
+         #x1c13fc01
+         #x3fc0919
+         #x80201
+         #xf0f6fdf4
+         #xfcf9fbff
+         #xfc0b09fa
+         #x170dfbf6
+         #x902060b
+         #x190e020b
+         #xfe0a17
+         #x30a04fe
+         #xf1fafcf7
+         #xf8f7f9
+         #x61103fb
+         #x16fdf4fb
+         #xff0b17
+         #x150e0b0b
+         #xfc000911
+         #x70c05fb
+         #xf8fcfbfc
+         #x2f2f2f8
+         #xb0f0202
+         #x8f2f801
+         #xf902131b
+         #x13111003
+         #xfafe040c
+         #xa0d03f8
+         #xfdfafd01
+         #xfceaf2fd
+         #x80f0b09
+         #xfaf40001
+         #xfe0d1712
+         #x13130af9
+         #xf6fd030d
+         #xc0dfff4
+         #xfbfa0005
+         #xf4e9f600
+         #x7161305
+         #xf8fc01fd
+         #x7121008
+         #x120f00f8
+         #xf4fd050c
+         #xd09fcf4
+         #xfbfe0509
+         #xf0eefa00
+         #xc1d13fc
+         #xfbf9
+         #x100b0504
+         #xe09fc02
+         #xf601060a
+         #x904fefa
+         #xff02060b
+         #xf5f2fa00
+         #x151f0af8
+         #x7faf5fd
+         #xc00020a
+         #x8040009
+         #xfc030406
+         #x40201ff
+         #x504070a
+         #xf9f1fa03
+         #x191b02fa
+         #x2f1f605
+         #x2fb0812
+         #x2040708
+         #xff020303
+         #x1050600
+         #xa040608
+         #xf8f1000a
+         #x14120200
+         #xf8f10009
+         #xf9ff1114
+         #x80aff
+         #xff010401
+         #x50700fe
+         #x2030802
+         #xf3fb070a
+         #x110a03fb
+         #xf0ff050a
+         #xd1602
+         #x60afdf9
+         #xff0604fd
+         #x401ff01
+         #xfc040801
+         #xfb020704
+         #xc0b01f8
+         #xfa050102
+         #xe100eff
+         #x906f500
+         #x40a02fd
+         #xff0208
+         #xfa0705fe
+         #x60300fd
+         #xc06fafc
+         #x100fd03
+         #x120b0a03
+         #x6fdf80c
+         #xa0a0201
+         #xfd00070b
+         #xfc0500fc
+         #xcfefcfb
+         #x700f905
+         #xfffa0006
+         #xf0c0f08
+         #xf90011
+         #xc0b0401
+         #xfd02090b
+         #xfa00fefc
+         #x9f7fcfc
+         #xffff0e
+         #xf7fb0604
+         #xf151306
+         #xfefd060d
+         #xc0b0300
+         #xfc03090c
+         #xf5fcfffd
+         #x3f8fdf8
+         #x1030d
+         #xf50009fe
+         #x191d0f00
+         #xfe030a
+         #xe0b0000
+         #xfa060a0d
+         #xf3fe00f9
+         #xfcfaf2
+         #x4050308
+         #xf70506fc
+         #x1f1a08fe
+         #xfc000f
+         #xf060006
+         #xfd0c090c
+         #xf700fff2
+         #x1fbf0f0
+         #x8020004
+         #xf8050300
+         #x1f1607ff
+         #xfdf90016
+         #xc02040c
+         #x60f0208
+         #xfbfcf7ef
+         #xfff2eff9
+         #x6000102
+         #xfb040509
+         #x1e100a00
+         #xf8fa051b
+         #x9040b08
+         #xd0bfe06
+         #xf8f5f2f5
+         #xf7edf905
+         #x30101fd
+         #xff05080b
+         #x190f0dff
+         #xf9fe081b
+         #x8070d03
+         #xc04fe07
+         #xeff0f5fd
+         #xf1f10808
+         #x307fdf3
+         #x2060a08
+         #x12130aff
+         #x10815
+         #x90a0900
+         #x4000208
+         #xeaf3faff
+         #xf4fe0f01
+         #xa08f0ec
+         #x6050906
+         #x12130803
+         #x4010810
+         #x9080402
+         #x40507
+         #xeef9fbf9
+         #xfc070bf9
+         #xf00e4ec
+         #x4030a0b
+         #x11110a0a
+         #x501070c
+         #x7040308
+         #x30b0402
+         #xf7faf5f3
+         #x20503fb
+         #xbf3e1f4
+         #xff031011
+         #x110f0e0d
+         #x502060a
+         #x200060d
+         #xa0bfdfe
+         #xfbf4eef6
+         #xfe0304
+         #xeeeafa
+         #xfc0a1510
+         #x11101006
+         #x6050409
+         #xff010a0e
+         #xd04f7fc
+         #xf4ecf0ff
+         #xf8fd0d0a
+         #xfbf3f2f7
+         #x3111408
+         #x10100c01
+         #x906040b
+         #xff040c0e
+         #x9fef4fc
+         #xe9ebf806
+         #xf6051705
+         #xfdf0ef
+         #xc120c00
+         #xf0b0505
+         #xb07080d
+         #x80c0d
+         #xf9f5ff
+         #xe6f40004
+         #xfd1013f8
+         #x9fee5ec
+         #xe0a0602
+         #x805070e
+         #xd0b0d0c
+         #x409080e
+         #xf9faf702
+         #xeefc02fd
+         #x71205f0
+         #xdf4e0f3
+         #x603080c
+         #x2030f14
+         #x10110f04
+         #x8060612
+         #xfafff805
+         #xf9fffff5
+         #xd09f9f4
+         #x3e8e600
+         #xfc051011
+         #x71711
+         #x15160bfc
+         #x9010515
+         #xfe00fa06
+         #xfbfbfbf2
+         #x7fcf8fe
+         #xf6e9f806
+         #xfd101409
+         #x50d1606
+         #x1b16fffc
+         #x8fe0818
+         #x1fd05
+         #xf5f9f9f2
+         #xfef6fd02
+         #xf1f70403
+         #xa160dfe
+         #xb0e0d00
+         #x1c0ff902
+         #x4fd0d1a
+         #x2020002
+         #xeff9f8f4
+         #xfbf702ff
+         #xfb0703fc
+         #x160ffff6
+         #xa080506
+         #x1908fe0a
+         #xff101a
+         #x50501ff
+         #xf0fcf7f7
+         #xfef900f7
+         #x70efdfc
+         #x1501f8f9
+         #x1030a15
+         #x1508090a
+         #xfd010f17
+         #x80800fd
+         #xf5fcf7fb
+         #xfff5f9f4
+         #xe0bfc02
+         #x8f7f900
+         #xfb05141b
+         #x130d0e01
+         #xfc010a14
+         #xb0afffa
+         #xfafbf900
+         #xfbedf7f9
+         #xd090208
+         #xf9f50003
+         #xfd0c1b15
+         #x13110af9
+         #xfbfe0712
+         #xd0afcf7
+         #xf9faff04
+         #xf2ebfafe
+         #xc0f0d05
+         #xf4fd0100
+         #x6131707
+         #x130ffff9
+         #xf7fe0712
+         #xe07f8f5
+         #xf8fe0307
+         #xeeeefefe
+         #x10180efd
+         #xfb01fdfd
+         #xf100c01
+         #x1107f900
+         #xf700080f
+         #xc04f7f8
+         #xfa02060a
+         #xf0f2fffd
+         #x191c07f7
+         #x2fdf500
+         #xe050505
+         #xb02fd0b
+         #xfc04060c
+         #x702fbfd
+         #x105070a
+         #xf4f2fdff
+         #x1e1800f9
+         #xf4f608
+         #x4fe0a0d
+         #x501050c
+         #x30408
+         #x404ffff
+         #x6040707
+         #xf4f30005
+         #x1c10fefe
+         #xf5f2fd0e
+         #xfd00140f
+         #x2060804
+         #x10303
+         #x50700fe
+         #x5030804
+         #xf2f7060b
+         #x130b03fe
+         #xeefb050b
+         #xfc071606
+         #x50b02fc
+         #xff0404fe
+         #x701fd00
+         #xff080703
+         #xf5020a05
+         #xf0801f4
+         #xf902030e
+         #x7150df6
+         #xa03f9fe
+         #x3080000
+         #x2fd0007
+         #xfe0a0501
+         #x505fd
+         #xd07fcf8
+         #x202ff09
+         #xe1006fb
+         #x8fbf909
+         #xb09fe03
+         #xfeff060c
+         #x10900ff
+         #x600fffa
+         #xa00f903
+         #x2fd0009
+         #xc0d0903
+         #x1f80210
+         #xd060005
+         #xfe02090c
+         #x304fcfd
+         #x4fbfdfa
+         #x3fb000e
+         #xfbfc0407
+         #xc110e04
+         #xfdfb0a0e
+         #xc060103
+         #xfe04090c
+         #xfefffcfd
+         #xfefafef9
+         #xfe080e
+         #xf6030700
+         #x14180e00
+         #xfcff090b
+         #xd060100
+         #xfe05090e
+         #xf8fefefa
+         #xfdfefbf4
+         #x2020909
+         #xfa0802fc
+         #x1e1908fb
+         #xfd000310
+         #xe040002
+         #x80a0f
+         #xf801fdf5
+         #xfffef4f0
+         #x7020705
+         #xff08ff01
+         #x1f1105fb
+         #xfcfd0319
+         #xc000304
+         #x60a070b
+         #xfb00f7f1
+         #xf6f0f4
+         #x5000405
+         #xff050009
+         #x1d0e05fb
+         #xfafb081e
+         #x7000a04
+         #xe070407
+         #xfaf9eff8
+         #xfaedf7fd
+         #x1000302
+         #x4070b
+         #x191106fb
+         #xf9fd0f1f
+         #x4070eff
+         #xd010306
+         #xf3f3f001
+         #xf2f10400
+         #x204fffb
+         #x3070b07
+         #x141406fd
+         #xfc00111a
+         #x50a0afe
+         #x6fd0408
+         #xecf3f705
+         #xf1ff0dfa
+         #x905f5f2
+         #x5080a05
+         #x15140400
+         #xff000e12
+         #x7090500
+         #x1000608
+         #xeff8f900
+         #xf90b0af2
+         #xefce9f0
+         #x4070909
+         #x150f0607
+         #x10b10
+         #x7050404
+         #x2050505
+         #xf6faf6fa
+         #x10c02f2
+         #xbf0e5f6
+         #x70d11
+         #x140d0c08
+         #x103080f
+         #x4010608
+         #x9080101
+         #xfbf6effa
+         #x20400fb
+         #xe8ebfd
+         #xfe0b1313
+         #x12100f04
+         #x203060d
+         #x10b0b
+         #xe02fbfe
+         #xf6eeee01
+         #xfc000902
+         #xf7ecf4fd
+         #x313140a
+         #x12120bff
+         #x403050e
+         #xff040e0a
+         #xafbf7fe
+         #xecebf508
+         #xf8071200
+         #xfaf5f4f6
+         #xd150e01
+         #x110f0501
+         #x604080f
+         #x70d0b
+         #x1f7f600
+         #xe6f1ff09
+         #xfc1511f4
+         #x4f8ebef
+         #x100f0501
+         #xd070409
+         #x7070c0e
+         #x5090c0c
+         #xfcf7f805
+         #xecfa0201
+         #x71705eb
+         #x9efe4f5
+         #x908050a
+         #x6030e11
+         #xb0d0e09
+         #x8070a0e
+         #xfbf8fa08
+         #xf600fff8
+         #xd0efaee
+         #x1e5e800
+         #x1070c13
+         #x209170e
+         #x11130801
+         #x9020b11
+         #xfefafb07
+         #xfbfff9f4
+         #xb01f7f8
+         #xf4e4f607
+         #xfe0f1310
+         #x4101602
+         #x1813fffe
+         #x6ff0d15
+         #xfb0005
+         #xf8fbf5f6
+         #x1f9ffff
+         #xeef20206
+         #xa151001
+         #xa130cfd
+         #x1a0cf902
+         #x1001118
+         #x2fd0301
+         #xf3faf3fa
+         #xfafa05fc
+         #xf6010200
+         #x171104f8
+         #xb0e0403
+         #x1804fd08
+         #xfd03141a
+         #x2fe03fe
+         #xf3fbf3fc
+         #xfafe03f4
+         #x508fcfd
+         #x1605faf8
+         #x5070611
+         #x11020609
+         #xfc051419
+         #x50200fd
+         #xf8faf3ff
+         #xfbfdfcf0
+         #xf05fa00
+         #x9fbfa00
+         #x7131a
+         #xe080b02
+         #xfc051117
+         #x803fefc
+         #xfbf7f502
+         #xf8f7f7f3
+         #xe010003
+         #xfbf9ff08
+         #xff0e1c13
+         #x100f07fa
+         #xfd020e15
+         #xb05fcfa
+         #xfaf8fb05
+         #xf2f1f9f9
+         #xa050903
+         #xf5fe0107
+         #x6161a05
+         #x120efff8
+         #xfaff0d15
+         #xd03f8f7
+         #xf8fb0009
+         #xecf4fefa
+         #xf100dfb
+         #xfb01fe03
+         #xf1610fe
+         #x1106f800
+         #xf9010d13
+         #xc00f5f9
+         #xfb00030b
+         #xedf8fff8
+         #x181606f5
+         #x1fff805
+         #xf0f07ff
+         #xcfffd0a
+         #xfd030b11
+         #x900f5fe
+         #x4050b
+         #xf0f9fdfa
+         #x1f14fff5
+         #xf6f60d
+         #x7050806
+         #x5ff050e
+         #x103080c
+         #x700fa00
+         #x5040609
+         #xf1f7fe00
+         #x1d0bfff9
+         #xf7f2fc15
+         #xfe041209
+         #x2030a08
+         #x2010508
+         #x702fdff
+         #x4040705
+         #xf0f90305
+         #x160702f9
+         #xf0f80316
+         #xfc0c1701
+         #x40706fe
+         #x20402
+         #x803fdff
+         #x60703
+         #xf1000907
+         #xf0804f6
+         #xf4000510
+         #x11311f8
+         #x907fcfc
+         #x10701fe
+         #x3fdff07
+         #x3090507
+         #xfc0807ff
+         #xd07fbf3
+         #x1000510
+         #xd1600f5
+         #x7fdfc02
+         #xa03fc06
+         #xfefd040d
+         #x70a0103
+         #x30600fa
+         #xb01f8fd
+         #x4fc020e
+         #xd0e0000
+         #xf7020b
+         #xe01ff0a
+         #xfd02090d
+         #xb04fdff
+         #x100fbfc
+         #x4fb0007
+         #xfefc060c
+         #xb0e0703
+         #xfafb0b0c
+         #xb000207
+         #xff050b0b
+         #x6fffcfe
+         #xfdfefbfe
+         #xfffb0b0b
+         #xfa010605
+         #x10130aff
+         #xfa010c0a
+         #x9020302
+         #x60a0c
+         #xfffcfdfc
+         #xfa00fbfa
+         #xfe011005
+         #xfe070100
+         #x191506fa
+         #xfc03070f
+         #xa0302ff
+         #x1060c0d
+         #xfcfffbf9
+         #xff00f5f4
+         #x2040c01
+         #x306fd01
+         #x1e1101f9
+         #xfe000619
+         #x9000200
+         #x5070e0a
+         #xfe00f6f8
+         #xf9f0f3
+         #x3020803
+         #x601fe08
+         #x1a0d00fb
+         #xfcfe0b1f
+         #x40106ff
+         #x8060b05
+         #xfffaeffd
+         #xfdf1f3f8
+         #x10605
+         #x401050b
+         #x160f01fb
+         #xfafe111f
+         #x609fc
+         #x8010803
+         #xf9f1ef07
+         #xf2f2fffc
+         #x10403ff
+         #x4060b06
+         #x1512fffc
+         #xfa00181b
+         #x10c08fa
+         #x4fe0704
+         #xf3eff60a
+         #xefff06f7
+         #x604fcf6
+         #x5090b04
+         #x16120000
+         #xfc031615
+         #x50b04fd
+         #xffff0806
+         #xf1f3fc07
+         #xf70e04ef
+         #xbfdf2f0
+         #x50a0709
+         #x180d0204
+         #xfe040f13
+         #x6070300
+         #xff030805
+         #xf7f7f900
+         #x110fdee
+         #x7efecf5
+         #x3090a12
+         #x160b0906
+         #xff050b13
+         #x4040602
+         #x4040502
+         #xfbf5f3fe
+         #x509faf5
+         #xfde7effd
+         #x20b1114
+         #x130f0c01
+         #x40812
+         #x40903
+         #x80200ff
+         #xf9eef002
+         #x300fe
+         #xf2e8f7ff
+         #x512150e
+         #x131308fd
+         #x2030711
+         #xfe060c05
+         #x7fcfcfe
+         #xefe9f60c
+         #xfc090bfd
+         #xf3f1f9fa
+         #xe160f01
+         #x131102ff
+         #x2020911
+         #xff0a0d06
+         #xf7fa00
+         #xe9edff0d
+         #xff140cf3
+         #xfcf5f3f3
+         #x13130600
+         #x110a0207
+         #x3050d11
+         #x30b0c07
+         #xfaf5fb04
+         #xebf80405
+         #x91b02ea
+         #x2efeaf4
+         #x10090309
+         #xa040a0f
+         #x50b0e0d
+         #x7090b07
+         #xf9f5fe07
+         #xf4ff00fd
+         #x1213f6ea
+         #xfce4ecff
+         #x7060a13
+         #x308130d
+         #xd110906
+         #x6060c0a
+         #xfaf60106
+         #xfcfffafa
+         #x1003f3f2
+         #xefe3f608
+         #x40b1210
+         #x4131404
+         #x15110101
+         #x3040e0e
+         #xfbf70302
+         #xfbfbf4fa
+         #x5fbfafa
+         #xe9ee0109
+         #xa131403
+         #x9190afd
+         #x1809fa01
+         #xfe051214
+         #xfbf906fe
+         #xf9f7f2ff
+         #xfcfe01fa
+         #xf1fd0302
+         #x16140af7
+         #xe120001
+         #x1401fe06
+         #xfb091518
+         #xfdfd04fc
+         #xf9f6f300
+         #xf90202f4
+         #x3fffd
+         #x170afef7
+         #xb09010f
+         #xf000508
+         #xfb0c161a
+         #xff0001fc
+         #xfbf5f401
+         #xfc04faef
+         #xa00fcfd
+         #xcfffa00
+         #x4060f19
+         #xa040803
+         #xfd0b1517
+         #x301fffc
+         #xfcf3f503
+         #xfafff5f2
+         #xafc0000
+         #xfffbff0b
+         #x30e1c15
+         #xd0c03fd
+         #xfe091314
+         #x600fdfb
+         #xfbf3f906
+         #xf5f9f5f7
+         #x60008fe
+         #xf9fe030d
+         #x7191c06
+         #x110bfcfa
+         #xfc061213
+         #x800fbf8
+         #xf8f6ff0a
+         #xf0f8fafa
+         #x7090cf9
+         #xfc00020a
+         #x101d10fc
+         #x1005f7ff
+         #xf9041214
+         #x8fef7f9
+         #xfafc030d
+         #xeffcfcf7
+         #x121106f2
+         #x2fffd0a
+         #x131505fd
+         #xbfffb08
+         #xfb071113
+         #x7fbf6fd
+         #x50d
+         #xf1fefaf7
+         #x1a1000f1
+         #x1f7fb10
+         #xd0c0402
+         #x4fd050d
+         #x60d0f
+         #x5fbf800
+         #x402070b
+         #xf3fcf9fc
+         #x1b0afdf4
+         #xfaf2ff1b
+         #x3090c06
+         #x10c08
+         #x2030b09
+         #x6fdfc00
+         #x4020709
+         #xf1fbff02
+         #x140501f5
+         #xf3f6061d
+         #xf11ff
+         #x2070900
+         #x20804
+         #x6fefdff
+         #x1050708
+         #xf2000604
+         #xd0601f1
+         #xf5fd0a18
+         #x3180cf6
+         #x60702fb
+         #x50402
+         #x5fefd03
+         #x1090608
+         #xf8060801
+         #xc08fef1
+         #xfe010712
+         #xa1902f3
+         #x800fcff
+         #x707fe03
+         #xfefd030c
+         #xa080607
+         #x30900ff
+         #xc02f4f7
+         #xb10
+         #x130cfaff
+         #x1fc0007
+         #xbfeff0a
+         #xfd000a0c
+         #xe040101
+         #x403fa00
+         #x5fbfb01
+         #xfefc0a0f
+         #xe080105
+         #xfafc070a
+         #x7fc0509
+         #xff060c08
+         #xafffffe
+         #xfffa04
+         #xfdfc0905
+         #xfa000a09
+         #xf0d0701
+         #xf8030b09
+         #x3000701
+         #x1080c07
+         #x1fbfdfd
+         #xfcfffb03
+         #xfb031002
+         #xff050402
+         #x151104fb
+         #xfd07080b
+         #x40204fc
+         #x2070d09
+         #xfdfdfdfc
+         #xff00f8fc
+         #xff090dfe
+         #x603ff00
+         #x1a0ffffa
+         #x40716
+         #x50301fb
+         #x3081007
+         #xfffef8fb
+         #x2fcf3f8
+         #x2090800
+         #x9ffff05
+         #x180bfdfe
+         #xff010d1d
+         #x20101fd
+         #x5090f02
+         #x1f9f3ff
+         #xf4f2f9
+         #x1060604
+         #x5fd0407
+         #x140bfd00
+         #xfc00161f
+         #xff0503fc
+         #x4060b00
+         #xffeff206
+         #xf5f1f8fc
+         #x50701
+         #x3030b05
+         #x140ffe00
+         #xfa031b1b
+         #xb03fa
+         #x20602
+         #xf6ecfa0b
+         #xeffdfef8
+         #x50602f7
+         #x40a0b03
+         #x180cfd00
+         #xfb061a17
+         #x40b00fa
+         #xfc020605
+         #xf1f00007
+         #xf70afef3
+         #x800f9f0
+         #x60b0707
+         #x1a090003
+         #xfc081317
+         #x70800fc
+         #xfd040705
+         #xf4f60000
+         #x40ef7ef
+         #x5f5f1f2
+         #x7080910
+         #x15070505
+         #xff090e18
+         #x60502fd
+         #x60602
+         #xf9f5fafe
+         #xb08f4f4
+         #xf9ebf2fc
+         #x60a1013
+         #x120b0802
+         #x60c16
+         #x20505fe
+         #x40403ff
+         #xf9eff602
+         #x702f9fb
+         #xeeeaf801
+         #x810160c
+         #x121105ff
+         #x1040c14
+         #x80700
+         #x400fffd
+         #xf1e9f90a
+         #x10602fe
+         #xecf1fcfe
+         #xe161200
+         #x151200ff
+         #x1020c13
+         #xb0801
+         #xfffbfb00
+         #xe9ec010c
+         #x41205f5
+         #xf4f6f8f7
+         #x151408fc
+         #x1409fe07
+         #x50f14
+         #x30d0902
+         #xfaf7fc03
+         #xe9f50708
+         #xd18feec
+         #xfbf2f0f6
+         #x140c0302
+         #xd04050f
+         #x30a1012
+         #x70d0902
+         #xf6f60006
+         #xf1fe05ff
+         #x1712f3e9
+         #xf7e9edff
+         #xd05090d
+         #x508100f
+         #xa0e0c0b
+         #x70a0903
+         #xf6f70304
+         #xfafffefc
+         #x1504eff0
+         #xece5f509
+         #x708130d
+         #x5131007
+         #x120e0504
+         #x3090a09
+         #xf6f90600
+         #xfefbf8fd
+         #xcfbf5f7
+         #xe5ed000d
+         #xa111701
+         #xb190801
+         #x16080001
+         #xff0a0e11
+         #xf6fc06fc
+         #xfcf5f5ff
+         #xfdfcfa
+         #xebfb0406
+         #x13160ff3
+         #x1316ff03
+         #x1100fe04
+         #xfd0d1218
+         #xf7ff01fb
+         #xfaf2f700
+         #xfc04fdf6
+         #xfa0101fe
+         #x160f02f3
+         #x1207000f
+         #x9fe0309
+         #xff101519
+         #xf900fefd
+         #xfaf1f9ff
+         #xff07f8f4
+         #x400fefb
+         #xf03fbff
+         #xa030a18
+         #x7030607
+         #x1111616
+         #xff01fcfe
+         #xfaf1fa00
+         #x103f2f6
+         #x4fb00fd
+         #x3fcff0a
+         #x40a1915
+         #x9080200
+         #x20f1512
+         #x100fcfd
+         #xf7f0fc03
+         #xfdfbf3fa
+         #xfd05fd
+         #xfdfe060e
+         #x9181b08
+         #xf09fafe
+         #xd1511
+         #x2fffcfa
+         #xf5f30007
+         #xf7f8f7fa
+         #x10607f8
+         #xfe00080b
+         #x121f10fe
+         #x1001f600
+         #xfd0c1413
+         #x3fef9f8
+         #xf6f8040b
+         #xf4fcfaf8
+         #xa0f03f2
+         #x2000409
+         #x181b03fc
+         #x9fbf907
+         #xfc0c1413
+         #x3fbf6fc
+         #xfcfd080c
+         #xf7fff8f8
+         #x150efdef
+         #x2fb0210
+         #x150e0002
+         #x2fb020d
+         #xc120f
+         #x2f8f800
+         #x90c
+         #xf8fdf7fc
+         #x1608faf0
+         #xfbf40519
+         #xb090605
+         #xff000a0c
+         #x1090f09
+         #x1f9fdff
+         #x101090b
+         #xf7fbfa02
+         #x1005fcf2
+         #xf3f60d1f
+         #x50e0c00
+         #x60b03
+         #x70b03
+         #x1fafefe
+         #x3090b
+         #xf6fd0105
+         #xb06fdf0
+         #xf4fc121b
+         #x81708f8
+         #x40804fd
+         #xfe070701
+         #xfbfe00
+         #x106080b
+         #xf9040602
+         #xa08f9ee
+         #xfa001113
+         #xf18fff5
+         #x705fffd
+         #x3060203
+         #xfffc0009
+         #x709070a
+         #x902ff
+         #xd06f4f4
+         #x1000b11
+         #x1312f8fa
+         #x3fefe03
+         #xa01fe08
+         #xfc010a09
+         #xd070700
+         #x704fc06
+         #x8faf4ff
+         #xfb030f0f
+         #x1300fe02
+         #xfeff000e
+         #x4fd0505
+         #xff060d04
+         #xb0102fc
+         #x3fdfc0c
+         #xfff90003
+         #xf9020e0c
+         #xd040603
+         #xfc03060b
+         #xfeff0900
+         #x2090c01
+         #x1fefffc
+         #xfb000b
+         #xfa030a01
+         #xfd060a03
+         #x110c05fd
+         #xff08060b
+         #xff0405fa
+         #x3090b03
+         #xfcfdfefd
+         #xfc0004
+         #xff0d08fd
+         #x40502fe
+         #x160dfffc
+         #x2070711
+         #x20600f9
+         #x30a0d05
+         #xfdfdfbfe
+         #x3fbfafe
+         #x50e02ff
+         #x7ff0000
+         #x1607fa01
+         #x3040c19
+         #x303fefc
+         #x40c0d02
+         #xfaf7fe
+         #x1f5f5fd
+         #x50a0204
+         #x3fc0403
+         #x1306fd05
+         #xff03161b
+         #x3fefe
+         #x50d0900
+         #xfef1f702
+         #xfaf2f6ff
+         #x3080603
+         #xff010901
+         #x1206ff04
+         #xfc071c18
+         #x5fffd
+         #x4090301
+         #xf6edfe07
+         #xf2f7fbfe
+         #x40807fa
+         #xa0a00
+         #x1606ff02
+         #xfc0c1b17
+         #x508fefb
+         #x60106
+         #xeef10502
+         #xf702fbf7
+         #x705fef1
+         #x70c0605
+         #x18020003
+         #xfe0d161a
+         #xa05fdfa
+         #xfe060307
+         #xeef806fe
+         #x408f6f2
+         #x5fcf4f2
+         #xa09070c
+         #x15030204
+         #xc121c
+         #x904fefa
+         #x70405
+         #xf4fafffb
+         #xe02f2f4
+         #xfbf2f1fd
+         #x808110f
+         #xf070504
+         #x2091119
+         #x60400fb
+         #x4070201
+         #xf5f4fbfe
+         #xcfcf6fa
+         #xeeeef704
+         #x90f1707
+         #x110d0301
+         #x2061116
+         #x30600fe
+         #x404ff00
+         #xf0eefc04
+         #x5fffefd
+         #xebf3fc03
+         #xd1615fb
+         #x150d0002
+         #x41114
+         #x3080300
+         #xfffb01
+         #xe7ee0308
+         #x50902f7
+         #xf0f9fcfc
+         #x14170af5
+         #x1607fe07
+         #x51116
+         #x70c0400
+         #xfbfafb05
+         #xe5f70a04
+         #xf11fdee
+         #xf8f7f3fb
+         #x160f03fc
+         #xf000310
+         #xa1216
+         #xa0c04ff
+         #xf7f8ff07
+         #xecff08ff
+         #x190ff4e9
+         #xf6efee02
+         #xf070704
+         #x7040c13
+         #x70e1111
+         #xa0c0400
+         #xf4f90206
+         #xf60101fa
+         #x1b00eded
+         #xece9f30f
+         #x7081205
+         #x60f100d
+         #x100d0b07
+         #x80a0306
+         #xf4fc0402
+         #xfcfdfcfa
+         #xff8f1f5
+         #xe5eeff13
+         #x81117fb
+         #xe170805
+         #x12070402
+         #x40a070f
+         #xf4ff01ff
+         #xfcf6fbfa
+         #x3f9f8fa
+         #xe9f8050d
+         #xf1911ef
+         #x16110006
+         #xe010005
+         #x30c0d17
+         #xf702feff
+         #xf9f2fcfb
+         #xff01fbfa
+         #xf6000402
+         #x161603ed
+         #x1806000f
+         #x6fe020b
+         #x50f131a
+         #xfb02f901
+         #xf5f4fef9
+         #x204f7f8
+         #xfffc
+         #x1208fbfa
+         #xf000b18
+         #x201040d
+         #x8111614
+         #xfd00f802
+         #xf4f4fefa
+         #x700f3f9
+         #x1fdfdfd
+         #x700fe06
+         #x5061716
+         #x5050207
+         #x912160f
+         #xf902
+         #xf2f4fefd
+         #x4f8f5fc
+         #xfdfd0000
+         #xff080b
+         #x7151a0b
+         #xb05fc00
+         #x711130f
+         #xfefaff
+         #xf0f50001
+         #xfef5f9fc
+         #xfd0402fd
+         #xff020c06
+         #x131f0f00
+         #xdfff802
+         #x4101411
+         #xfef8fc
+         #xf0f80405
+         #xf9f8fbf8
+         #x50bfff7
+         #x1040a04
+         #x1c1b05ff
+         #x8f8f90a
+         #x2111413
+         #xfcf5fd
+         #xf5fd0807
+         #xfafcf9f7
+         #x100df9f2
+         #x1000609
+         #x1b0f0002
+         #xf70010
+         #x4111310
+         #xf9f600
+         #xfb000b08
+         #xfdfbf6fb
+         #x1407f5f3
+         #xfbfb0a15
+         #x12070405
+         #xfdfe0711
+         #x50f1008
+         #xfef7fb00
+         #xfd020b08
+         #xfbf8fa00
+         #xf03f5f3
+         #xf3fa111b
+         #xa0a0900
+         #x5090a
+         #x30d0c03
+         #xfdf9fdfe
+         #xfd040c08
+         #xf9f80103
+         #xa04f6f4
+         #xf0001918
+         #xc1207fa
+         #x4080502
+         #xb0700
+         #xfcfbfdff
+         #xff060c09
+         #xfa000501
+         #xa06f4f1
+         #xf6051812
+         #x1414fef5
+         #x707ff01
+         #x30a0301
+         #xfbfcfe05
+         #x4070b07
+         #x60300
+         #xe04eff3
+         #xfb06130e
+         #x180bf7f9
+         #x502fc06
+         #x7030105
+         #xfcff050a
+         #xc080904
+         #x607fe02
+         #xbfdf1fc
+         #xfd040f0f
+         #x1501fb00
+         #xffff0b
+         #x7fe0207
+         #xff060c00
+         #x90805fb
+         #x6fd000d
+         #xf6fa04
+         #xfa09100f
+         #xafd03fe
+         #x412
+         #xfb010800
+         #x30a0afc
+         #x20200fb
+         #xf80710
+         #xfbff0303
+         #xfc0a0e05
+         #x90605fb
+         #x105060e
+         #xfa0605fa
+         #x60a0700
+         #xfb00fdfd
+         #xfefa0907
+         #xb0400
+         #x20906fc
+         #x100a00fc
+         #x506060f
+         #x8fffa
+         #x60b0703
+         #xfbfffcff
+         #xfc03ff
+         #x80eff00
+         #x50300fb
+         #x1306fd02
+         #x5040b15
+         #x505fbfd
+         #x60c0904
+         #xfefcfaff
+         #xf8fcfe
+         #xd0afe05
+         #xff0100
+         #x1100ff07
+         #x1041418
+         #x400fb00
+         #x80f0601
+         #xfdf5fa00
+         #xfaf2fb00
+         #x9070306
+         #xfb010601
+         #xf000306
+         #xff0a1817
+         #x200fd00
+         #x90d0002
+         #xf5f1fe01
+         #xf5f4fd00
+         #x70807ff
+         #xfd090700
+         #x10000303
+         #xfe0f1816
+         #x501fefd
+         #x707fe07
+         #xebf50400
+         #xf6fbfffb
+         #x80901f4
+         #x50c0301
+         #x13000101
+         #x111161a
+         #xa01fdfa
+         #x305010a
+         #xeafe06fc
+         #x1fff9f4
+         #x602f5f4
+         #xb080508
+         #x10000204
+         #x410161d
+         #xa00fcf9
+         #x3050408
+         #xf00000f9
+         #xbfcf5f2
+         #xf8f0ff
+         #xa080d0c
+         #xc040405
+         #x40c171b
+         #x800fcfb
+         #x5060206
+         #xf4fcfafb
+         #xaf6f6f6
+         #xf5f2f509
+         #x80f1504
+         #xd090305
+         #x40a1716
+         #x602fcfe
+         #x604ff04
+         #xf0f4fc00
+         #x4f7fdfb
+         #xeef4fd09
+         #xd1714f8
+         #x12090004
+         #x81515
+         #x603ff00
+         #x400fb05
+         #xe8f30104
+         #x30101f7
+         #xf1faff03
+         #x131a0af0
+         #x1503ff09
+         #xff091418
+         #x9050000
+         #xfffbfb08
+         #xe4fa0802
+         #xc0a00ed
+         #xf8fbf8ff
+         #x181300f3
+         #xffe0310
+         #xb1419
+         #xc0801fd
+         #xfaf9fe0a
+         #xe90207fd
+         #x1709f5e7
+         #xf8f3f106
+         #x120902fd
+         #x6000c15
+         #x60e1514
+         #xd08fffd
+         #xf6fa020a
+         #xf40502f9
+         #x1800efe9
+         #xf1ecf412
+         #x9080c00
+         #x50a1011
+         #xc0f110b
+         #xc07ff03
+         #xf5fd0207
+         #xfc01fdf6
+         #x10f5eff1
+         #xe9ed0019
+         #x51214f7
+         #xd120c0a
+         #xf0b0904
+         #xa05010e
+         #xf700ff05
+         #xfbfbfcf6
+         #x4f5f6f9
+         #xeaf60914
+         #xc1b0deb
+         #x170f0407
+         #xb040206
+         #x9060916
+         #xfa01fb04
+         #xf7f8fdf4
+         #xfffcfafb
+         #xf3ff0908
+         #x151a00e9
+         #x1803020c
+         #x400010f
+         #xa0a1116
+         #xfe00f707
+         #xf2f8fef3
+         #x200fafa
+         #xfd010200
+         #x170df7f3
+         #xffc0a15
+         #x1010313
+         #xd0e1613
+         #xfff809
+         #xf1fafdf5
+         #x8fdf8f9
+         #xfffefc01
+         #xe01fb00
+         #x5041616
+         #x304050d
+         #xe12160c
+         #x1fcfa08
+         #xf0fafcf9
+         #x7f6f8fa
+         #xfdfdfd04
+         #x3000606
+         #x3121a0d
+         #x7030104
+         #xd12140c
+         #xfbfb06
+         #xeef9fefd
+         #xf4fcf9
+         #xfc01ff04
+         #x50e02
+         #x111d1103
+         #x9fdfc02
+         #xa11120f
+         #xfcf903
+         #xeefb0100
+         #xfaf6fdf5
+         #x307fdfe
+         #x1090bfe
+         #x1c1a0500
+         #x3f7fc0b
+         #x9121412
+         #xfbf503
+         #xf0ff0501
+         #xfafafbf3
+         #xc07f9f9
+         #x2070703
+         #x1e0e0102
+         #xfef60015
+         #xa13140f
+         #xf8f405
+         #xf6020803
+         #xfdfaf8f6
+         #x1105f4f7
+         #xff02080e
+         #x15050405
+         #xfbfa0617
+         #xc131109
+         #xfdf6f805
+         #xfa050a05
+         #xfdf6fbfc
+         #xe00f2f9
+         #xf6001217
+         #xc070900
+         #xfe010a12
+         #xa100c02
+         #xfbf8fb02
+         #xfc060b05
+         #xf9f600ff
+         #xbfff3f9
+         #xf2041916
+         #xc0d06f9
+         #x206080a
+         #x70e0700
+         #xfafafa01
+         #xfd080c04
+         #xf8fd05ff
+         #xb01f2f6
+         #xf50d1a0f
+         #x140efff4
+         #x7060107
+         #x70b0202
+         #xfafcfb05
+         #x10a0d03
+         #xfd0303fe
+         #xe00eff5
+         #xfa10150d
+         #x1908f9f6
+         #x703fe0b
+         #xa060003
+         #xfbfd0108
+         #x60b0cff
+         #x304ff00
+         #xdf9effb
+         #xfd0d100f
+         #x16fefafb
+         #x400ff13
+         #x8000104
+         #xfe030b04
+         #xa0a08fd
+         #x700000a
+         #x4f5f601
+         #xfa091011
+         #xdfa0100
+         #x113
+         #x602
+         #x30a07fb
+         #x607fffc
+         #xfa090d
+         #xfaf80006
+         #xe1008
+         #x20402f8
+         #xb0e
+         #xfb060300
+         #x80b02fd
+         #x3fcff
+         #xfbfc0f08
+         #xff040202
+         #x30e09fd
+         #x90afef7
+         #x303090c
+         #x109fffd
+         #x8090204
+         #xfe00fc01
+         #xfc010aff
+         #xa09ff00
+         #x60800fb
+         #xe05fc00
+         #x5030b11
+         #x805fa00
+         #x80a0407
+         #xfefb00
+         #xfe0001fc
+         #xf05fe03
+         #x202fe00
+         #xe000005
+         #x3051115
+         #x800fa03
+         #xb0c0504
+         #xfef9fa00
+         #xfbf9fdfe
+         #xd020305
+         #xfb010106
+         #xaff0705
+         #x91615
+         #x3fcfd03
+         #xd0b0102
+         #xf6f6fc01
+         #xf5f60000
+         #x8050801
+         #xfd070304
+         #xa010700
+         #x10f1615
+         #x2fd00ff
+         #xd06ff04
+         #xeef80002
+         #xf4fa02fb
+         #x80905f9
+         #x50a0104
+         #xb0204fe
+         #x4121517
+         #x4fffffb
+         #x7010108
+         #xeb0002ff
+         #xfcfdfff2
+         #xa06f9f6
+         #xc070107
+         #xa000102
+         #x712161b
+         #x6fffcf8
+         #x5020709
+         #xf203fefd
+         #x4faf8ed
+         #x4fcf100
+         #xb070909
+         #x7030206
+         #x8101c18
+         #x6fefafb
+         #x6040607
+         #xf800f8fd
+         #x5f6f6f0
+         #xfcf3f60a
+         #x80e1204
+         #x9060307
+         #x60f1c13
+         #x5fefafe
+         #x7030206
+         #xf6f9f800
+         #xf6faf5
+         #xf3f3000d
+         #xb180ff9
+         #xf060206
+         #x30e1813
+         #x5fefc00
+         #x6000006
+         #xeef7fe04
+         #xfefd00f4
+         #xf3f90307
+         #x151b06f0
+         #x11010108
+         #xd1616
+         #x600ffff
+         #x1fbff08
+         #xe8fb0303
+         #x406ffec
+         #xf8fcff03
+         #x1a14fcf0
+         #xdfd0410
+         #x10f1719
+         #x90300fc
+         #xfcf8000b
+         #xeb030500
+         #xf08f7e4
+         #xfbf7f708
+         #x1709fbf8
+         #x4fe0c16
+         #x5111816
+         #xb04fdfb
+         #xf8f9030c
+         #xf60700fa
+         #x1200eee5
+         #xf5eef914
+         #xc0704fc
+         #x2081214
+         #xb12160c
+         #xc02fc00
+         #xf7fd050b
+         #xfe04fcf6
+         #xcf7eced
+         #xedec041c
+         #x70f0bf7
+         #xa0f110d
+         #xd100d05
+         #xb00ff09
+         #xf9000209
+         #xfefffaf4
+         #x1f4f2f5
+         #xeaf41117
+         #xc1b07ec
+         #x140e0907
+         #xb090409
+         #x8000712
+         #xfd00fe08
+         #xf8fcfaf2
+         #xfdf8f8f9
+         #xf1fe100c
+         #x181afbe8
+         #x1505050a
+         #x5030211
+         #x8041113
+         #xfdfc09
+         #xf4fdf9f3
+         #xfcfbf8
+         #xfa020903
+         #x1d0ef3f0
+         #xdff0a11
+         #x1020517
+         #xa0b160c
+         #xf9fd0b
+         #xf1fef8f5
+         #x6fcfbf6
+         #xff000003
+         #x1601f5fc
+         #x2011316
+         #x2030812
+         #xd101608
+         #xfff7000c
+         #xf4fdf6fa
+         #x6f7fbf6
+         #xfdfdfe09
+         #x8000100
+         #x111711
+         #x5020705
+         #xd131308
+         #xfff8000a
+         #xf4fcf8fe
+         #xfff5fdf5
+         #xfcfe000a
+         #x1060aff
+         #xc1b1307
+         #x5ff0102
+         #xd12110c
+         #xfef8fe09
+         #xf2fcfc00
+         #xf8f8fef2
+         #x10004
+         #x20d08fc
+         #x1c190802
+         #xf9fe0a
+         #xc12130f
+         #xfff8fa09
+         #xf3ff0000
+         #xf8fcfbef
+         #x903fdfe
+         #x60d0400
+         #x1e0e0302
+         #xf9f60215
+         #xe13150c
+         #xfff5f80a
+         #xf6020201
+         #xfbfcf7ef
+         #xdfff8fb
+         #x407050b
+         #x18050403
+         #xf7fa081b
+         #xf141305
+         #xfcf3fa0b
+         #xfa050503
+         #xfbf8f8f5
+         #xbfcf5fd
+         #xfe050d14
+         #xd050701
+         #xfa000d17
+         #xf120c01
+         #xf9f5fc09
+         #xfd070703
+         #xf7f7fdf9
+         #x8faf6fd
+         #xf8091614
+         #xb0c06f9
+         #x40d0f
+         #xd0e0700
+         #xf9f8fc08
+         #xa0a01
+         #xf6fc01fa
+         #x8faf6fb
+         #xf9111810
+         #x100e00f3
+         #x306080b
+         #xc0b0301
+         #xfaf9fa09
+         #x20c0bff
+         #xf90401fa
+         #xafaf3f7
+         #x16140d
+         #x1606f8f2
+         #x6040210
+         #xd060004
+         #xfbfaff0b
+         #x60e0afd
+         #x5fefd
+         #xaf5f1f9
+         #x3130f11
+         #x12fef9f7
+         #x5000316
+         #xb010005
+         #xfdff0606
+         #x90e06fa
+         #x500fe04
+         #x3f1f500
+         #x30f0f13
+         #xafbfffa
+         #x3ff0819
+         #x3000204
+         #x1070afe
+         #x80b01fb
+         #x3fa060d
+         #xfbf4fd06
+         #xd120f
+         #x20001f9
+         #xff0a12
+         #xfc040400
+         #x70afffe
+         #x802fb01
+         #xfa020e07
+         #xf9fe0402
+         #x8110d00
+         #x309faf9
+         #x31006
+         #x1050002
+         #xa08fd04
+         #x400fc04
+         #xfa090b00
+         #x50501ff
+         #xa0c01fc
+         #xb07f9fd
+         #x2040c0a
+         #x904fc02
+         #x9060109
+         #x3fdfd04
+         #xfe0902fc
+         #xd0200ff
+         #x603fb03
+         #xb00ff03
+         #x2060f10
+         #xafefc05
+         #xa080507
+         #xfafc04
+         #xfd02fefe
+         #xaff0401
+         #xfe0b
+         #x7ff0603
+         #x10a1313
+         #x4faff04
+         #xe090401
+         #xfbf7fc05
+         #xf8fcff00
+         #x5010a00
+         #xff02020c
+         #x40409ff
+         #x20e1511
+         #xfffb0200
+         #xe050100
+         #xf3f8fd07
+         #xf5fc02fb
+         #x60808fa
+         #x6060208
+         #x50703fb
+         #x6111512
+         #xffff01fd
+         #xa000303
+         #xf1fdff08
+         #xf80000f2
+         #xa09fff6
+         #xc040107
+         #x605ff00
+         #xa121714
+         #xfefb
+         #x3000805
+         #xf701fd04
+         #xfffff8eb
+         #x900f5fc
+         #xc03050a
+         #x5030108
+         #xa131c13
+         #x1fffafb
+         #x2020a04
+         #xfefff802
+         #xfaf3ed
+         #xf5f906
+         #x80a0d06
+         #x6040409
+         #x9131d0f
+         #x1fcf8ff
+         #x4030804
+         #xfef8f703
+         #xfbf8f5f3
+         #xf7f3040a
+         #xb140dfe
+         #xb040407
+         #x613190f
+         #xfbfb00
+         #x4000403
+         #xf5f5fc05
+         #xf9fcfaf4
+         #xf3f90b05
+         #x151803f5
+         #xd010308
+         #x5131614
+         #xfdffff
+         #x1fc0405
+         #xeff90006
+         #xff04faed
+         #xf7fe0601
+         #x1d11f9f2
+         #x8fe040f
+         #x4121817
+         #x200fffb
+         #xfdf90508
+         #xf1000203
+         #x807f5e5
+         #xfbfbff05
+         #x1b07f6f7
+         #x2000b17
+         #x7141b13
+         #x601fcf9
+         #xf7f9070b
+         #xfa0500fe
+         #xe02ece3
+         #xf7f2ff10
+         #x1103fdfc
+         #x61318
+         #xc17190c
+         #x800fafd
+         #xf6fd090a
+         #x103fcf9
+         #x8f8e7eb
+         #xeeef0b19
+         #x80902f8
+         #x70f1410
+         #xf151005
+         #x7fcfd06
+         #xf9000808
+         #x200f9f5
+         #xf3ecf4
+         #xe9f51718
+         #xe1501f0
+         #x10100e08
+         #xe0f0507
+         #x3fb050c
+         #xfdff0505
+         #xfdfcf6f5
+         #xfaf5f4f9
+         #xed001a0b
+         #x1b16f8ea
+         #x13090708
+         #x9070211
+         #x102100d
+         #xfffb0206
+         #xf9fdf5f6
+         #xfdfaf9f7
+         #xf7070f03
+         #x1f0aefef
+         #xb020810
+         #x4030717
+         #x30a1509
+         #xfef70308
+         #xf8fdf3fa
+         #xfbfaf4
+         #xfd040503
+         #x1bfff2f8
+         #x1050f17
+         #x3030e12
+         #x7121404
+         #xfaf5050a
+         #xf9fcf2fd
+         #x2faf9f2
+         #xfeff0009
+         #xdfcfdff
+         #xff0f1516
+         #x3040c06
+         #xa151004
+         #xf8f7070a
+         #xfbf8f4ff
+         #xfdfaf9f2
+         #xfcfd050a
+         #x40405fd
+         #x918130d
+         #x2010500
+         #xc130f08
+         #xf9f9040a
+         #xfaf8f900
+         #xf7fcfaf2
+         #xfeff0804
+         #x40c05fb
+         #x19180b05
+         #xfffc0007
+         #xd13110b
+         #xfaf8000b
+         #xf8fbfd00
+         #xf800f8ef
+         #x20004fe
+         #xa0e00fe
+         #x1e0f0403
+         #xf9f90115
+         #xe141407
+         #xfbf6000d
+         #xfaffff00
+         #xfbfff4ee
+         #x7fffffb
+         #xb090108
+         #x17060505
+         #xf5fb0a1c
+         #x10161300
+         #xf9f2000e
+         #xfd010002
+         #xfcfbf3f1
+         #x6fafbfc
+         #x6050811
+         #xe070603
+         #xf8001119
+         #x11140dfc
+         #xf6f2000d
+         #x40303
+         #xf8f9f7f5
+         #x3f7fafe
+         #x91214
+         #xa0b04fd
+         #xfd041212
+         #x100f07fd
+         #xf5f5000c
+         #x2070700
+         #xf5fefbf8
+         #x1f7fcfa
+         #xff111610
+         #xe0dfef6
+         #x70d0c
+         #xe0b04ff
+         #xf7f7000c
+         #x50b08fe
+         #xf803fcf9
+         #x3f7faf6
+         #x616130f
+         #x1308f8f3
+         #x306080f
+         #xd060201
+         #xf9f7010d
+         #x80e06fb
+         #x5fafb
+         #x3f5f6f7
+         #xc140f12
+         #x10fff4f6
+         #x4030816
+         #xb020103
+         #xfafa0709
+         #xc0f02fb
+         #x401fb00
+         #xfff1f6fd
+         #xb0f1015
+         #x7fdf8fa
+         #x3000d18
+         #x5000205
+         #xfe010902
+         #xd0cfffc
+         #x2fd0207
+         #xf8f1fc04
+         #x90e1310
+         #x1fcfa
+         #x1311
+         #xff000305
+         #x50903fd
+         #xa07fcff
+         #xfdfe0c0a
+         #xf7f90206
+         #x7101205
+         #x8fbf8
+         #xff021209
+         #xff050202
+         #x805fc03
+         #x9fdfe05
+         #xfc0d0a06
+         #xfd0004fc
+         #xd1006fb
+         #xa01f600
+         #xb0c05
+         #x6010101
+         #x802000a
+         #x5fc0007
+         #x1110200
+         #x50101fa
+         #xc06fd03
+         #xbfefb04
+         #x2090b0b
+         #x9fe0003
+         #x8030607
+         #x2fb0006
+         #x408fc00
+         #x6ff02fd
+         #x5fe000e
+         #x5ff0305
+         #x20a0f0f
+         #x2fa0204
+         #xa060700
+         #xfdf8ff07
+         #xff00fd01
+         #x10106fe
+         #xfd0510
+         #x2050500
+         #x40d120e
+         #xfcfb0402
+         #xc0604fc
+         #xf7f7ff0b
+         #xf9fe01ff
+         #x708fa
+         #x401070a
+         #x40b00fc
+         #x70f140b
+         #xf90003ff
+         #x80103fe
+         #xf5f9000c
+         #xf90200f5
+         #x80b00f5
+         #x9010507
+         #x709fc00
+         #xa11160d
+         #xfd02fffd
+         #x2000500
+         #xf9fc000b
+         #xfd03f8ee
+         #xc05faf8
+         #x900050a
+         #x603fe07
+         #xb13190c
+         #xfaff
+         #x30901
+         #xfbfd06
+         #xfffff0ef
+         #x4f9fa00
+         #x6050a0b
+         #x602050b
+         #xc171c0b
+         #xfdf800
+         #x1060800
+         #xf6fa04
+         #xfafaeff5
+         #xf8f50503
+         #xa0f0b03
+         #x8020709
+         #xd18160c
+         #xfef9f901
+         #x2040600
+         #xfaf4fd05
+         #xf8fbf5f8
+         #xf3fc0d00
+         #x151404fa
+         #xa020508
+         #xa161310
+         #xfdfbfd00
+         #x10600
+         #xf3f60106
+         #xfd00f8f3
+         #xf6020afd
+         #x1e0ef9f5
+         #x600040e
+         #xb161714
+         #xfdfffefc
+         #xfbfe0602
+         #xf4fc0305
+         #x504f2ea
+         #xfb010300
+         #x1b02f5f7
+         #xa19
+         #xb161b11
+         #x100fafb
+         #xf7fe0906
+         #xfb000200
+         #xc01e9e7
+         #xfafa020a
+         #x13fef9fc
+         #xff06131c
+         #xe1a1a08
+         #x4fef7fe
+         #xf6000b07
+         #x201fffb
+         #x9f8e3ed
+         #xf1f50b13
+         #xa02fffc
+         #x30e1715
+         #x131a1203
+         #x3faf903
+         #xf8020c04
+         #x3fffaf6
+         #x1f1e7f7
+         #xe9fb1a13
+         #xd0bfef3
+         #xd12120b
+         #x13130605
+         #xfff9020a
+         #xfb020a00
+         #xfcf6f6
+         #xfcf0f0fc
+         #xec061c0b
+         #x190ef7ec
+         #x110e0909
+         #xf0a040e
+         #xfbff0c0b
+         #xfdff07ff
+         #xfdfaf4f9
+         #xfaf5f7fa
+         #xf60e1402
+         #x1f05efec
+         #xb070511
+         #x9040a14
+         #xfc0b1108
+         #xfafb0701
+         #xfcf9f3fc
+         #xfefaf8f6
+         #xff0c0902
+         #x1bfbf0f4
+         #x2060c1a
+         #x5041110
+         #x2130f04
+         #xf6fa0706
+         #xfef6f3ff
+         #xfffbf6f4
+         #x40406
+         #xef8f8fb
+         #xd141c
+         #x3051104
+         #x9160b04
+         #xf4fc0909
+         #xfff3f600
+         #xfdfcf4f4
+         #xfdff0708
+         #x30001fc
+         #x8161613
+         #x20509fe
+         #xd140a06
+         #xf4fd070b
+         #xfcf3f9fe
+         #xf9fef4f5
+         #xfb000d02
+         #x60902fb
+         #x16160f09
+         #xff000005
+         #xe120d07
+         #xf6fd050b
+         #xf9f6fdfd
+         #xf900f4f4
+         #xfe020bfd
+         #xd0bfefd
+         #x1d0f0705
+         #xfafc0013
+         #xf151103
+         #xf7fa040d
+         #xfafbfffe
+         #xfefff2f2
+         #x10203f9
+         #x1005fe04
+         #x15080407
+         #xf7fc0a1d
+         #x11180efc
+         #xf5f6050f
+         #xfdfd0000
+         #xfefaf0f3
+         #x1fffefb
+         #xb02050b
+         #xd070508
+         #xf700141a
+         #x131609f7
+         #xf3f5060f
+         #x200
+         #xfbf8f1f6
+         #xfffafefd
+         #x5070f0e
+         #xa0a0504
+         #xfb061612
+         #x121104f8
+         #xf1f7050e
+         #x20205ff
+         #xf8fcf5f9
+         #xfdf9fffa
+         #x30f140e
+         #xd0cfffc
+         #xa110d
+         #xf0c02fb
+         #xf3f8050c
+         #x40706fb
+         #xfb00f7fb
+         #xfdf9fdf5
+         #xa15130c
+         #x1107f7f8
+         #x20a0b0e
+         #xc0802fe
+         #xf5f7070c
+         #x90c04fa
+         #x2f7fe
+         #xfef8f8f4
+         #x1214100f
+         #xf00f3fa
+         #x4070c14
+         #x9040200
+         #xf5f90b09
+         #xe0c00fb
+         #x5fff800
+         #xfaf4f5fb
+         #x120f1211
+         #x6fbf4ff
+         #x4041115
+         #x5010103
+         #xf8000c03
+         #x100afdfc
+         #x2fcfe06
+         #xf5f3fa02
+         #xe0d170e
+         #xfef700
+         #x5160e
+         #xff0305
+         #xff0506ff
+         #xf03fcff
+         #xfe000609
+         #xf3f70103
+         #xa111603
+         #x103f7ff
+         #xfe081505
+         #xfe000404
+         #x707fd00
+         #xc00fd04
+         #xfa080a07
+         #xf9ff0500
+         #xc120dfc
+         #x704f6fe
+         #xff0a1003
+         #x4030201
+         #x7000006
+         #x2fd0406
+         #x60e0509
+         #x300f9
+         #x100afffe
+         #xaf7fa07
+         #x50e050a
+         #x40102fe
+         #x4000606
+         #xfd0407
+         #xb0a0006
+         #x200fefb
+         #x9ff000a
+         #x4fa0109
+         #x60a090d
+         #x1fd0201
+         #x50409ff
+         #xfcfc0307
+         #x800ff05
+         #xff010000
+         #x1fc090d
+         #x1030504
+         #x60c0f0b
+         #xfafe0501
+         #x80704f9
+         #xf8f9020a
+         #xfd0101
+         #x702fe
+         #xff000c08
+         #x50a00ff
+         #x70f1108
+         #xf7010400
+         #x70400fa
+         #xf5f9050d
+         #xfc0101fb
+         #x60bfff8
+         #x3030a03
+         #xa07fa00
+         #x9101208
+         #xfb050000
+         #x20200ff
+         #xf8fb060c
+         #xff04faf4
+         #xc08f9f7
+         #x4020707
+         #xa01fd07
+         #xb13140a
+         #x103fb00
+         #x40301
+         #xfcfb0506
+         #x100f0f3
+         #x9fff9fb
+         #x203080c
+         #x7fe040b
+         #xd171409
+         #x2fdf803
+         #x1080500
+         #xfff80102
+         #xfff8eefa
+         #xfdf902ff
+         #x40a0c0a
+         #x6000909
+         #x111a1309
+         #xfff8f904
+         #x30803fd
+         #xf8f50001
+         #xfaf6f3fd
+         #xf4ff09fd
+         #x110f07ff
+         #x6030708
+         #x1219100d
+         #xfbf9fb03
+         #x10503fc
+         #xf2f70203
+         #xfcfaf7f9
+         #xf60607fa
+         #x1b0bfef6
+         #x502050f
+         #x1016140f
+         #xfbfdfc00
+         #xfe0303fe
+         #xf2fb0502
+         #x3fff4f1
+         #xfe0902fd
+         #x1a01f6f6
+         #x10a1a
+         #x1017190d
+         #xfffff8ff
+         #xf9020502
+         #xf80005ff
+         #xafeebed
+         #xfe010105
+         #xffbf8fb
+         #xff05141f
+         #x121b1807
+         #x2fcf500
+         #xf9050804
+         #xfe0101f8
+         #xaf5e5f1
+         #xf6fc080e
+         #x7fdfdfb
+         #x10d1a19
+         #x161c1101
+         #x1f7f504
+         #xfb060b01
+         #x1fffdf4
+         #x3ece6f9
+         #xee001511
+         #x804fff5
+         #xa14160e
+         #x18180702
+         #xfcf6fd0a
+         #xfd070afb
+         #xfffcf7f5
+         #xfceaefff
+         #xef0d1b0b
+         #x1408f8eb
+         #x10120b0c
+         #x150c030a
+         #xf7fc060d
+         #xfd0505f9
+         #xfdf9f5f8
+         #xf9eef6fe
+         #xf9161304
+         #x1a02f2e8
+         #xe0b0614
+         #xd040a11
+         #xf9070b0c
+         #xfa0203fd
+         #xfdf6f5fc
+         #xfaf6f9fa
+         #x3140900
+         #x16f8efee
+         #x6060b1c
+         #x605130e
+         #x1110a08
+         #xf6000304
+         #xfef3f7fc
+         #xfdfaf5f8
+         #x50b0503
+         #x9f6f5f7
+         #x309161f
+         #x4081204
+         #xb130706
+         #xf401040a
+         #xfdf1fafa
+         #xfdfaf3f9
+         #x40904
+         #xfdfcfb
+         #x8111b18
+         #x30909fe
+         #x10110607
+         #xf503050d
+         #xf9f2fcf8
+         #xfcfcf4fb
+         #xfc030e01
+         #x205fffa
+         #x1315150c
+         #x204ff03
+         #x11100a07
+         #xf701050e
+         #xf5f5fef6
+         #xfdfbf4fa
+         #xfd070bfc
+         #xd07fcfb
+         #x19100b08
+         #xfeff0012
+         #x12130d01
+         #xf800050f
+         #xf5f9fef8
+         #xfbf3f7
+         #x803fa
+         #x1202fcff
+         #x160a060a
+         #xf9fd0a1a
+         #x14160bfb
+         #xf6fd0612
+         #xf9fcfffa
+         #x1f7f2f7
+         #x105fefd
+         #xd000304
+         #xc07070e
+         #xf8001419
+         #x161603f6
+         #xf3fc0813
+         #xfcfd01fa
+         #xfef4f1f8
+         #xff00fefe
+         #x6030c07
+         #xb08070b
+         #xfb071713
+         #x1711fef6
+         #xf1fd0911
+         #xfe0004f8
+         #xfbf5f3fb
+         #xfcfefffc
+         #x50d1106
+         #xd090404
+         #xc130e
+         #x130afef9
+         #xf2fc080d
+         #x504f6
+         #xfcfaf7fd
+         #xfbfefef7
+         #xa131206
+         #x1006fcfe
+         #x40d0e0f
+         #xd08fffa
+         #xf3fc090b
+         #x50902f6
+         #x1fcf800
+         #xfcfdf7f6
+         #x12131108
+         #xefff500
+         #x60a0d13
+         #xa07fffd
+         #xf3fd0c09
+         #xb0a00f7
+         #x4faf903
+         #xfaf9f3fb
+         #x13101309
+         #x7f9f505
+         #x6081214
+         #x604ff00
+         #xf3010d04
+         #x1006fdf8
+         #x3f8fd07
+         #xf6f5f602
+         #xe101805
+         #x1f8f809
+         #x30a160d
+         #x1000004
+         #xfa0608ff
+         #x1001fdfa
+         #xfefc020c
+         #xf3f7ff03
+         #xa1417ff
+         #x2fcf906
+         #x10e1405
+         #xfd000404
+         #x20700fe
+         #xbfdfefe
+         #xfc04070d
+         #xf6fd03ff
+         #xc170ff8
+         #x7fcf804
+         #x2100c02
+         #xfe020600
+         #x702fd03
+         #x6fe0104
+         #x10e070a
+         #xfe0203f9
+         #xf1102fa
+         #xbf9f905
+         #x50f0607
+         #x30303fd
+         #x3ff0503
+         #xfd010606
+         #xe060708
+         #x102f900
+         #xe02ff01
+         #xf6010c
+         #xc09050d
+         #x20000
+         #x20309ff
+         #xfc010606
+         #xdff0406
+         #x100fa05
+         #x2fd0808
+         #xfffe0609
+         #x9080b0b
+         #xfc000202
+         #x50704f9
+         #xf9ff0507
+         #x3fc0502
+         #x4fe05
+         #xfc020f03
+         #x4060302
+         #x80c0e06
+         #xf9030301
+         #x706fdf9
+         #xf6fd070a
+         #xffff03fc
+         #x608fe00
+         #xfe080c00
+         #xb05fe00
+         #x90f0d06
+         #xfc060101
+         #x503faff
+         #xf5ff0a09
+         #x2fef7
+         #xe08f9fa
+         #x1070703
+         #xdfefd04
+         #xb110e0b
+         #x304fd02
+         #x202fd03
+         #xf7000a05
+         #x300f5f6
+         #xc00f7fc
+         #x5070b
+         #x7fb0508
+         #xe150f0c
+         #x6fffa03
+         #x2050003
+         #xf8ff0700
+         #x3f7f2fa
+         #x1fcfc00
+         #x1070b0c
+         #x3ff0b07
+         #x13180d0a
+         #x2f8fb06
+         #x50801ff
+         #xf5fc02fe
+         #xfdf0f7ff
+         #xfa0003ff
+         #xa0c0c04
+         #x3040906
+         #x16170d0a
+         #xfcf6fd07
+         #x60600fc
+         #xf0fb0200
+         #xfbf4fcfc
+         #xfc0801fb
+         #x150b03f8
+         #x304060d
+         #x1515110c
+         #xfaf9fd07
+         #x305fefd
+         #xf0fd0400
+         #xfafaf4
+         #xafdfd
+         #x1502faf5
+         #x1020919
+         #x1216160a
+         #xfdfbfa05
+         #x40000
+         #xf40005fd
+         #x6faf2f0
+         #x406fd03
+         #xdfbf7f9
+         #xff03151f
+         #x141a1604
+         #x1f9f605
+         #xfe050403
+         #xfa0201f8
+         #x7f2eaf2
+         #xfd00040c
+         #x3fbfcfc
+         #x10c1e1b
+         #x191d0e00
+         #x1f5f609
+         #xff080800
+         #xfe01fdf3
+         #x2e8ebf9
+         #xf6030f10
+         #x200fff6
+         #x8151b10
+         #x1c170600
+         #xfbf3fa0e
+         #xa07f9
+         #xfefff7f3
+         #xfae4f2ff
+         #xf50f160d
+         #xb04fbeb
+         #x1016100b
+         #x180e0307
+         #xf5f70312
+         #x10902f7
+         #xfcfaf5f7
+         #xf4eaf9ff
+         #x191205
+         #x1401f2e6
+         #x110e0914
+         #x1005090e
+         #xf7010812
+         #x7fdfb
+         #xfbf6f6f9
+         #xf5f2fbfd
+         #xa170901
+         #xffaedeb
+         #xb060d1e
+         #x706110d
+         #x10a080f
+         #xfc04fc05
+         #xfaf4f9f9
+         #xf9f7f8fb
+         #xe0f0501
+         #x5f5f0f6
+         #x5061a1e
+         #x30b1106
+         #xd0c060a
+         #xfa03ff0d
+         #xf8f3fcf5
+         #xfcf7f6fd
+         #x7070802
+         #xfefaf7fd
+         #x80e1f18
+         #x50d0700
+         #x130a0608
+         #xfb040210
+         #xf3f5fcf1
+         #xfcf6f7fe
+         #x60b00
+         #xfbfc
+         #xf151c0e
+         #x508ff04
+         #x130a0806
+         #xfc030410
+         #xf0f9fbef
+         #xfef6fafd
+         #xff0b0bfe
+         #xa04fbfa
+         #x16141008
+         #x100fd0f
+         #x120e0b02
+         #xfd010612
+         #xf1fbfbf2
+         #xf5fafa
+         #x30d01fe
+         #xf00fafb
+         #x140d090c
+         #xfcfc0918
+         #x151208fc
+         #xfa000715
+         #xf5fdfbf5
+         #x1f4f7f7
+         #x508fc00
+         #xbff00ff
+         #xe080911
+         #xf9001617
+         #x191100f8
+         #xf7000918
+         #xf8fefef6
+         #xfef2f5f8
+         #x303fc01
+         #x4020701
+         #xa070c11
+         #xfb081811
+         #x1a0cf9f6
+         #xf5000b16
+         #xfa0000f3
+         #xfaf1f6fb
+         #xff00
+         #x40a0c01
+         #xc080a09
+         #xe140e
+         #x1606f9f9
+         #xf5010b11
+         #xfc0401f1
+         #xfaf3f8fd
+         #xfe00fefb
+         #xa120d00
+         #xf050304
+         #x30e0f10
+         #x1004fbfa
+         #xf6000a0c
+         #x9fff0
+         #xfef6fbff
+         #xff00f8f9
+         #x10130d01
+         #xcfffc03
+         #x70c0e13
+         #xc05fbfc
+         #xf4000b0a
+         #x809fcf2
+         #xf6fc01
+         #xfefcf2fe
+         #x12121002
+         #x6f8fa0a
+         #x80a1213
+         #xa03fb00
+         #xf4050b07
+         #xd06fbf3
+         #xf6fe07
+         #xfbf6f503
+         #xe131400
+         #x1f5fd0e
+         #x60d150e
+         #x600fd03
+         #xf9090801
+         #xd01fcf3
+         #xfcf9020c
+         #xf6f6fd05
+         #xa1814fb
+         #xf5000b
+         #x5101206
+         #xff0204
+         #xa01fd
+         #x8fffdf6
+         #xfbff070f
+         #xf6fb0200
+         #xd1c0df6
+         #x3f7ff07
+         #x8130905
+         #xfd010501
+         #x605fefe
+         #x1fe00fe
+         #x6090e
+         #xfb0001fa
+         #x121703f7
+         #x5f5fe07
+         #xc110309
+         #xff0504fe
+         #x4ff0202
+         #xfe010405
+         #xb09080a
+         #x103fbfc
+         #x110afefe
+         #x2f3000b
+         #xc0b020d
+         #x20500fd
+         #x1020500
+         #xfe050506
+         #xc020a02
+         #x2fdf80b
+         #x6000301
+         #xf9fc070d
+         #xb040c07
+         #xff08
+         #x30803fb
+         #xfd040505
+         #x4fe0700
+         #x1fdfe0d
+         #xfc040b01
+         #xff030705
+         #x7070d04
+         #xfc020206
+         #x707fbfb
+         #xfa010706
+         #xfe0106fc
+         #x5020106
+         #xfc0c09fe
+         #x80401ff
+         #x80c0b05
+         #xff060103
+         #x702f700
+         #xf8020907
+         #xff0400f7
+         #xb03fe00
+         #x20d0400
+         #xbfe00ff
+         #xa0f090b
+         #x505ff02
+         #x5fffa06
+         #xf7050b05
+         #x300f9f5
+         #xe00f8fe
+         #x307030b
+         #x5f90403
+         #xe110b0f
+         #x9fffc04
+         #x400ff06
+         #xf8050701
+         #x3f8f7f7
+         #x5fcfa01
+         #x2060a0f
+         #xfe0903
+         #x13140c0c
+         #x4f8fc06
+         #x6020101
+         #xf7030200
+         #xfef1fafa
+         #xfefefe03
+         #x50a0d07
+         #x70903
+         #x17130b08
+         #xfdf5ff0b
+         #x70400fb
+         #xf3000000
+         #xf8f1fff9
+         #x60000
+         #xf0d08fb
+         #x3080609
+         #x15110e07
+         #xf8f7000c
+         #x703fdfb
+         #xf2ff0001
+         #xf9f9fef3
+         #x809fbfd
+         #x1106fef7
+         #x2040b16
+         #x13141207
+         #xfaf9ff0c
+         #x402fdff
+         #xf40201ff
+         #xfbf8ef
+         #xa04fa01
+         #x9fef7fb
+         #x3151d
+         #x13191203
+         #xfff7fb0a
+         #x2020102
+         #xf90400fb
+         #x2f4eff0
+         #x400000a
+         #x1fafaff
+         #xc1f19
+         #x191c0c00
+         #xfff2fa0b
+         #x20505ff
+         #xfe03faf7
+         #xfeeaeff6
+         #xfc010c0f
+         #xfffefdfc
+         #x7181e0f
+         #x1e1803ff
+         #xf9effc12
+         #x40905f8
+         #xff00f5f7
+         #xf6e5f4fb
+         #xfc0c130d
+         #x402fbf1
+         #x101b150a
+         #x1b0d0104
+         #xf3f30218
+         #x60b00f4
+         #xfefbf3f8
+         #xeee9fbfe
+         #x4171306
+         #xc01f2e9
+         #x14130d0f
+         #x1005060b
+         #xf4fb0a19
+         #x607f8fa
+         #xfbf6f5fa
+         #xeef2fdfc
+         #x10170c00
+         #xbfbeaee
+         #xf07101a
+         #x7070e0e
+         #xff030c14
+         #x402f704
+         #xf8f5f8f9
+         #xf3f7fcfc
+         #x131007fe
+         #x2f4eafa
+         #x8061a1c
+         #x50d0e0a
+         #xa060a0d
+         #x100fc0e
+         #xf4f6f9f5
+         #xf8f7fafd
+         #xd0908ff
+         #xfcf5f102
+         #x50f1f15
+         #x70f0604
+         #x10050908
+         #x211
+         #xf1f9f8f2
+         #xfaf4fcfd
+         #x5090900
+         #xfffbf801
+         #xb181e0a
+         #x90aff05
+         #xf050a06
+         #x10811
+         #xf0fbf5f1
+         #xfaf3fffb
+         #x30c07ff
+         #x6fffafc
+         #x121a1407
+         #x501ff0d
+         #xe0a0a03
+         #x10811
+         #xf1fcf3f4
+         #xfcf4fff7
+         #x70e0100
+         #xdfff9f9
+         #x14140b0c
+         #xfefc0714
+         #x120f08ff
+         #xfe000b16
+         #xf5fbf4f6
+         #xfcf6fcf5
+         #xb0afd01
+         #x8fdfbfd
+         #xf0b0d13
+         #xf9001415
+         #x180e00fa
+         #xfb000e1a
+         #xf8fdf7f6
+         #xfbf4f9f5
+         #x903fe03
+         #x1000000
+         #xa081012
+         #xfa0a1810
+         #x1a07f9f7
+         #xfa011019
+         #xf900faf3
+         #xf7f3f9f7
+         #x4000001
+         #x2080501
+         #xa09110c
+         #x10130d
+         #x1600f7f8
+         #xf9021014
+         #xfc02faf0
+         #xf6f3fbf9
+         #x10000fe
+         #x90e0600
+         #xc090a06
+         #x510100f
+         #xffff9fa
+         #xf9030e0f
+         #x5f8ef
+         #xf8f5fcfa
+         #x100fbfc
+         #x101107ff
+         #xb030307
+         #x70d1112
+         #xb00fafd
+         #xf9030b0d
+         #x606f6f0
+         #xfbf6fdfd
+         #x2fdf6ff
+         #x121209ff
+         #x5fb000b
+         #x80c1312
+         #xc00f900
+         #xf8050a0b
+         #xc04f6f0
+         #xfaf7ff04
+         #xfff5f702
+         #xf130b00
+         #xfff6030f
+         #x80e150d
+         #xafcfb05
+         #xfc090806
+         #xb01f8ef
+         #xf9f8020b
+         #xf9f3ff04
+         #xe190dfd
+         #xfcf5060d
+         #x9121008
+         #x3fb0006
+         #x30a03ff
+         #x600f8f1
+         #xf8fd080e
+         #xf5f70400
+         #x111c08f8
+         #xfdf80708
+         #xc120a05
+         #xfdff0404
+         #x806fefd
+         #xf9f8
+         #xfe020d0e
+         #xf9ff01fc
+         #x181700f6
+         #xfef70207
+         #x100f0509
+         #xff050301
+         #x701fe00
+         #xfe01fe01
+         #x5050e09
+         #x1fbfe
+         #x190dfcfa
+         #xfdf7010b
+         #x1109060c
+         #x2060003
+         #x1000402
+         #xfd050306
+         #xd040a04
+         #x3fff706
+         #xe02ff00
+         #xf8f8060e
+         #xc040909
+         #x303fd05
+         #x2050100
+         #x4040404
+         #x40707fe
+         #xf8020d
+         #x40501
+         #xf9030a09
+         #x5060dfe
+         #x1ff030c
+         #x707fcfd
+         #x1040504
+         #xfe0603fc
+         #xfffb080a
+         #xff0d05ff
+         #x30605fe
+         #x50a0a01
+         #x30407
+         #x800f701
+         #xfd040707
+         #xff0800f8
+         #x5000601
+         #x60e0002
+         #x70000fb
+         #x80c0809
+         #x6050104
+         #x5fbfa08
+         #xfd070807
+         #x205fbf5
+         #x800ffff
+         #xa09000a
+         #x3fd00ff
+         #xc0e0b0f
+         #xa00fe04
+         #x2fb0009
+         #xfe080605
+         #x3fdf7f5
+         #x5fbfb02
+         #x7040711
+         #xfc000501
+         #x12100e0b
+         #x6fafd07
+         #x2fe0502
+         #xfe070203
+         #xfef6f9f6
+         #xfbfe05
+         #x6070e0c
+         #xfd070600
+         #x15100d06
+         #xfdf6000b
+         #x40003fb
+         #xfd03ff04
+         #xf7f7fef6
+         #x2
+         #x90d0b00
+         #x20b0404
+         #x140f0c02
+         #xf6f80310
+         #x500fff8
+         #xf8fffe05
+         #xf4fcfef2
+         #x603fefd
+         #xf0b00fa
+         #x506080f
+         #x12110f04
+         #xf6fa0410
+         #x400fcfb
+         #xf8000004
+         #xf9fff8ee
+         #xb01fcfd
+         #xa00f900
+         #x2051619
+         #x13170d03
+         #xf9f9010e
+         #x3ff00ff
+         #xfc02ff00
+         #xfffaf2ee
+         #x8fe0003
+         #x1faf905
+         #xd1f16
+         #x191a0800
+         #xfaf5ff0d
+         #x20005fc
+         #x2fafe
+         #xfcf1eff3
+         #xfe090a
+         #xfefcfe02
+         #x6191e0d
+         #x1e1702fd
+         #xf5f00012
+         #x40605f4
+         #x2fff5fd
+         #xf2ebf4f8
+         #xff07120a
+         #x100fcf9
+         #x111f1606
+         #x1c0d0001
+         #xeef2061a
+         #x70800f1
+         #xf9f2fe
+         #xebeef9fb
+         #x5121403
+         #x700f3f1
+         #x17180e0a
+         #x1306020a
+         #xeef80d1c
+         #x907f7f5
+         #xfef5f4ff
+         #xe9f5fcfc
+         #x111611fb
+         #x9fae9f5
+         #x130c1114
+         #x906090f
+         #xf7001217
+         #x800f500
+         #xf8f4f7fe
+         #xeffafcfb
+         #x16110af7
+         #x3f2e801
+         #x9091c17
+         #x60d0b0e
+         #x205110d
+         #x4fafd09
+         #xf4f6f7fc
+         #xf5f9fcfb
+         #x110b07f9
+         #xfdefef0a
+         #x4111f10
+         #xa0f0608
+         #x8040e07
+         #x1fb060c
+         #xf3f9f5fa
+         #xf7f6fffa
+         #x80a07fc
+         #xfdf3f809
+         #x81d1e09
+         #xe0a0004
+         #x7060d05
+         #xfe0c0b
+         #xf4faf1f9
+         #xf7f600f7
+         #x70d05fe
+         #x3f9fb01
+         #x111f1304
+         #x8010008
+         #x60a0b05
+         #xff000d0d
+         #xf6f9effa
+         #xf6fa00f3
+         #xb0d02ff
+         #x7fbfafd
+         #x15190b09
+         #xfd080f
+         #xb0e0801
+         #xfe010d12
+         #xf9f6effb
+         #xf7fbfcf1
+         #xe08ff00
+         #x7fbf8fd
+         #x130f0e12
+         #xf9011212
+         #x120d02fc
+         #xfc011218
+         #xfbf7f2fa
+         #xf7fbf9f3
+         #xc020100
+         #xfdfb03
+         #xd0b1512
+         #xfb0a140f
+         #x1505fbf7
+         #xfb031717
+         #xfbfaf5f7
+         #xf6f8f8f5
+         #x7000400
+         #x20005
+         #x90d160c
+         #x11110c
+         #x11fef7f7
+         #xfb051811
+         #xfdfef5f4
+         #xf4f7f9f7
+         #x20003fd
+         #x7080203
+         #xa0f0f06
+         #x7110e0c
+         #x9fbf8f9
+         #xfb06140c
+         #x100f2f3
+         #xf4f8fbf7
+         #x201fffb
+         #xf0b0201
+         #xa0b0707
+         #x80f110f
+         #x5fdf9fd
+         #xfc060f0b
+         #x600f1f3
+         #xf6fafbfa
+         #x3fcfbfc
+         #x120c0301
+         #x602050d
+         #x80f140f
+         #x7fdf900
+         #xfd060d0d
+         #xbfff2f1
+         #xf7fafc00
+         #xf6fc00
+         #x11100502
+         #xfb0811
+         #x911140b
+         #x8f9fa03
+         #xff080c08
+         #xbfef2f0
+         #xf6fb0009
+         #xf8f30100
+         #x11130501
+         #xfafa0b0e
+         #xb131006
+         #x2f70006
+         #x3090800
+         #x6fef2f1
+         #xf7fd070d
+         #xf4f806fe
+         #x171804fd
+         #xf9fd0909
+         #xe120b04
+         #xfcfa0406
+         #x90601fd
+         #x2fef2f8
+         #xfa020e0c
+         #xf5fe04fa
+         #x1e14fff8
+         #xf8000409
+         #x120e0803
+         #xfb020506
+         #x701fe00
+         #xfff601
+         #x61007
+         #xfd01fdfc
+         #x1e0bfaf9
+         #xf8fd020e
+         #x10080a06
+         #x2050108
+         #x3ff0004
+         #x100fc06
+         #x5080d01
+         #x2fef904
+         #x1502fcfe
+         #xf6fd0512
+         #xc050d03
+         #x601ff0d
+         #x1030203
+         #x4040306
+         #x60707ff
+         #xf8fe0d
+         #x5010201
+         #xf6000b0e
+         #x6050fff
+         #x3ff000e
+         #x403ff00
+         #x6030503
+         #x20b0000
+         #xf9fa0e07
+         #x2070301
+         #x70902
+         #x30c07fb
+         #xff010a08
+         #x700fa01
+         #x2040606
+         #x10afefe
+         #xfc010d00
+         #x90b0001
+         #x606fffa
+         #x60c0503
+         #x4040604
+         #x4f9fb08
+         #x1060709
+         #x406faf9
+         #x20204fe
+         #xf05ff08
+         #x200fbff
+         #xa0c0a0b
+         #x9020003
+         #xfff7030a
+         #x3080708
+         #x400f7f7
+         #x3ffff00
+         #xc00060f
+         #xfd00ff03
+         #xe0d0f0a
+         #x7fdfe06
+         #xfcfc0903
+         #x5060406
+         #xfbf6f7
+         #xfffb0004
+         #x5040f0d
+         #xfc060103
+         #x120f1001
+         #xfdf8000c
+         #xff0006fa
+         #x3020105
+         #xf8faf8f8
+         #xfefd0302
+         #x70c0e05
+         #x30a0102
+         #x120e0cff
+         #xf4f80411
+         #x10100f4
+         #xff0006
+         #xf500f9f5
+         #x20003fb
+         #xc0d0500
+         #x8060408
+         #x100f0801
+         #xf3fc0812
+         #x2fffcf6
+         #xfdfd0107
+         #xf903f5f2
+         #x700fff8
+         #xd05fb03
+         #x5040f12
+         #x11130a04
+         #xf6fe080f
+         #xfdfef9
+         #xfeff0005
+         #xfefef0f0
+         #x4fcfffc
+         #x5fbfb0b
+         #x10f1c13
+         #x19180600
+         #xf7fb040e
+         #x3f8
+         #x1fffd02
+         #xfdf6eef3
+         #xfd0603
+         #xfef90009
+         #x41b1e0b
+         #x1f1400fd
+         #xf3f60213
+         #x10404f1
+         #x4fcf800
+         #xf5f0f1f8
+         #xfe041005
+         #xfffe0000
+         #x131f1504
+         #x1d0cfe00
+         #xecf5081b
+         #x508feec
+         #x2f6f601
+         #xecf2f6fc
+         #x40f14fe
+         #x400f7f9
+         #x1a1c0d05
+         #x1305ff08
+         #xeafa111e
+         #x904f5ee
+         #xfff2f602
+         #xeaf7f9fe
+         #xe1511f5
+         #x7f9edfc
+         #x19110e0c
+         #xb050411
+         #xf0021718
+         #x8fff4f7
+         #xf9f2f803
+         #xeffbfbfe
+         #x14130af0
+         #x5efea07
+         #xd0c1712
+         #x90b0911
+         #xfa08160d
+         #x4f8fc00
+         #xf5f4f903
+         #xf5fafcfb
+         #x110f04f2
+         #xfee9f210
+         #x6161e0d
+         #xd0d080a
+         #xa1106
+         #xfef70703
+         #xf5f7f601
+         #xf7f9fef8
+         #xc0d02f7
+         #xfaecfc0f
+         #x91f1a06
+         #xf080404
+         #xa0d06
+         #xfafc0d03
+         #xf8f6f200
+         #xf5fb00f6
+         #x90d02fa
+         #xfcf40007
+         #x131f1004
+         #xb010205
+         #xd0b08
+         #xfb020d05
+         #xfbf3f0ff
+         #xf4fefdf3
+         #xd0c01fb
+         #xf9fd00
+         #x1a1c0b08
+         #x1fe070b
+         #x60f0805
+         #xfc040d0c
+         #xfcf0f1ff
+         #xf601f9f2
+         #x100801fb
+         #xf9f903
+         #x18110d0e
+         #xfa010d10
+         #xe0e03fe
+         #xfc051114
+         #xfbeff4fd
+         #xf801f5f4
+         #xc0203fc
+         #xfff9f908
+         #x100c1510
+         #xfd0b1110
+         #x1207fdf7
+         #xfb061914
+         #xfaf3f5fa
+         #xf8fdf5f6
+         #x50005fb
+         #xfffcfd0b
+         #xb11170b
+         #x4110f0c
+         #xdfef8f6
+         #xfb0a1c0d
+         #xfcf6f5f7
+         #xf7faf6f8
+         #x20205fa
+         #x4000108
+         #xb141305
+         #x9110c0b
+         #x4faf7f9
+         #xfd0d1806
+         #xf9f2f6
+         #xf5fbf8f8
+         #x20302f8
+         #xb040204
+         #xd120906
+         #xb0e0e0c
+         #xfbf8fd
+         #xfe0c1105
+         #x4f8f0f6
+         #xf6fcf7fb
+         #x300fff8
+         #xf060103
+         #xa09070d
+         #xa10120c
+         #x1fcf800
+         #xff0a0f08
+         #x7f7f0f5
+         #xf7fcf801
+         #xfafff9
+         #x10080205
+         #x4020b11
+         #xb14120a
+         #x3f9f901
+         #x91007
+         #x8f8f0f3
+         #xf8fcfe08
+         #xf8f602fa
+         #x110c0405
+         #xfc000d10
+         #xf160f05
+         #xfff5ff04
+         #x3090eff
+         #x6f8eef4
+         #xf8fd050d
+         #xf2fa05f9
+         #x180f0400
+         #xf8040c0c
+         #x11120a01
+         #xf7f90406
+         #x60807f9
+         #x3f7eefa
+         #xfa010c0b
+         #xf40102f8
+         #x1e0e00fa
+         #xf905050e
+         #x110d0800
+         #xf6000609
+         #x70300fc
+         #x3f7f002
+         #xfe080f07
+         #xfb03fef9
+         #x1f08fcf7
+         #xfa030112
+         #xf0a0afe
+         #xfe04040c
+         #x2ffff03
+         #x4f8f807
+         #x10c0b02
+         #xfffbff
+         #x1701fbfb
+         #xf9ff0519
+         #xa080dfd
+         #x501030f
+         #x105
+         #x5fb0006
+         #x40d0500
+         #xf90006
+         #xafffe01
+         #xf8000c15
+         #x5090cfa
+         #x4fd0510
+         #x2030001
+         #x7020503
+         #x30b0100
+         #xfaf80b0a
+         #x1050202
+         #xfc050c07
+         #x30a09f9
+         #xff090c
+         #x400feff
+         #x2040603
+         #x706ff05
+         #xf7060e02
+         #x90501fe
+         #x5090300
+         #x70b00fe
+         #xff070b02
+         #x1fafd05
+         #x2050708
+         #x804fd00
+         #xff0a06fe
+         #xf030000
+         #x502f900
+         #x90a0506
+         #x6060300
+         #xfcf80409
+         #x4060808
+         #x800f8fd
+         #x204ff00
+         #xcff0607
+         #xfffb08
+         #xc0c0e06
+         #x6000004
+         #xf9fc0a04
+         #x6050705
+         #x3fcf6fd
+         #xffff03
+         #x4010e0a
+         #xfe000009
+         #xf0f0e00
+         #xfffa0009
+         #xf90109fa
+         #x6030601
+         #xfdfaf5fd
+         #xfcfe0401
+         #x20b1105
+         #x3050105
+         #x101009fd
+         #xf5fa0510
+         #xff0400f3
+         #x2000402
+         #xfafdf6fd
+         #xfe0105fb
+         #xa0f0901
+         #x9040106
+         #x100e0400
+         #xf3fe0a12
+         #x101f9f4
+         #xfffe0504
+         #xfc00f4fa
+         #x20201f5
+         #xf080104
+         #x803080b
+         #x100e0305
+         #xf6010c0f
+         #xfefaf7
+         #xfdfe0405
+         #x1fff1f6
+         #x2fefdf8
+         #xafdff0c
+         #x20a1310
+         #x15110504
+         #xf900080d
+         #xfefffef6
+         #xfefe0203
+         #x1f7eef6
+         #xfefd0000
+         #xfffa050b
+         #x51a180b
+         #x1d1100fe
+         #xf5fc0514
+         #xfe03fff1
+         #x1fbff00
+         #xfaf2effb
+         #xfc030901
+         #xfcfe0704
+         #x121f1404
+         #x1d0afcff
+         #xeff9081c
+         #x308fae9
+         #xf6fc00
+         #xf1f1f400
+         #x10d10fc
+         #xfefd
+         #x1e1d0b02
+         #x1403fc08
+         #xeafc131f
+         #x906f1e9
+         #xfbf3fb02
+         #xeff5f801
+         #xb150df2
+         #x4faf5ff
+         #x1d130a07
+         #xb020112
+         #xed061a19
+         #x9fdeff0
+         #xf6f2fc06
+         #xf2f8fb00
+         #x121605ed
+         #x3eff108
+         #x130f100c
+         #x9050715
+         #xf60e190e
+         #x2f6f6f9
+         #xf3f3fd08
+         #xf7f9fdfd
+         #x1313feef
+         #xfce7f811
+         #x917170d
+         #xd090a0d
+         #xfd101108
+         #xfaf801fe
+         #xf4f5fc06
+         #xf8fafef9
+         #x100efcf4
+         #xf4eb0211
+         #xe1f1607
+         #x10060704
+         #x100b0a
+         #xf70006ff
+         #xf7f3fa03
+         #xf7fdfdf6
+         #xe0cfdf8
+         #xf3f4070a
+         #x161f1003
+         #xb010402
+         #x110090d
+         #xf8060601
+         #xfaf0f7ff
+         #xf600faf6
+         #x100b00f7
+         #xf7fb0205
+         #x1e1a0905
+         #xff040b
+         #x710090b
+         #xfc080709
+         #xf9edf8fd
+         #xf903f6f7
+         #x100801f6
+         #xfbfbfc07
+         #x1d110d0a
+         #xfc020911
+         #xf0f0401
+         #xfd080b11
+         #xf5edf9fb
+         #xfc01f4f8
+         #xd0501f6
+         #xfcf7fc0d
+         #x160e150c
+         #xfd090c14
+         #x1208fef9
+         #xfe0b1512
+         #xf4f0f9fa
+         #xfefef5fa
+         #x60303f8
+         #xfdf7ff0f
+         #xd121608
+         #x50f0c0f
+         #xe00f7f6
+         #xfe0f190a
+         #xf5f3f8f8
+         #xfcfaf6f9
+         #x20501f9
+         #xfb030a
+         #xd191104
+         #xc0e0b0b
+         #x3faf5fb
+         #xff131603
+         #xfaf4f5f6
+         #xfafaf7fa
+         #x20600f7
+         #x4000505
+         #x11170b06
+         #xc0c0c0a
+         #xfef9f6ff
+         #x3150f00
+         #xfff3f3f6
+         #xf9fbf7fd
+         #x405fef6
+         #x9020304
+         #x100e080c
+         #xb0e0e0c
+         #xfefaf801
+         #x3100c03
+         #xf2f2f6
+         #xfafaf702
+         #x1fffdf6
+         #xb030306
+         #x9070d11
+         #xd130e0a
+         #xf9f802
+         #x20d0f03
+         #xf3f1f6
+         #xfbf9fc08
+         #xfbfdfff7
+         #xd050506
+         #x1061011
+         #x12150c06
+         #xfdf7fb04
+         #x20c11fc
+         #xf3eff6
+         #xfbfa050d
+         #xf5ff00f7
+         #x13090701
+         #xfe090d0e
+         #x14120900
+         #xf4f80007
+         #x50d0af5
+         #xf2eefc
+         #xfb000c0b
+         #xf604fff7
+         #x190a04f7
+         #xfe0a0712
+         #x130d07fd
+         #xf200050c
+         #x60900f6
+         #xf0f002
+         #xfd070d07
+         #xfc05fbf8
+         #x1907fff3
+         #x5061a
+         #xe0a06fa
+         #xfa05060e
+         #x303fcff
+         #xeff806
+         #x10e0905
+         #x201fafc
+         #x1401fbf7
+         #xffff0a1d
+         #x90a07fa
+         #x204070f
+         #x3
+         #xf40106
+         #x60f0404
+         #xfffbff00
+         #xafffcff
+         #xfcff111c
+         #x70c05f9
+         #x2000a0e
+         #x300
+         #xfb0502
+         #x80b0005
+         #xf9fb0702
+         #x3000001
+         #xfd041311
+         #x60e01f7
+         #xfe000e09
+         #x30100fe
+         #x3030602
+         #x7080005
+         #xf5021003
+         #x5060200
+         #x1090802
+         #x70c00fc
+         #xfd060e04
+         #x1fdfe01
+         #x1060605
+         #x9000305
+         #xff0f0404
+         #xb0200f7
+         #x705ff06
+         #xb07ff03
+         #x40b0501
+         #xfcf90208
+         #x3070806
+         #x8feff01
+         #x70bfe04
+         #xaff01fe
+         #x3fbfd0d
+         #xb090706
+         #x8050002
+         #xf7fd0a05
+         #x5070901
+         #x5fafa01
+         #x502fe06
+         #x1010a04
+         #xfa030e
+         #xe0e0b02
+         #x1fe0008
+         #xf90409fc
+         #x40608fe
+         #xf7f903
+         #xffff0205
+         #xff0a0f03
+         #x1fe0508
+         #x101105fd
+         #xf8fb030d
+         #xfe0700f4
+         #x10406fc
+         #xfdf8f902
+         #xfd0204ff
+         #x6110c00
+         #x7000304
+         #x110e0000
+         #xf4fe0a11
+         #x204f8f4
+         #xfd0205ff
+         #xfffaf900
+         #x400f9
+         #xe0d0500
+         #x7000408
+         #x100b0006
+         #xf8030d10
+         #x1fff5f8
+         #xfc020601
+         #x2f8f6fc
+         #x202fafa
+         #xc020406
+         #x4060c0e
+         #x120b0306
+         #xfc050b0e
+         #xfffdf8fa
+         #xfc010501
+         #x3f5f4fa
+         #xfffa00
+         #x2fd0909
+         #x414130d
+         #x160b0200
+         #xfc010612
+         #xff01f9f4
+         #xfcff03ff
+         #xfef0f3fc
+         #xfd000102
+         #xfa010d03
+         #x121e1105
+         #x1807fd00
+         #xf5fc091c
+         #x205f4ee
+         #xfcfb00fe
+         #xf6eff600
+         #x908fe
+         #xfd0405fd
+         #x1e1c0c01
+         #x1401fa09
+         #xeffe131f
+         #xa04ece9
+         #xf8f7fe00
+         #xf2f1fb02
+         #x91308f5
+         #x2fffbfe
+         #x1f140703
+         #xafeff15
+         #xef071c1c
+         #xafce9ee
+         #xf2f5ff06
+         #xf5f4ff00
+         #x1316fff0
+         #xf3f806
+         #x170e0c09
+         #x8000918
+         #xf7111a11
+         #x3f5edf7
+         #xf0f6000a
+         #xf8f700fc
+         #x1613f7f2
+         #xf8ebfe0f
+         #xe14110a
+         #x9040e11
+         #x15120c
+         #xfaf5f7fe
+         #xf1f60208
+         #xf8f9fff8
+         #x160df4f5
+         #xeeed0811
+         #x111f1306
+         #xb050b06
+         #x6130a0e
+         #xf5fefd00
+         #xf5f60201
+         #xf8fdfdf6
+         #x1309f8f8
+         #xeaf80c0c
+         #x1c1f0f01
+         #x8030505
+         #x80f0912
+         #xf906fd04
+         #xf5f3fffb
+         #xf800f9f7
+         #x1206fbf6
+         #xefff0709
+         #x1f190b00
+         #x100010b
+         #xc0e0a0f
+         #xff08fe0b
+         #xf2f1fdf7
+         #xfd00f6fa
+         #x1106fdf4
+         #xf7fe000c
+         #x1f0f0d02
+         #xfb010416
+         #x120d0804
+         #x2080412
+         #xeef1fcf8
+         #xfef7fb
+         #xd05fdf5
+         #xfaf90010
+         #x170e1205
+         #xff070919
+         #x150900fb
+         #x10a0e13
+         #xecf3fbf7
+         #x2f9f8fa
+         #x705fcf8
+         #xfaf60311
+         #x10151505
+         #x60b0c14
+         #x1000f8f9
+         #x211170c
+         #xeef4f9f6
+         #xf7faf9
+         #x507fdfb
+         #xfbfa090c
+         #xf1c1002
+         #xb0b0b0c
+         #x6f9f4fc
+         #x6171202
+         #xf2f5f7f6
+         #xfdf7faf9
+         #x608fbfb
+         #xfd000905
+         #x15190a04
+         #xb0a0b0b
+         #xfef6f503
+         #x9170aff
+         #xf6f4f4f6
+         #xfcf8f9fb
+         #x706faf9
+         #x20603
+         #x16110908
+         #xa0b0b0d
+         #xfdf7f804
+         #xb140700
+         #xf8f2f4f7
+         #xfcf7fb00
+         #x502f9f8
+         #x5020406
+         #xf0a0d0d
+         #xc100c0e
+         #xfff7fa03
+         #x90f0a01
+         #xf7f2f3f9
+         #xfcf5ff05
+         #xff00faf9
+         #x7030706
+         #x70b120e
+         #x14120b09
+         #xfdf5f905
+         #x6100dfc
+         #xf8f2f1f9
+         #xfbf70507
+         #xfb01fafa
+         #xb060900
+         #x30f100f
+         #x160f0802
+         #xf6f6fc0b
+         #x71208f3
+         #xfaf0f0fa
+         #xfafc0c09
+         #xfc04fafa
+         #x100906f6
+         #x40e0c12
+         #x120a06fe
+         #xf2fc0310
+         #x90ffdf4
+         #xfbedf200
+         #xfc060d07
+         #x4f8f9
+         #x120900f1
+         #x6060b1a
+         #xe0904fc
+         #xf9030712
+         #x807f7fb
+         #xf9ecf902
+         #x10c0a06
+         #x300f8fa
+         #xe05faf4
+         #x3ff111f
+         #xb0a00fc
+         #x105090f
+         #x401fb02
+         #xf6f10103
+         #x80d0606
+         #x2fcfbfe
+         #x900f9fe
+         #xfefe181c
+         #xa0cfffd
+         #x4040c0c
+         #x100
+         #xf6fa0500
+         #xc090407
+         #xfbfc0101
+         #x300fe00
+         #xfc041a14
+         #xc0cfcfb
+         #xff050e08
+         #x10102fc
+         #xf9010600
+         #xb030406
+         #xf6020503
+         #x40101fd
+         #xc1109
+         #xc0afafb
+         #xfc0a0e04
+         #x2fffefe
+         #xff070503
+         #xa000406
+         #xfc0c0704
+         #xa0400f8
+         #x6090103
+         #xb07fc00
+         #x10d0900
+         #xfefdff08
+         #x5070503
+         #x5000501
+         #xb0a0008
+         #x601fcf7
+         #x5fd010c
+         #xa020106
+         #xc08ff05
+         #xf9fd0708
+         #x6090700
+         #x3fc0002
+         #xb03ff09
+         #x10100
+         #xfff50810
+         #xc0a0704
+         #x700fe07
+         #xf9040900
+         #x40906fa
+         #xfff8ff04
+         #x3ff0308
+         #xfd080803
+         #xfdfb0c08
+         #x100e0400
+         #xfdfb020d
+         #xff0901f7
+         #x20903f7
+         #xfcf6ff04
+         #x10403
+         #x4100a00
+         #x1000801
+         #x120cfe00
+         #xf7fd0810
+         #x505f7f5
+         #x700fa
+         #xfcf70001
+         #x10400fe
+         #xe1005fe
+         #x4010304
+         #x1107fe06
+         #xf8030e11
+         #x4fff3fa
+         #xfe0602ff
+         #xfff7fdfe
+         #x403f9ff
+         #xd080401
+         #x202070c
+         #xf060308
+         #xff070c0f
+         #xfaf5fe
+         #xfe060300
+         #xf4fafb
+         #x3fff703
+         #x4020804
+         #x40c0f0e
+         #x10070502
+         #x40a12
+         #xfffcf8fb
+         #xfd0403fe
+         #xfdf0f8fb
+         #xfdfd06
+         #xfb060d02
+         #xf181107
+         #x1206ff00
+         #xfdfe0a1a
+         #x300f3f3
+         #xfb0000fc
+         #xf7eff9fd
+         #x30301
+         #xfd0b09fd
+         #x1d190b00
+         #xe00fa0a
+         #xf4ff131f
+         #x9ffecee
+         #xf8fdfdff
+         #xf3f0fdff
+         #x70d03fa
+         #x306fffd
+         #x1f130600
+         #x9fcff17
+         #xf2071d1c
+         #xbf8e5ef
+         #xf3fafe06
+         #xf3f301fe
+         #x1213fdf4
+         #x2fafb03
+         #x190e0704
+         #x3fc0a1d
+         #xf9131d14
+         #x3f0e7f9
+         #xf0f9020b
+         #xf5f803f8
+         #x190ff4f4
+         #xf7f3000c
+         #x12100d08
+         #x4021115
+         #x416140d
+         #xfbf1ee01
+         #xf0fa0509
+         #xf6fc00f4
+         #x1908f1f7
+         #xecf40811
+         #x13171104
+         #x6060f0b
+         #xc120c10
+         #xf7f8f506
+         #xf2fa0600
+         #xf7fffcf3
+         #x1502f5f8
+         #xe7fe0d10
+         #x1c1c10fc
+         #x5050708
+         #xf0d0c14
+         #xfb00f709
+         #xf2fb03f7
+         #xfa00f9f6
+         #x1200faf7
+         #xee04090f
+         #x1f160bf7
+         #x30010
+         #x100b1010
+         #x201f90e
+         #xeff9fef4
+         #xfefef9f9
+         #xf02f9f5
+         #xf7020411
+         #x1d100af8
+         #xfe02031a
+         #x130b0e06
+         #x6010014
+         #xebf8faf7
+         #x2fafbf9
+         #xc03f7f8
+         #xfcfc0413
+         #x160f0dfe
+         #xff040a1d
+         #x150a05fb
+         #x5030d15
+         #xe9f8f8f9
+         #x2f8fdf6
+         #x903f6fc
+         #xf9f80912
+         #x10160f00
+         #x5070f17
+         #x1102fbfa
+         #x40b140f
+         #xebf8f7f9
+         #xf7fef3
+         #x804f700
+         #xf6fc0d0b
+         #x121c0e00
+         #x9090f0e
+         #x7f9f600
+         #x9151304
+         #xeff8f6f7
+         #xfdf7fcf2
+         #x904f900
+         #xf7010c05
+         #x191c0a00
+         #x9080c0b
+         #xfef3f705
+         #x111809ff
+         #xf2f6f3f9
+         #xfbf8fbf6
+         #xb03fafe
+         #xfc050705
+         #x1b120903
+         #x8090a11
+         #xfbf4fb07
+         #x121303ff
+         #xf3f4f2fc
+         #xfcf7fcfb
+         #xa01f9fc
+         #x40407
+         #x150c0c07
+         #xa0d0b13
+         #xfcf6fc05
+         #x100e0500
+         #xf3f3f2fe
+         #xfbf600fe
+         #x4fff7fc
+         #x2030707
+         #xb0d1009
+         #x100f0b0e
+         #xfcf4fb07
+         #xc0e08fc
+         #xf4f2f1ff
+         #xf9f80700
+         #xfff7fd
+         #x5060901
+         #x912100b
+         #x150d0907
+         #xf7f3fc0e
+         #xb1204f5
+         #xf5eff0fd
+         #xf7fe0a00
+         #xf8fc
+         #x80b07f9
+         #xa110f0f
+         #x12090601
+         #xf3f60116
+         #xf12f9f4
+         #xf6edf2fd
+         #xf9060c02
+         #x300f8fb
+         #xc0cfff3
+         #xb091016
+         #xb070200
+         #xf8fe0916
+         #x1008f2fb
+         #xf2ecf800
+         #xd0b03
+         #x5fdf9fa
+         #xd07f7f9
+         #x601161a
+         #x908ff02
+         #x30c10
+         #xa00f602
+         #xeef1ff02
+         #x70c0a03
+         #x2fbfafc
+         #xa01f500
+         #xff011c18
+         #xb08fc01
+         #x5050c0c
+         #x4feff02
+         #xedfa0301
+         #xc070a02
+         #xfcfcfc02
+         #x5fefb01
+         #xfa0b1f14
+         #xe07fbfe
+         #x2080d09
+         #x10000fe
+         #xf2020200
+         #xb030a00
+         #xfa010006
+         #x40000fd
+         #xfe12170b
+         #xe04fafc
+         #xc0c08
+         #x100fdfe
+         #xfa060200
+         #x80009ff
+         #xff080009
+         #x50300f5
+         #x40f0907
+         #xd01fbfe
+         #x3100807
+         #xfefc05
+         #x2080403
+         #x6000601
+         #x80c0009
+         #x803fdf4
+         #x802010a
+         #xa01ff04
+         #xb0d0204
+         #xfcfd030d
+         #x9070400
+         #x30202
+         #xd010407
+         #x2fff702
+         #xfffb0a0b
+         #x8030406
+         #xe00fe0a
+         #xfb020905
+         #x80903fa
+         #xfefd0104
+         #x6fd0608
+         #xff030008
+         #xf7fe0f06
+         #xd0a0501
+         #x2fb000d
+         #x803fc
+         #x609fff7
+         #xfafa0303
+         #x704
+         #x40a0504
+         #xfa050bff
+         #x110900ff
+         #xfafb0811
+         #x506faf7
+         #x509fcf9
+         #xf9fa0300
+         #x1030301
+         #xe0f0400
+         #x50300
+         #x1003ff02
+         #xf8000d12
+         #x7fff4fa
+         #x405fc00
+         #xfafb01fe
+         #x602fdff
+         #x110a0100
+         #x20309
+         #xc010305
+         #xfe070f11
+         #x1f8f6ff
+         #x305ff01
+         #xfbf9fdfb
+         #x5fdfb02
+         #x8060403
+         #x1060b0e
+         #xb040603
+         #x2070c10
+         #xfef7fa00
+         #x2050000
+         #xf9f6fafb
+         #x1faff05
+         #x90803
+         #x80f1109
+         #xc050201
+         #x20d14
+         #xfbf9f9
+         #x4fffd
+         #xf5f2fafb
+         #xfefe0502
+         #xff0e0800
+         #x17160cff
+         #xc00fb08
+         #xf800141c
+         #x5faf0f1
+         #xfd00fc00
+         #xf1f3fdfc
+         #x40605fd
+         #x70b01fe
+         #x1f1204fe
+         #x5fb0018
+         #xf3091e19
+         #x8f4e8f1
+         #xf9fcfb07
+         #xf0f600fa
+         #xe0cfef7
+         #x601fc02
+         #x1a0d0302
+         #xfb0c1e
+         #xf9141f13
+         #x2ebe5fa
+         #xf5fa010d
+         #xf1fc01f5
+         #x1709f7f5
+         #xfcf9000b
+         #x120c0806
+         #xff001419
+         #x619170d
+         #xf9e9eb04
+         #xf4fc070b
+         #xf401fff1
+         #x1800f5f6
+         #xeffa0714
+         #x14110e01
+         #x1081110
+         #xf13110d
+         #xf5eef20b
+         #xf4000900
+         #xf602faf0
+         #x14fcf7f6
+         #xeb010c17
+         #x1a150ef8
+         #x40a080f
+         #x110c110f
+         #xfaf6f80c
+         #xf30103f7
+         #xfa01f8f3
+         #xdfcfaf5
+         #xf2070b17
+         #x1f1609f0
+         #x3060114
+         #xe0a150d
+         #x1f8fc0e
+         #xf200fbf6
+         #xfffdf9f5
+         #xafef9f6
+         #xfc050917
+         #x1c1204f1
+         #x1041c
+         #xe0e1302
+         #x3f80312
+         #xf0fef7fa
+         #xfbfdf4
+         #xa00f5f9
+         #xff0916
+         #x151103f7
+         #x10e1f
+         #x110e0afb
+         #x1fc0e14
+         #xeffaf500
+         #xfafff0
+         #x900f300
+         #xfbfd0e12
+         #x101606fd
+         #x3051518
+         #x1006fefb
+         #x205160f
+         #xf0f9f5ff
+         #xfdfbfdec
+         #x9fef603
+         #xf500110d
+         #x151b08fd
+         #x608120f
+         #x7fbf800
+         #x70f1505
+         #xf3f7f4fd
+         #xfbfdfbec
+         #xafefb02
+         #xf5060e09
+         #x1b1907fc
+         #x6090d0e
+         #xfdf3fa07
+         #x10150dfd
+         #xf4f5f2fc
+         #xfafdf8ef
+         #x9fefd00
+         #xfa080808
+         #x1f1407fc
+         #x6090913
+         #xf6f3ff07
+         #x161104fb
+         #xf4f3f102
+         #xfafbfaf4
+         #x8fefdfd
+         #x5050a
+         #x190f0900
+         #x80b0b18
+         #xf7f70005
+         #x140b03fd
+         #xf3f1f207
+         #xf9fafff8
+         #x6fdfafe
+         #x204070a
+         #x100f0c03
+         #xc0c0e13
+         #xf8f6fe05
+         #xe0906fb
+         #xf4f0f407
+         #xf6fc02f8
+         #x2fcfafe
+         #x2060906
+         #xd130d05
+         #x100c0c0a
+         #xf6f3fe0d
+         #xd0e03f5
+         #xf4eff304
+         #xf50206f9
+         #x3fbfbfc
+         #x50b06ff
+         #x10130d09
+         #xf090606
+         #xf1f20416
+         #x110ffaf3
+         #xf3edf401
+         #xf70907fb
+         #x3fafcf8
+         #xa0cfefc
+         #x110d100d
+         #xa070207
+         #xf2f90d17
+         #x1406f1f8
+         #xf0edf602
+         #xff0e08ff
+         #x2fafbf8
+         #xe07f6fe
+         #xa071612
+         #x8070007
+         #xfb011210
+         #x10fbf400
+         #xebf1fb07
+         #x70d0afe
+         #xf9fafb
+         #xefff404
+         #x91d13
+         #xa06fe06
+         #x2070f09
+         #x6f7fd03
+         #xebf9ff07
+         #xb0a0bfb
+         #xfdfbfa00
+         #x9fafa04
+         #xfc121d10
+         #xc02ff01
+         #x4090c09
+         #xfc0101
+         #xf1000004
+         #xa080bf6
+         #xfbfefd08
+         #x4fc00fe
+         #xfe1b180c
+         #xc00fffa
+         #x30b0a0c
+         #x100fc01
+         #xfb04ff01
+         #x50608f5
+         #x1000b
+         #x301fff7
+         #x6170e08
+         #x9fefdfa
+         #x70e080c
+         #x1fffa07
+         #x3040002
+         #x20704f9
+         #x804030b
+         #x403faf7
+         #x90a0709
+         #x6fefe00
+         #xe0c050b
+         #xfefcff0d
+         #x9060302
+         #x1040200
+         #xd030309
+         #x401f6ff
+         #x4fc080c
+         #x6000306
+         #x1006000a
+         #xfc00090b
+         #xa0501fd
+         #x30106
+         #x5000a03
+         #x1f9fc0e
+         #xf8030e05
+         #x6050500
+         #x7fc030c
+         #x70700
+         #xa07fef8
+         #xfc000306
+         #xff000a02
+         #x201040b
+         #xf70a09fe
+         #xc0802fa
+         #xfcf90811
+         #x506fef9
+         #xa05f9fa
+         #xf9000303
+         #xff0407ff
+         #xc080402
+         #xff0c00ff
+         #xd0200fb
+         #xf7ff0f13
+         #x6fff7f9
+         #xa02f900
+         #xf9000000
+         #x30302fe
+         #x12090100
+         #x1060007
+         #x9000200
+         #xfb061112
+         #x1f8f7fe
+         #x900fc04
+         #xf900fcff
+         #x5ff00fe
+         #xe050004
+         #x3070e
+         #x5020701
+         #x10a0f0f
+         #xfcf6fc00
+         #x701ff02
+         #xf9fcfafe
+         #xfa0300
+         #x7070406
+         #x40a0e0b
+         #x8050300
+         #x1070e10
+         #xfbf8fefc
+         #x501fe00
+         #xf6f9f9fe
+         #xfbfc0800
+         #x60c0603
+         #xe120d02
+         #x902ff05
+         #xfc051213
+         #xfff9f7f4
+         #x200fb00
+         #xf3f7fbfc
+         #xfe0309fc
+         #xb0d0200
+         #x1a1403fd
+         #x5fbff13
+         #xf50a1b16
+         #xf3ecf2
+         #xfffbfb08
+         #xf1fafdfa
+         #x80802f7
+         #xc04fe02
+         #x1a0c0002
+         #xfdfa0c1e
+         #xfa171f0f
+         #xfdeae7fb
+         #xfbf9000e
+         #xf1fffef7
+         #x1106fbf4
+         #x2fdff0a
+         #x14090306
+         #xfc01171b
+         #x51b1a09
+         #xf5e5eb06
+         #xf7fc0a0c
+         #xf403fbf2
+         #x13fff9f3
+         #xf6fc0615
+         #x110c0b03
+         #xb1413
+         #x10161307
+         #xf1e7f50c
+         #xf6010b02
+         #xf904f7f1
+         #xdfafaf3
+         #xf2010c1c
+         #x16120bf6
+         #x40d0a11
+         #x10101307
+         #xf3edfd0c
+         #xf70505fa
+         #xfd00f5f1
+         #x7fafaf4
+         #xf8060f1c
+         #x1b1504ed
+         #x5070417
+         #xb101606
+         #xf8f1010a
+         #xf804fbf9
+         #xfef7f3
+         #x4fdf8f5
+         #x106101a
+         #x1a14fced
+         #x301071e
+         #x9131501
+         #xfbf3080d
+         #xf9fff500
+         #xfbfbf1
+         #x5fef4fb
+         #x3021216
+         #x1512faf6
+         #x100121f
+         #xc150afb
+         #xf9f81010
+         #xf9faf503
+         #xfefdfbee
+         #x7fbf500
+         #xfd001312
+         #x1312fefd
+         #x1051a18
+         #xe0efffb
+         #xf902170e
+         #xf8f5f703
+         #xfb01f8eb
+         #x6f8fa01
+         #xf605140e
+         #x171402fd
+         #x30a1610
+         #x9fff900
+         #x10e1604
+         #xf8f4f700
+         #xfb02f4ea
+         #x5f8ff00
+         #xf60a0f0c
+         #x1d1504f9
+         #x40b0d0f
+         #xfdf6fc05
+         #xc130ffa
+         #xf7f3f500
+         #xfb00f2ee
+         #x4fa01fe
+         #xfd0b0a0d
+         #x1f1203f7
+         #x5090917
+         #xf4f50105
+         #x131105f6
+         #xf6f0f406
+         #xfcfff3f1
+         #x3fc00fc
+         #x107070e
+         #x1b0f02fa
+         #x6090b1c
+         #xf2f90302
+         #x120a02f8
+         #xf4eef60e
+         #xfafdf8f4
+         #x2fcfffc
+         #x304080d
+         #x141005ff
+         #xa0b1118
+         #xf5fb0003
+         #xe0803f8
+         #xf3edf90f
+         #xf8fffdf5
+         #x1fbfefc
+         #x2060b0a
+         #x11130801
+         #xd0c0f0f
+         #xf4f6ff0a
+         #xb0b02f4
+         #xf3eefb0a
+         #xf704fef5
+         #xfafff9
+         #x40b0705
+         #x14130903
+         #xd0a080a
+         #xf0f40612
+         #x110cfbef
+         #xf1edf907
+         #xfb0900f8
+         #xfa00f6
+         #xb0c0003
+         #x150f0c06
+         #x908020d
+         #xecf91113
+         #x1404f4f1
+         #xeeedf708
+         #xc02f9
+         #xfffafdf6
+         #x1005fa05
+         #xf0d100b
+         #x705010f
+         #xf103160c
+         #x10f8f4fb
+         #xeaeffa0e
+         #x80d06f8
+         #xfdfbfaf9
+         #x11fcf907
+         #x410150f
+         #x904020b
+         #xfc0b1206
+         #x4f3fd01
+         #xebf4fe11
+         #xb0c08f4
+         #xfbfbf900
+         #xaf7ff05
+         #x191811
+         #xa010401
+         #x20c0c08
+         #xfdf80203
+         #xf2fa000c
+         #xa0d06ef
+         #xfcfbfc07
+         #x3f80100
+         #x41f160e
+         #x80002f9
+         #x40b0a0d
+         #xfcfeff03
+         #xfcff0005
+         #x60f01ef
+         #xfffd020a
+         #xfa
+         #xc1c0f0a
+         #x3fffef7
+         #x70b0b0f
+         #xfefc09
+         #x4000002
+         #x40dfdf4
+         #x3000708
+         #x302f9fb
+         #x11110b08
+         #x1fefcff
+         #xe0b0a0d
+         #xfffbff10
+         #x8000002
+         #x30afcfd
+         #x7000905
+         #x5fef503
+         #xa050a09
+         #x1ffff05
+         #x1106060a
+         #xfcfd070f
+         #xa050200
+         #x1060004
+         #x7000a04
+         #x2faf70b
+         #xfc000d07
+         #x4030404
+         #xdff020b
+         #xfd050c03
+         #x80300fb
+         #x201030a
+         #x60800
+         #xfef8060b
+         #xfb0e0902
+         #x70602f7
+         #xfdfd0a0b
+         #x40904f9
+         #xa01fafa
+         #xfe020408
+         #xff0707fd
+         #x4020904
+         #x11000ff
+         #xa04fef5
+         #xf5ff1011
+         #x602fbf6
+         #xbfef900
+         #xfd030006
+         #x20704fb
+         #xd060300
+         #x606fc07
+         #x600fffc
+         #xf7071311
+         #x2faf8fb
+         #x8fcfc04
+         #xfd02fe06
+         #x30201fa
+         #xe040003
+         #x300030f
+         #x3000200
+         #xff0d120e
+         #xfaf7fc00
+         #x6fd0003
+         #xfdfefb05
+         #xffff03fc
+         #xa030307
+         #x1040d0f
+         #x4040300
+         #x30c0f0b
+         #xf7f900ff
+         #x5ff0000
+         #xfafafb04
+         #xf9ff07fc
+         #x9060705
+         #x80f0c07
+         #x7030001
+         #x9100e
+         #xfafcfcf8
+         #x4fefeff
+         #xf7f9fb02
+         #xfa0307f9
+         #xd090500
+         #x12120302
+         #x5fe000c
+         #xfb0c150f
+         #xfdf7f1f4
+         #x2fafd04
+         #xf4fafbff
+         #x20904f6
+         #x110600ff
+         #x180dfe05
+         #xfefb0a18
+         #xfc161b0e
+         #xf9ede8fc
+         #xfdf80209
+         #xf4fffafb
+         #xb07fef3
+         #x800ff07
+         #x1405020a
+         #xf901181b
+         #x81e1905
+         #xf2e5ec07
+         #xf7fb0b09
+         #xf802f8f7
+         #xe00faf0
+         #xfdfd0413
+         #x10070805
+         #xfd0c1716
+         #x121b1301
+         #xebe4f70d
+         #xf6020e01
+         #xfd01f5f5
+         #x8fcf9f1
+         #xf9000e1a
+         #x110e09fa
+         #x6100e13
+         #x12141001
+         #xeaea010b
+         #xfa0708fa
+         #x1fef3f3
+         #x2fcf7f3
+         #xfe05151b
+         #x161400ef
+         #x9090a17
+         #xb141202
+         #xeef00607
+         #xfd06fff9
+         #x1fbf4f3
+         #xfef5f8
+         #x3071716
+         #x1912f5f0
+         #x6010d1c
+         #x8191201
+         #xf1f40709
+         #xff00f8ff
+         #xfbf6f2
+         #x3fef3fc
+         #x4061812
+         #x180df2f8
+         #x161d
+         #xd1c0afd
+         #xf0fa0d0f
+         #xfff7fa02
+         #xfdfff5f1
+         #x4f9f5ff
+         #xfe08180e
+         #x1609f7ff
+         #xff071c17
+         #x1313fefd
+         #xf204130f
+         #xfbf2fd01
+         #xfd02f2f0
+         #x3f6fc00
+         #xf90b150e
+         #x1809fefe
+         #x10e1711
+         #xf04f800
+         #xfb0f1507
+         #xf8f3fefc
+         #xff02eef0
+         #xf602fe
+         #xfa0f120e
+         #x1d0c02f9
+         #x40e0d14
+         #x1f9fc03
+         #x8150efb
+         #xf6f2fafd
+         #xffedf2
+         #xfefa04fc
+         #x10e0d0e
+         #x1e0efff5
+         #x60a091a
+         #xf6f80103
+         #x111304f3
+         #xf4f0f905
+         #xfbeff4
+         #xfefe02fb
+         #x6090b0e
+         #x1b0dfdf7
+         #x6080e1f
+         #xf2fd0301
+         #x120cfef4
+         #xf3edfb0e
+         #xfffbf3f4
+         #xff00fc
+         #x6040c0e
+         #x160efefd
+         #x809131c
+         #xf5ff0000
+         #xc08fef6
+         #xf0ed0011
+         #xfcfef6f4
+         #xfffdfffb
+         #x2070e0a
+         #x140f0100
+         #xb0c1314
+         #xf6fafe07
+         #xa09fff4
+         #xefef030d
+         #xfb02f9f5
+         #xfefc00f8
+         #x40a0c07
+         #x160f0401
+         #xc0c0c10
+         #xf1f7030e
+         #xd0afbec
+         #xeef10109
+         #x5faf6
+         #xfcfcfff5
+         #xa0b0506
+         #x160e0601
+         #xb080512
+         #xebfb0f10
+         #x1205f4ea
+         #xebf0fd0b
+         #x506fdf7
+         #xfafefbf5
+         #x10050005
+         #x110e0907
+         #x9040614
+         #xec07160a
+         #xefaf2f1
+         #xeaeffc13
+         #xa0800f5
+         #xfbfef7fa
+         #x10fd0004
+         #xa120d0f
+         #x802090f
+         #xf6121205
+         #x1f2f9fd
+         #xeaf00117
+         #xc0b02f0
+         #xfcfdf600
+         #x8f70203
+         #x8191113
+         #x7010904
+         #x1120905
+         #xf9f80002
+         #xf0f50611
+         #xb0f00ec
+         #xfcfbfb06
+         #xfff904fe
+         #xc1d1412
+         #x50105fc
+         #x60c080c
+         #xf8fe0004
+         #xf8fa0607
+         #xa11f9ed
+         #xfdfb0208
+         #xfcff01fc
+         #x141c120c
+         #x201fdfa
+         #x70a0b0e
+         #xfdfffe07
+         #xfffd0400
+         #xa0ef4f4
+         #xfffe0905
+         #xfbfe
+         #x19130e08
+         #xf701
+         #xb0b0e09
+         #xfefb010d
+         #x2fe0201
+         #xa09f5fe
+         #xa03
+         #x4fcf703
+         #x100b0c07
+         #xfb07
+         #xe090b07
+         #xfbfb090f
+         #x4000200
+         #x803fb05
+         #x30901
+         #x3f5fa0b
+         #x5080c08
+         #x2010006
+         #xc030806
+         #xfb010d08
+         #x80301fd
+         #x302020a
+         #x40a01
+         #xfff5020e
+         #xfb0c0a04
+         #x50503fd
+         #x2fd070a
+         #xa09f9
+         #x501fdfa
+         #x201070b
+         #x20a0300
+         #xf9000d02
+         #x70e0301
+         #x803faf7
+         #xf5030f0a
+         #x607fff3
+         #x6fefafe
+         #x2060b
+         #x40a01fc
+         #x30607ff
+         #xc07ff04
+         #x600f8fb
+         #xf40a130e
+         #x4fff8f8
+         #x4fafd03
+         #x100030b
+         #x506fffa
+         #xa050201
+         #x7fe020d
+         #x1fffd01
+         #xfe10130b
+         #xfdfaf9ff
+         #xfa0003
+         #x1fd020b
+         #x103fefb
+         #x9020404
+         #x1ff0b11
+         #x2020001
+         #x6100f08
+         #xf7fbfe02
+         #xfd01fe
+         #xfffa0108
+         #xfc0200fd
+         #x7040802
+         #x30a0e0d
+         #x5040000
+         #x60c0d08
+         #xf9fffdfe
+         #xfe00fb
+         #xfaf90006
+         #xfc0602fb
+         #xa0708fd
+         #xd100608
+         #x4000005
+         #x10c110c
+         #xfcfdf4fa
+         #xfbfffd
+         #xf8faff04
+         #x10a01f7
+         #xd0703fa
+         #x14090009
+         #xfffd0711
+         #x113140b
+         #xfbf3eaff
+         #xfdf90202
+         #xf8fcfd01
+         #x809fef4
+         #xc02ff00
+         #x1302020e
+         #xfa021419
+         #xb1c1505
+         #xf2e7eb0a
+         #xf5fd0b02
+         #xfbfdfafc
+         #x904f9f2
+         #x2ff030c
+         #xe03090b
+         #xff0d1817
+         #x161c10ff
+         #xe9e4f710
+         #xf4050ffe
+         #xfdf7f8
+         #x700f5f3
+         #xfd000d15
+         #xc0a0900
+         #x6101314
+         #x17180cff
+         #xe5ea020d
+         #xf90c09f6
+         #x3faf5f5
+         #x1fff3f7
+         #xfe061914
+         #x1211fff5
+         #xb0b0e14
+         #x10160b02
+         #xe7f30508
+         #x900f3
+         #x2f6f4f4
+         #xfef1fc
+         #x10b1c0e
+         #x170ff3f6
+         #x7031318
+         #xe190a04
+         #xeaf9030a
+         #x400fbf6
+         #xf8f4f6
+         #x2fbf100
+         #x20f1c09
+         #x1905effd
+         #x3191a
+         #x141a0503
+         #xedfe0513
+         #x1f8fdf9
+         #xfefcf3f7
+         #x3f7f500
+         #xff10190a
+         #x17fef602
+         #xfe091c17
+         #x1c14fd00
+         #xf0040c16
+         #xfaf602f6
+         #xfff1f8
+         #xf5fdff
+         #xfd13150c
+         #x15ffffff
+         #x1111515
+         #x1904f900
+         #xf90f100e
+         #xf4f702f2
+         #x2feeff7
+         #xfbf701fd
+         #x14130c
+         #x170401f8
+         #x6110d17
+         #xafafb01
+         #x6160dff
+         #xf2f8fdf5
+         #x5f9eef6
+         #xf8fc01fd
+         #x711110a
+         #x1909fdf5
+         #x90b0b1c
+         #xfaf90102
+         #x111502f5
+         #xf1f5fa00
+         #x4f4f0f6
+         #xfb00fffe
+         #x90c1009
+         #x190af8f8
+         #x707111f
+         #xf5ff0201
+         #x140efaf5
+         #xeff1fe0b
+         #x1f4f2f6
+         #xfe01fd00
+         #x7091007
+         #x1708f8fe
+         #x608181e
+         #xf901ff01
+         #xf07f9f8
+         #xecf00511
+         #xfff7f5f5
+         #xfeff
+         #x2091107
+         #x1509fe01
+         #x80d1818
+         #xfcfdfc04
+         #xb07faf6
+         #xeaf4090d
+         #xfffbf6f4
+         #xfefffefb
+         #x30d0f05
+         #x17090000
+         #xb0e1115
+         #xf6f8000b
+         #xc07f7ef
+         #xe9f80809
+         #x2fff8f4
+         #xfc00fcf9
+         #xa0c0a04
+         #x170a0200
+         #xb090b17
+         #xeefc0b0e
+         #xf04f1e8
+         #xeaf6020b
+         #x700fbf4
+         #xfc01f7fa
+         #xf070702
+         #x120b0305
+         #x8030b18
+         #xec08120b
+         #xcfceced
+         #xe9f20213
+         #x900fdf2
+         #xfd00f3ff
+         #xc000600
+         #xe0e060f
+         #x6011113
+         #xf8140e06
+         #x2f5effa
+         #xe9f10716
+         #xa06feee
+         #xfefdf404
+         #x4fe07fd
+         #xe120d14
+         #x4031009
+         #x5140607
+         #xf7f6f903
+         #xebf50e11
+         #xc0dfbeb
+         #xfff9f908
+         #xfbff05fc
+         #x13171513
+         #x3050800
+         #xc0d040a
+         #xf5fefe06
+         #xf1fc1002
+         #xf0ef4ed
+         #xfdf90108
+         #xf80201fc
+         #x1a16160c
+         #x105fc01
+         #xb08090b
+         #xfb00ff07
+         #xf6000afb
+         #x1109f0f4
+         #xfcfd0706
+         #xfd02fdfe
+         #x1b141205
+         #x201f508
+         #xa0a0d07
+         #xfffe010a
+         #xfa0004fd
+         #x1101f3fd
+         #xfc020706
+         #x3fcfb02
+         #x160f0e05
+         #x2fef70e
+         #xc0d0d01
+         #xfbfc090d
+         #xfd0003ff
+         #xdfcfa03
+         #xff060505
+         #x1f6fe06
+         #xb0c0b07
+         #x2fefe0c
+         #xb0a0902
+         #xf9000f09
+         #x102fd
+         #x8fc0107
+         #x80305
+         #xfbf50606
+         #x40e0a07
+         #x4010201
+         #x4040804
+         #xff080dff
+         #x40300fa
+         #x300070b
+         #x2090303
+         #xf8fd0c05
+         #x3100602
+         #x704fef7
+         #xf9010c08
+         #x60a00f4
+         #x200fbfc
+         #x2030b09
+         #x8070001
+         #xfa0a08ff
+         #xe0602fe
+         #x6fdf300
+         #xf70c0f0a
+         #x703f6f7
+         #xfcfb01
+         #x2010a0b
+         #x907fdfe
+         #x4090200
+         #xafd0205
+         #x1faf706
+         #xff13110b
+         #xfcf600
+         #xfefbff03
+         #x2fe0a0a
+         #x703faff
+         #x7040303
+         #xfd0b0d
+         #xfeff06
+         #x9130e06
+         #xfbfbfb06
+         #xfcfd01ff
+         #xfffc0907
+         #x202fb00
+         #x4030701
+         #x40f0d
+         #x3010002
+         #xc100b05
+         #xfafffe04
+         #xfdff00f9
+         #xfbfb0806
+         #x4feff
+         #x50807fb
+         #x80d0c0a
+         #x501ff01
+         #x80c0c07
+         #xfefff700
+         #xfdfefef9
+         #xf9fc0504
+         #x407fefb
+         #x90a02f8
+         #x1109060b
+         #xff030a
+         #x60f1009
+         #xfff8ef02
+         #xfafc00fd
+         #xf9fc0203
+         #xa08fcf7
+         #xa06fefd
+         #x1100060f
+         #xfb010c15
+         #xc171103
+         #xf7eaee0d
+         #xf5ff0600
+         #xfbfb00ff
+         #xb04f8f5
+         #x5000006
+         #xafe0c0f
+         #xfe0c1617
+         #x171a0dfd
+         #xeae4f915
+         #xf4070bfb
+         #xfff9fef9
+         #x701f3f8
+         #x90d
+         #x8070b05
+         #x7111612
+         #x1b1607fd
+         #xe3e90313
+         #xfa0e08f2
+         #x1f7f9f4
+         #x4fff0fc
+         #xfe08160e
+         #xc0e03fc
+         #xc0d1310
+         #x16130503
+         #xe4f4040e
+         #x30d00ec
+         #xfff6f5f4
+         #x3fcef00
+         #x111b08
+         #x150af7fb
+         #x7071413
+         #x14150508
+         #xeafc0011
+         #x605fcec
+         #xfdf6f3f8
+         #x4f7f301
+         #x2161905
+         #x17fef300
+         #xff081818
+         #x1b150408
+         #xeffe0018
+         #x2fdfced
+         #xfcf8f4fd
+         #x2f3f900
+         #x1191607
+         #x14f5f901
+         #xfe10191a
+         #x1f0e0002
+         #xf301071e
+         #xfafa00ec
+         #xfffaf5fe
+         #xfdf2fdff
+         #x219120b
+         #xff70000
+         #x3161518
+         #x1e02fcff
+         #xfb091016
+         #xf2feffea
+         #x3f7f4fb
+         #xf8f800fe
+         #x717120b
+         #xd0001f9
+         #xa120d19
+         #x10f9fd00
+         #x6110f06
+         #xf0fffaee
+         #x5f2f4f8
+         #xf8fefe00
+         #xd141207
+         #x1006fbf7
+         #xb0b0f1d
+         #xf80002
+         #x121304f9
+         #xf1fbf6fa
+         #x3eff5f5
+         #xfa01fc04
+         #xe101201
+         #x1306f4fb
+         #x706161f
+         #xf8ff0203
+         #x150df9f8
+         #xeff5fb08
+         #xeff6f4
+         #x1fc05
+         #x90e1100
+         #x1503f601
+         #x4091c1e
+         #xfc01ff02
+         #x1205f4fc
+         #xecf5030f
+         #xfcf3f7f3
+         #x100fe03
+         #x4100f00
+         #x1400fb02
+         #x50e1d1b
+         #xfdfc04
+         #xc01f7fb
+         #xe8fa0b0e
+         #xfdf6f7f1
+         #xff00
+         #x3110e02
+         #x14020000
+         #xa111519
+         #xfbf7fe08
+         #xc03f6f2
+         #xe9000a0a
+         #xf8f8ef
+         #xff00fbfe
+         #xa100c01
+         #x14050000
+         #xc0c1119
+         #xf2fa060c
+         #xe01f0ec
+         #xebff050b
+         #x4faf9ee
+         #xff00f600
+         #xe0c09ff
+         #x1207ff04
+         #x806131a
+         #xef050e0c
+         #xcfbe7ef
+         #xedf90511
+         #x4fdfbed
+         #xfff404
+         #xa0707fc
+         #xf07030d
+         #x3031615
+         #xfb110c09
+         #x2f3e6fd
+         #xeaf60b14
+         #x502faeb
+         #x2faf607
+         #x20406fb
+         #x11090c14
+         #x8150f
+         #xc120508
+         #xfaf3ee0a
+         #xe8f9130c
+         #x908f7e9
+         #xf6fc08
+         #xfc0603fc
+         #x140d1410
+         #x20c0c0a
+         #x14090209
+         #xf8f9f90d
+         #xea0214fe
+         #xf0af2eb
+         #xfcf60109
+         #xfa0600fe
+         #x18121807
+         #x40a0009
+         #x10040709
+         #xfdfefe09
+         #xef080cf7
+         #x1401f0f0
+         #xfafc050a
+         #xff03fd00
+         #x19151401
+         #x502f810
+         #xa070c05
+         #xfe0109
+         #xf50803f8
+         #x13faf3f7
+         #xfb02040c
+         #x2fefd00
+         #x16140e00
+         #x4fbfa14
+         #xa0d0b01
+         #xfdfd060c
+         #xf90400fd
+         #xef5fbfd
+         #xff06010f
+         #xf900ff
+         #x10110a04
+         #x3fa0111
+         #xd0e0601
+         #xfa000c0b
+         #xfc0301fd
+         #x7f70200
+         #x307010e
+         #xf8f80500
+         #xa0f0b06
+         #x2fd0408
+         #xa090403
+         #xfc070d02
+         #xff0300f9
+         #x2fd0803
+         #x6070109
+         #xf30009ff
+         #xa0e0a03
+         #x40000ff
+         #x60706
+         #x40c06f7
+         #x203fcf9
+         #x1010a08
+         #x7080004
+         #xf6070aff
+         #xd0a04fe
+         #x6fff6fd
+         #xf80a0c09
+         #x906f6fb
+         #x1fdf901
+         #x1070b04
+         #xa02ff01
+         #x30a0003
+         #xb0100fa
+         #xf4f80b
+         #x4100d0a
+         #x5fef203
+         #xfffbfd05
+         #x1030c06
+         #x900fc02
+         #x7060005
+         #xfd0505
+         #xfcf7000c
+         #xe140d07
+         #xfefaf90c
+         #xfdfc0001
+         #xfe020d03
+         #x6fffc02
+         #x4040304
+         #xfc040e0a
+         #xfffe0304
+         #x12100a03
+         #xfdfcff0b
+         #xfcfffffc
+         #xfb020b01
+         #x4ffff01
+         #x3080400
+         #x20b0f08
+         #x2000100
+         #xe0d0904
+         #xfefe06
+         #xfdfffbf9
+         #xf9020801
+         #x60200fd
+         #x70bfffc
+         #xc0b0b08
+         #x1ff0006
+         #x80d0c06
+         #x1f8f605
+         #xfafefbfc
+         #xf9000701
+         #x903fdf9
+         #xb08fafe
+         #xd030a0c
+         #xfe000711
+         #xb120e03
+         #xfbeef50c
+         #xf700ff00
+         #xfafe05fe
+         #xb02f9f8
+         #x901fc06
+         #x7010e0e
+         #xfe071115
+         #x13160afd
+         #xede5fd16
+         #xf70605fe
+         #xfcfb01f7
+         #x900f4fa
+         #x200040b
+         #x2060f09
+         #x6111611
+         #x1a1404fb
+         #xe2e90617
+         #xfe0d04f3
+         #xfcfafcf2
+         #x7fdf3fe
+         #xff070f0a
+         #x70c0601
+         #xc10150b
+         #x190e0103
+         #xe3f40814
+         #x70effe9
+         #xfbf9f7f3
+         #x5f7f501
+         #x131607
+         #x1208fdfe
+         #x80c130e
+         #x170c040a
+         #xeafc0116
+         #xc07f8e5
+         #xf9f8f3fa
+         #x3f3f901
+         #x41b1206
+         #x14fcf9ff
+         #x10d1416
+         #x1c0e0709
+         #xf2fb021d
+         #x500f7e5
+         #xf9f7f400
+         #xf1fe00
+         #xa1c0f09
+         #xef2fd00
+         #x131519
+         #x1f0b0401
+         #xf6fb0a1f
+         #xfc00f7e7
+         #xfcf5f801
+         #xf9f300fe
+         #xe1a0e0b
+         #x6f500fe
+         #x5171319
+         #x1d0300fc
+         #xfb01151b
+         #xf502f6e8
+         #xf3fcfe
+         #xf6f7ffff
+         #x1218100a
+         #x2ff00fa
+         #xf141117
+         #x10fafefd
+         #x30b170a
+         #xf502f1ee
+         #xf1fbf6
+         #xf6fefc03
+         #x13151102
+         #x706f8fb
+         #xe0b1316
+         #xfff80003
+         #xe100bfd
+         #xf8fdeef9
+         #xfef0f9f2
+         #xfc00fd08
+         #x121410fd
+         #xe05f400
+         #x7071a19
+         #xf7fd0205
+         #x150cfdfa
+         #xf6f6f307
+         #xf9f1f8f1
+         #x1ffff09
+         #xd140dfb
+         #x11fdf605
+         #xb1f1b
+         #xfc000003
+         #x1301f7ff
+         #xf0f5ff10
+         #xf6f3f7f0
+         #x2fe0105
+         #x8140aff
+         #xffafc05
+         #x3121e1b
+         #xfdfe02
+         #xdfdf9ff
+         #xecfc0811
+         #xf7f6f7ed
+         #x1ff0201
+         #x9140901
+         #xefc0001
+         #x9151a1a
+         #xfef7ff04
+         #x8fdfaf6
+         #xed030b0d
+         #xfbf8f6ea
+         #xff00
+         #xc130901
+         #xd01ff00
+         #xd10151b
+         #xf3f70409
+         #x9fef3ee
+         #xf204060d
+         #xfef9f6e9
+         #x200fb01
+         #xf0f08ff
+         #xe02fd03
+         #x80a1819
+         #xf0010b0c
+         #xaf9e8f1
+         #xf4000510
+         #xfffdf6e9
+         #x3fcfa05
+         #xc0c06fd
+         #xe02000c
+         #x20a1b16
+         #xfb0b0d0a
+         #x4f0e300
+         #xf0fb0d12
+         #xf6ea
+         #x2f6fd07
+         #x50b01fe
+         #xe020b10
+         #xe1812
+         #xc0e0806
+         #xfcebeb0e
+         #xea00140b
+         #x504f3e8
+         #xfff40107
+         #x10aff00
+         #x1007150c
+         #x2130e0f
+         #x16070504
+         #xf7eefa12
+         #xe90913ff
+         #xc03f0e7
+         #xfaf60508
+         #x107fd02
+         #x13101803
+         #x70f0411
+         #x11010703
+         #xfaf7020c
+         #xf0100af6
+         #x11fdefe9
+         #xf8fa050c
+         #x403fd01
+         #x141812fd
+         #x905ff13
+         #x7030a03
+         #xfffa0308
+         #xf90e00f8
+         #xff5f2ed
+         #xfa010412
+         #x5fffffe
+         #x141a0bff
+         #x6fb0216
+         #x70b0902
+         #xfefc050b
+         #xff08fcfe
+         #x9f3f8f3
+         #x30416
+         #xfb00fc
+         #x13170703
+         #xf80913
+         #xc0d0404
+         #xfaff090e
+         #x3fdff
+         #xf7fff9
+         #x5030613
+         #xf8fe02fc
+         #x10100905
+         #xfefb0a0c
+         #xf080105
+         #xfc060b09
+         #x2fffa
+         #xfdfe03fc
+         #x702070c
+         #xf40204ff
+         #xf0e0b00
+         #xfffe0306
+         #x8050407
+         #x30b0600
+         #x102fcf9
+         #xfe040700
+         #x8020606
+         #xf7090401
+         #xf0b08f9
+         #x2fdfb05
+         #x1080808
+         #x909fbfa
+         #x201f9fe
+         #x60a04
+         #x9030103
+         #xc0202
+         #xe0500f8
+         #x1f6f609
+         #x10f0c0b
+         #x8fef309
+         #x3f9fb06
+         #x20b0802
+         #x6ff0001
+         #xa04000a
+         #x301fdfe
+         #xf6f4040c
+         #x110f0d06
+         #x1f7f810
+         #xfff90005
+         #xb0902
+         #x4fb0002
+         #x702020a
+         #xfc030606
+         #xf7fb0906
+         #x15100b01
+         #xfdf80210
+         #xfdfcffff
+         #xfe0b0900
+         #x1fc0200
+         #x4050306
+         #xc0d06
+         #xfe0005fe
+         #x110d0700
+         #xfefc040b
+         #xfdfefbfc
+         #xfc0a07ff
+         #x1fe03fc
+         #x8080002
+         #x80f0c04
+         #x1000000
+         #xb0c0803
+         #x1fbff07
+         #xfdfcf8ff
+         #xfc0806ff
+         #x50100f8
+         #xe05fa03
+         #xb0a0a08
+         #xfefe030b
+         #xa0f0a03
+         #xfdf2fc0b
+         #xfbfdfb03
+         #xfc0405fd
+         #x800fbf8
+         #xcfffa07
+         #x5060d0c
+         #xfe030e11
+         #x101308fe
+         #xf0eb0113
+         #xfb010001
+         #xfc0303f8
+         #x8fff8fa
+         #x6fc000c
+         #xa100c
+         #x30c150c
+         #x171102fc
+         #xe3ec0a17
+         #x802f7
+         #xfa00fcf3
+         #x6faf6fd
+         #x20a0b
+         #x40f0b05
+         #xb121506
+         #x170bff01
+         #xe2f60e16
+         #xa0afce8
+         #xf9fff4f4
+         #x3f6fbfe
+         #x20f0e0a
+         #xd090300
+         #xa111009
+         #x15070308
+         #xeafc0a16
+         #xf07f4e2
+         #xf8fbf1fc
+         #xf200fe
+         #xa170d0a
+         #x11fffeff
+         #x4110f12
+         #x16080a07
+         #xf3fa091c
+         #xa01efe3
+         #xf9f6f504
+         #xfaf202fc
+         #x11180a0c
+         #x8f6ffff
+         #x5151118
+         #x1a0a0aff
+         #xf5f7131e
+         #x1ffeee8
+         #xfaf4fc04
+         #xf5f601fc
+         #x17160c0b
+         #xfef900ff
+         #xd171416
+         #x170603f9
+         #xf6fd1d17
+         #xfd00eded
+         #xfbf4fffe
+         #xf3fbffff
+         #x19140f05
+         #xfb01fd00
+         #x12121410
+         #xc00fffd
+         #xfb081f09
+         #xfdffe9f1
+         #xfaf4fef6
+         #xf7fefd03
+         #x181511fd
+         #x107f802
+         #x100b150d
+         #xfcfbff03
+         #x61014fc
+         #x1f8e8fb
+         #xf7f6f9f1
+         #xfcfdff06
+         #x15160df9
+         #xa01f507
+         #x70a1a10
+         #xf5fe0208
+         #xf0d03f8
+         #xfff1ee06
+         #xf4f7f5f1
+         #xfc0506
+         #x121708fa
+         #xef9f80b
+         #x10f1d15
+         #xf9010304
+         #x1003fafe
+         #xf7f0fb11
+         #xf3f8f4f2
+         #xfd0902
+         #x101403ff
+         #xbf5fe08
+         #x3151e18
+         #x0
+         #x9fbfd00
+         #xf1f80614
+         #xf4f9f4ee
+         #xff08ff
+         #x10130402
+         #x6fa0004
+         #xb191b19
+         #xfdfaff00
+         #x4fafff9
+         #xf2010b11
+         #xf7faf2e9
+         #x5fd
+         #x12100502
+         #x6ffff02
+         #x10161918
+         #xf4f80206
+         #x3fcf8ef
+         #xf805080e
+         #xfafbf0e7
+         #x1000000
+         #x130f0600
+         #x800fd05
+         #xb101a17
+         #xeffe090b
+         #x5f8ebf1
+         #xfc010710
+         #xfafceee9
+         #x2fc0001
+         #x100d0300
+         #xafe000b
+         #x40f1c15
+         #xf8080d09
+         #x3eee5fe
+         #xf8ff0c11
+         #xfdffefec
+         #x1f80402
+         #xc0b0001
+         #xafe080e
+         #x1151913
+         #x70c0c03
+         #xfae4ee0d
+         #xf003130d
+         #x300efeb
+         #xfbf60702
+         #x909fd04
+         #x704110a
+         #x7181111
+         #x110707fe
+         #xf3e50011
+         #xef0c1103
+         #x9ffede6
+         #xf6fa0705
+         #xa05fe05
+         #xa101303
+         #xe130a11
+         #xb0207fe
+         #xf2ee0b0a
+         #xf61208fb
+         #xefaece4
+         #xf5fe050c
+         #xb00ff01
+         #xf1b0e00
+         #xd070712
+         #x1040801
+         #xf7f80a03
+         #x10ffcfb
+         #xbf5ece7
+         #xf9000514
+         #x8fd01fe
+         #x151e0500
+         #x6fd0913
+         #x80704
+         #xfafc0607
+         #x706f800
+         #x3f4f0ed
+         #xff010a17
+         #x1fe01fa
+         #x18180304
+         #xfffb0e12
+         #x80b0406
+         #xfaff080d
+         #x700fc01
+         #xfbf8f5f5
+         #x2001013
+         #xfa0000fc
+         #x16110704
+         #xfbff0e0f
+         #xe070306
+         #xfb020c0d
+         #x400fefc
+         #xf800faf9
+         #x401120a
+         #xf803ff01
+         #x130e0aff
+         #xfa00080c
+         #xb020405
+         #x1080806
+         #x300fbf9
+         #xfc04fffc
+         #x4020e04
+         #xfc07ff04
+         #x100e07f6
+         #xfeff000a
+         #x5030706
+         #x8090001
+         #x3fff8fd
+         #x802ff
+         #x4020800
+         #x4070007
+         #xe0b00f4
+         #xfef8fe0d
+         #x5090a08
+         #xa01f405
+         #x4fbf904
+         #x20b0702
+         #x6000202
+         #xa070009
+         #x803fbfa
+         #xf8f2000e
+         #xd0e0d09
+         #x2f6fe11
+         #xf80008
+         #x60c0505
+         #xfe0200
+         #x900050b
+         #xfd05
+         #xf2fd0d06
+         #x13100cfb
+         #xfbf50713
+         #xfcf90203
+         #x50e0503
+         #xfefc03fe
+         #x501060a
+         #xff080706
+         #xf9030afe
+         #x110e06f9
+         #xfbfc0a0d
+         #xfbfcfeff
+         #x40d0400
+         #xfc0003fb
+         #x8040306
+         #x70f0804
+         #x201fc
+         #xc0b04ff
+         #xfefe0609
+         #xfcfafa00
+         #x30b03fe
+         #x200f8
+         #xd02ff04
+         #xb0f0706
+         #xffff0004
+         #xa0c0602
+         #xfcf9000a
+         #xfcf8fc05
+         #x20803fd
+         #x402fbf8
+         #xdfcfe07
+         #x80b080c
+         #xfc000a0b
+         #xe0f0600
+         #xf3f20211
+         #xfdfb0105
+         #x700f9
+         #x5fff9f9
+         #x6f9020b
+         #x30c0d0e
+         #x91208
+         #x140e01fd
+         #xe7f30b16
+         #x103fa
+         #xfe07fbf6
+         #x4fbfafa
+         #xffff080c
+         #x5100e0a
+         #x8111201
+         #x1508fe00
+         #xe3fa1014
+         #x906ffea
+         #xfd04f3f8
+         #xf7fdfa
+         #x90b0c
+         #xc0e0802
+         #xd140d04
+         #x11030106
+         #xea001112
+         #xe05f3e0
+         #xfcfbf000
+         #xfcf600f9
+         #xb100a0c
+         #xe040200
+         #xc130a0f
+         #xf070905
+         #xf1fe1115
+         #xc00ebe2
+         #xfbf4f508
+         #xf6f801f9
+         #x16110a0c
+         #x6fdff01
+         #xb130e14
+         #x100c0bfe
+         #xf2fa1918
+         #x6fbe7ea
+         #xfaf2fe09
+         #xf3fc00fa
+         #x1b0f0e09
+         #xfbfefe03
+         #x10141411
+         #x110b01fa
+         #xef001f13
+         #x3f8e7f0
+         #xf8f50201
+         #xf3fefefd
+         #x1b101100
+         #xf903fb09
+         #x15111607
+         #x904fb00
+         #xf30c1f07
+         #x4f6e7f2
+         #xf7fbfffa
+         #xf7fefe00
+         #x181411f9
+         #x3f90d
+         #x110e1603
+         #xfffffc09
+         #xff1818fa
+         #x6f0e8f6
+         #xf6fdf7f7
+         #xfcfd0102
+         #x16170bf6
+         #x9fef910
+         #x80b1607
+         #xf7ff010c
+         #xb1505f8
+         #x2eaee01
+         #xf4fdf2f9
+         #xfefc0900
+         #x151603fa
+         #xaf4fd10
+         #x212170f
+         #xfa020405
+         #xe08fcfc
+         #xf9eafa0d
+         #xf4fbf2f9
+         #xfdff0dfc
+         #x16130000
+         #x5f3020d
+         #x6191815
+         #xff0201fe
+         #x7fefeff
+         #xf1f20713
+         #xf6f9f2f4
+         #xfb020bf9
+         #x170d0003
+         #xf90309
+         #xf1b1a15
+         #xfffefdfd
+         #xfc01f9
+         #xf3fe0d11
+         #xf8f9f0ed
+         #xfe0406f9
+         #x170c0402
+         #xff0007
+         #x13191b12
+         #xf6fafe03
+         #xfefefcf0
+         #xfa030d0c
+         #xf9faeceb
+         #x303fb
+         #x150b0401
+         #x3fffc0a
+         #x10151c11
+         #xf0fd040a
+         #x1fcefee
+         #xff020b0d
+         #xfaf9e8ed
+         #xff03fd
+         #x130c0301
+         #x6fc000e
+         #x9151d11
+         #xf4050c09
+         #xefe8fa
+         #xfc010d0e
+         #xfdf9e9f2
+         #xfdfb06fd
+         #x11090004
+         #x4fc080f
+         #x8191911
+         #x20d0c00
+         #xf7e4f007
+         #xf604130d
+         #x1f9ecf1
+         #xf9fc07fe
+         #x1004ff06
+         #x1020e0c
+         #xc1b1410
+         #xb0c07fb
+         #xece3030c
+         #xf40d1206
+         #x7f8edeb
+         #xf5000502
+         #xf000204
+         #x30f0e07
+         #x14160f0e
+         #x80701fc
+         #xe8ee0f04
+         #xfd1108fe
+         #x9f6e9e4
+         #xf602030a
+         #xcfe04fe
+         #xc1a0706
+         #x140c0f0e
+         #xff060102
+         #xecfb0efe
+         #x90cfefb
+         #x7f3e5e6
+         #xfa020612
+         #x7ff04f9
+         #x151a0308
+         #xb04110e
+         #xfc080309
+         #xf4000701
+         #xf02faff
+         #xf3e5ef
+         #xfe000d15
+         #x1f8
+         #x1c150309
+         #x100f
+         #x40a0409
+         #xf7000609
+         #xbfbfeff
+         #xfaf6eaf8
+         #x1170f
+         #xfc01fefc
+         #x1c0c0605
+         #xfb040d11
+         #xb060406
+         #xfa020b0c
+         #x4fb00fd
+         #xf9fbf1fe
+         #x51a06
+         #xfd03fd01
+         #x160b08fe
+         #xfc060911
+         #xa020602
+         #xfe060d07
+         #x2fffef9
+         #xfd00f7ff
+         #xff0715ff
+         #x101fe06
+         #x120e04f9
+         #xfe020410
+         #x3030800
+         #x5080503
+         #x3fef9fc
+         #x103fc00
+         #x80bfd
+         #x6010007
+         #x110ffdf7
+         #xfcfd030f
+         #x3070b02
+         #x903fd06
+         #x4f9f903
+         #x4070002
+         #x10504ff
+         #xa000208
+         #xd08f6fb
+         #xf6f8060f
+         #x90b0c02
+         #x5f9fb0f
+         #x2f7fe08
+         #x50c0404
+         #x1000201
+         #xb01040b
+         #x401f902
+         #xf1fa0c0b
+         #x110e0eff
+         #xfbf70c10
+         #xf7fb0506
+         #xb080605
+         #xfe010101
+         #x3020b06
+         #xfe0108
+         #xf7070c01
+         #xf1103f1
+         #xf7fd100f
+         #xf7fd0201
+         #xb0a0602
+         #xfc0200ff
+         #x4030a04
+         #x5090606
+         #x803fb
+         #xe0dfef7
+         #xfa020b0b
+         #xf8fbfe00
+         #xb0904fe
+         #xfe04fdfe
+         #x9030500
+         #xd0d0407
+         #x102fe00
+         #xc090000
+         #xfc00040b
+         #xf9f7fe02
+         #x80802fc
+         #x203f8fd
+         #x8fe0202
+         #xd0b050d
+         #xfe000306
+         #xe0b0400
+         #xf6fa030f
+         #xf9f80402
+         #x60800fb
+         #x500f7fd
+         #x2fb0506
+         #x90a0b10
+         #xfd050d07
+         #x120b01fd
+         #xedf90a14
+         #xfcfe07fa
+         #x407fafa
+         #x3fcf9fc
+         #xfcfe090a
+         #x90d0f0c
+         #x50f0c02
+         #x1306fefe
+         #xe8fe1013
+         #x10402eb
+         #x302f5fc
+         #xfffafcfa
+         #xfd050c0b
+         #xd0f0d05
+         #xd130602
+         #xe01ff03
+         #xed04120e
+         #x905f5e0
+         #x2faf304
+         #xfbfafef9
+         #x70b0b0c
+         #xf0a0500
+         #x1011040b
+         #x9040605
+         #xf202130d
+         #xafee8e2
+         #xfff1f90a
+         #xf6fcfcfb
+         #x120c0d08
+         #x704ff03
+         #x110f0c10
+         #xa0d0801
+         #xf2011811
+         #x7f6e4ea
+         #xfaef000c
+         #xf500fbfc
+         #x170c1102
+         #xfd01fd0a
+         #x1310140b
+         #xe0f0000
+         #xed061f11
+         #x4f0e6ef
+         #xf5f60507
+         #xf801fbfd
+         #x161012fa
+         #xfc01fe11
+         #x140f1601
+         #xd07f707
+         #xf0131d08
+         #x4ede9ed
+         #xf5ff0000
+         #xfbfffdfd
+         #x13150ef4
+         #x2fffe14
+         #x100f11fe
+         #x5fff910
+         #xfd1e13ff
+         #x3eaebed
+         #xf601fa00
+         #xfdfd02fb
+         #x141807f5
+         #x8f90116
+         #xa100e03
+         #xfefc0011
+         #xc1e03f9
+         #xfee6eef6
+         #xf9fef401
+         #xfbfd08fb
+         #x1715fffa
+         #x7f30514
+         #x5120e0c
+         #xfd010609
+         #x120efafd
+         #xf3e7f904
+         #xfaf8f502
+         #xfa020af8
+         #x1a0efd00
+         #xf40811
+         #x9171312
+         #x10402fd
+         #xa01fb00
+         #xebf0050e
+         #xfaf5f7fc
+         #xfb0907f6
+         #x1a090000
+         #xfbfa0710
+         #x111a1811
+         #x201fbfc
+         #xfffe00fd
+         #xedfc100d
+         #xfaf5f4f3
+         #xff0a02f7
+         #x170704ff
+         #xfb00020f
+         #x17191b0b
+         #xfcfbf904
+         #xfd01fcf3
+         #xf6041108
+         #xfbf6edef
+         #x20800f9
+         #x140805ff
+         #xff0010
+         #x14181b0a
+         #xf4fb000c
+         #xfff1ef
+         #xfe060e04
+         #xfcf4e8f2
+         #x20400fa
+         #x12090300
+         #x2fa0212
+         #xe18190c
+         #xf502080b
+         #xf3e8f6
+         #xfd040e08
+         #xfdf0eaf8
+         #xff0103fb
+         #x12080104
+         #xf80812
+         #xe1b190f
+         #xff0b0b02
+         #xf6e6f002
+         #xf907120a
+         #xefeef7
+         #xfa0202fd
+         #x11030203
+         #xfd010c0f
+         #x141c160c
+         #x80e04fe
+         #xe9e50008
+         #xf90e1305
+         #x3f1eff0
+         #xf8050002
+         #xe0006ff
+         #xff0d0c0d
+         #x18171407
+         #x90afd00
+         #xe1f10d04
+         #x1120cfb
+         #x4f3eae9
+         #xfc060009
+         #x90007f9
+         #xb14070e
+         #x160f1305
+         #x305fa08
+         #xe6010afd
+         #xc0d03f4
+         #x2f1e3eb
+         #xff03050f
+         #x10005f5
+         #x1612050f
+         #xd0a1109
+         #x4fe10
+         #xf10802ff
+         #x1102fef3
+         #xfeefe0f5
+         #xff010f10
+         #xfe0401f7
+         #x1d0b070c
+         #x50a0f10
+         #x404020e
+         #xf9050006
+         #xafafff6
+         #xfaede500
+         #xfd03180c
+         #xfd05fdfb
+         #x1c070a07
+         #xb0b14
+         #xa050506
+         #xfb030709
+         #xfb02f7
+         #xfaf0ee05
+         #xfc0b1a02
+         #x2fc00
+         #x160809ff
+         #x90818
+         #x8030600
+         #xfd060c06
+         #xfcfe00f7
+         #xfef4f704
+         #xff1213fe
+         #x300ff02
+         #x120d02fa
+         #x1050817
+         #x20407fe
+         #x2090a01
+         #xfffffbfa
+         #x1f9fc02
+         #x11108fd
+         #x6fe0302
+         #x120dfafb
+         #xff000813
+         #x808fe
+         #x6060203
+         #x1fbfa00
+         #x4fffe03
+         #x30c02ff
+         #x6ff0603
+         #x1207f600
+         #xf9fd0a11
+         #x50c0afe
+         #x5fe010a
+         #xfff6fe06
+         #x7030005
+         #x3060001
+         #x5000704
+         #xcfef706
+         #xf3fe0d0e
+         #xb100af9
+         #xfdf6070f
+         #xfaf90307
+         #xa080507
+         #x10102
+         #x4020907
+         #x2fcff08
+         #xf4030f07
+         #xe1207f1
+         #xf6001010
+         #xf4000401
+         #xc060a00
+         #xff03fe07
+         #x80bff
+         #x606
+         #xc0500
+         #x120cf7f2
+         #xf9070e0f
+         #xf6ff01fe
+         #xc0707fa
+         #x105fb05
+         #x30808fb
+         #x9070506
+         #x506fd00
+         #x1106f9fb
+         #xff07070d
+         #xf7fb00ff
+         #xb0803f9
+         #x502f805
+         #x40404fc
+         #xe06060c
+         #xfe06
+         #xe050000
+         #xfd00050f
+         #xf6f90400
+         #x90700f9
+         #x6fef803
+         #xff000301
+         #xc050c0f
+         #xfe030509
+         #xf0701fd
+         #xf5fd0912
+         #xf50009f9
+         #x905fcfa
+         #x4fbf901
+         #xf9000707
+         #xa09140d
+         #x20b0706
+         #x1105fefb
+         #xf0011011
+         #xfb0704ec
+         #x900f8fc
+         #xfffafaff
+         #xfb050b09
+         #xd0e1104
+         #xd100305
+         #xc01fe00
+         #xf207130b
+         #x208f7e2
+         #x7f8f801
+         #xfbfcfaff
+         #x2090d07
+         #xf0e0900
+         #x130d010a
+         #x6010106
+         #xf8091108
+         #x800e8e2
+         #xeffe0a
+         #xfbfff800
+         #xd0a0e05
+         #xb0a0104
+         #x1109070e
+         #x6090507
+         #xf607110d
+         #x7f3e2e9
+         #xf8f0050d
+         #xfc00f700
+         #xf0d11fd
+         #x304000c
+         #x100b1208
+         #xf0dff09
+         #xf20c1612
+         #x2ebe5ec
+         #xf3f8090b
+         #xfd00f9fe
+         #xd1210f6
+         #x214
+         #x110f12ff
+         #x1305f80e
+         #xf518180f
+         #xfee9ebe7
+         #xf3010607
+         #xfffdfdfa
+         #xe1809f3
+         #x4fc0718
+         #xf110afc
+         #xefafa15
+         #x21f0e05
+         #xfaeaece3
+         #xf902fe05
+         #xfefc01f8
+         #x141901f7
+         #x5f60b16
+         #xa100402
+         #x3f80415
+         #x121d02ff
+         #xf4e9eceb
+         #xfdfcfc08
+         #xfc0004f8
+         #x1a13fcfc
+         #x2f50e14
+         #x810050b
+         #xfe0a0a
+         #x1a11f900
+         #xebe9f2fd
+         #xfef5ff07
+         #xfa0504f8
+         #x1d0afcfe
+         #xfbf90e13
+         #xc120d10
+         #x20406ff
+         #x1202fa03
+         #xe5f0000a
+         #xfcf200fe
+         #xfd0c00f9
+         #x1a0500fc
+         #xf6ff0b15
+         #x1215160b
+         #x502fbfe
+         #x4feff01
+         #xe7fb0b0c
+         #xfaf3fcf3
+         #x30dfcf9
+         #x130403fa
+         #xf9010817
+         #x16181904
+         #x1fbf705
+         #xff01fdf9
+         #xf1061003
+         #xfaf4f3ee
+         #x80afbfb
+         #xf0703fb
+         #xffff0616
+         #x16181703
+         #xf9f7fd10
+         #x201f2f2
+         #xfb0a0d00
+         #xfbf0edf2
+         #x706fdfc
+         #xf090200
+         #xfa0915
+         #x13191507
+         #xf6fd060f
+         #x3f7e9f5
+         #xfd0b0b02
+         #xfbebedf8
+         #x304fefd
+         #xf070202
+         #xfdfa0c14
+         #x121b150a
+         #xfd070907
+         #xfae9ec00
+         #xfa0a0d07
+         #xfbe9f3fa
+         #x6ffff
+         #x10030402
+         #xf9ff0e13
+         #x171c1608
+         #x70e0301
+         #xe9e7fb08
+         #xfc0f1103
+         #xfbedf4f3
+         #x7fc02
+         #xa0307fc
+         #xfc090d12
+         #x1b191401
+         #xd08fb06
+         #xe1f30608
+         #x3120ff7
+         #xfdf1eeee
+         #x105fe07
+         #x30407f7
+         #x70e0b12
+         #x19131100
+         #xb00f711
+         #xe6030504
+         #xd1006ea
+         #xfdf0e4f1
+         #x302050c
+         #xff0702f5
+         #x150b0c12
+         #x10100d05
+         #x7fcfd17
+         #xf40bfc02
+         #xd07ffe6
+         #xfbeae2fc
+         #x100100d
+         #xfe08fef9
+         #x1a060f0c
+         #x810090f
+         #x7fe0412
+         #xff07f906
+         #x600fdea
+         #xf8e4e806
+         #xfe071808
+         #x5fbfd
+         #x18050f03
+         #x70f0819
+         #xa010708
+         #x10009
+         #xfdfffef1
+         #xf7e3f30a
+         #xfe101903
+         #x302fbfe
+         #x120809fd
+         #x80b091c
+         #x8020601
+         #xff040905
+         #xf801fdf4
+         #xf9e9fd06
+         #x2190f00
+         #x5fffffd
+         #xf0d02fd
+         #x7050c1a
+         #x30504ff
+         #x1090901
+         #xfb02fbf7
+         #xfcf00000
+         #x9170400
+         #x3fe02fc
+         #x110cfc00
+         #x2011016
+         #x10804ff
+         #x6090301
+         #xfffef9fd
+         #xfff70000
+         #xd10ff02
+         #x105fd
+         #x1303f802
+         #xfb000f14
+         #x40c05fd
+         #x5020207
+         #xfdf9fd02
+         #x3fc0104
+         #x908ff04
+         #x30600
+         #xffafb06
+         #xf7010f13
+         #xa1005f8
+         #xfffd070c
+         #xf7fa0105
+         #x6000605
+         #x4040005
+         #x50802
+         #x7f70108
+         #xf7050f0e
+         #xe1201f1
+         #xf7fe0f0f
+         #xf4ff0503
+         #xb040a02
+         #x2ff06
+         #x70b01
+         #xfb0507
+         #xfe0b0a04
+         #x110ff9ee
+         #xfb0b0e15
+         #xf90102fb
+         #x80a07f5
+         #x300ff0b
+         #x20d05fb
+         #x1020702
+         #x7090000
+         #x1600f1fa
+         #x20c0b11
+         #xf9ff00fa
+         #x90a01f4
+         #x5fefe0b
+         #x40b00fb
+         #xa030706
+         #x501fb06
+         #xffefa00
+         #x305080e
+         #xf5fe03fe
+         #xa08fef6
+         #x6fafd09
+         #x106ff01
+         #xa020d0a
+         #x10c
+         #xb0100fe
+         #xfe000b0f
+         #xf40106fb
+         #xa05fdf6
+         #x3f8fe07
+         #xfd030206
+         #x8061307
+         #x205060c
+         #xc04fefb
+         #xf601110f
+         #xf70a03f2
+         #xa00fbf7
+         #xfef9fd06
+         #xfc050808
+         #x9101401
+         #xb0a0309
+         #xa01fbfe
+         #xf707130a
+         #x10bf6e9
+         #x7f8fcfc
+         #xfcfbfa06
+         #x1090c05
+         #xd130afd
+         #x1108010a
+         #x400fe05
+         #xfc0b0f06
+         #x902e8e7
+         #xf30002
+         #xfdfdf807
+         #x70c0d00
+         #xe0e0100
+         #x1005060c
+         #x403010d
+         #xfe0b0b0a
+         #x8f2e0ec
+         #xf6f4070a
+         #xfdf804
+         #xa0e0efc
+         #xa06020b
+         #xb070f09
+         #xc08010e
+         #xfb0d0e15
+         #xe8e4eb
+         #xeffc0c0b
+         #x1fcfdfd
+         #x9140bf9
+         #x6000912
+         #xc0e0c02
+         #x1600fd11
+         #xfd151215
+         #xf8e8e9e5
+         #xf2030b09
+         #x1fb00f7
+         #xd1803f9
+         #x5fb0e13
+         #xd110200
+         #x12f60015
+         #x91e100c
+         #xf2ece9e1
+         #xfa040707
+         #xfefb00f4
+         #x1616fcfb
+         #x1fb1312
+         #xd0ffd04
+         #x4f30b14
+         #x181b0601
+         #xeeece4ea
+         #xfd0506
+         #xfb00fff7
+         #x1d0ef9fe
+         #xfdfe1212
+         #xb0a000a
+         #xfdfd110a
+         #x1e0efe00
+         #xe8eae7fc
+         #xfff60703
+         #xfc06fefc
+         #x1e05fbfc
+         #xf7011016
+         #xb0a0a0b
+         #xff060b01
+         #x1600fc04
+         #xe4edf40e
+         #xf9f409fb
+         #x20bfcfd
+         #x1902fff9
+         #xf4050f1a
+         #xf0f1404
+         #x505feff
+         #x8fd0005
+         #xe6f8040f
+         #xf6f904ef
+         #x90afafd
+         #x100300f7
+         #xf9050e1c
+         #x141516fe
+         #x4fbf808
+         #x10000ff
+         #xef040b07
+         #xf7faf9ea
+         #xd06fafd
+         #xa07fffa
+         #xff010f19
+         #x151912fe
+         #xfcf3fd10
+         #x401f8f5
+         #xfa0c09ff
+         #xf8f4f0ed
+         #xd04fbfc
+         #xb07fe01
+         #xfffe1216
+         #x14190f03
+         #xf4f70712
+         #x5f8eef5
+         #xd0501
+         #xf7ebf0f5
+         #x802fcfe
+         #xe060004
+         #xfafd1214
+         #x151a1106
+         #xf9020a0c
+         #xfdebedfe
+         #xc0706
+         #xf4e9f6f8
+         #x503fd00
+         #xd040301
+         #xf7021214
+         #x191b1302
+         #x40a0509
+         #xede6f609
+         #xff0e0d05
+         #xf1edf8f5
+         #x604fc00
+         #x90506fc
+         #xfa081115
+         #x1a1a13fc
+         #xe06fd0d
+         #xe3f1010d
+         #x6120ef5
+         #xf3f3f1f1
+         #x8020002
+         #x30903fa
+         #x40a1214
+         #x18170bfb
+         #xefbfb16
+         #xe900030a
+         #xd1305e5
+         #xf8f1e9f5
+         #x7ff0705
+         #xafdfb
+         #x10081310
+         #x13150403
+         #x9f50119
+         #xf907fe06
+         #xe0efbe0
+         #xf8e8e600
+         #x2ff0f07
+         #x208f9ff
+         #x11061408
+         #xf13020f
+         #x4f70b14
+         #x402fb06
+         #x605f4e6
+         #xf5e1ee09
+         #xfd071606
+         #x605f901
+         #xf0a1200
+         #xf100618
+         #x3fe0e0a
+         #x5fc0007
+         #xfe01f3f1
+         #xf1e0fb09
+         #xff131503
+         #x800fbfe
+         #xd0f0afe
+         #xe0a0c1a
+         #x3030a05
+         #xfd0605
+         #xfa02f6f8
+         #xefe40303
+         #x81c0e00
+         #x7fefef9
+         #xd1000fe
+         #xa041219
+         #x1040504
+         #x60702
+         #xfd02f6f8
+         #xf0f004fc
+         #x11190400
+         #x2fffff8
+         #x100bfc02
+         #x3031615
+         #x1060305
+         #x5090202
+         #x100f6fb
+         #xf5f701fc
+         #x140f0001
+         #xfe0200fc
+         #x1201fe05
+         #xfd041414
+         #x5090301
+         #x8050007
+         #xfffbf900
+         #xfafb0100
+         #x12070003
+         #xfe050002
+         #xef90004
+         #xf9041216
+         #xc0b00fb
+         #x200040d
+         #xf9fbff03
+         #xfffe0601
+         #xa020105
+         #x70204
+         #x5f60404
+         #xfa071215
+         #x110dfdf3
+         #xfb010a11
+         #xf6fe0201
+         #x2020afe
+         #x4010108
+         #x1090501
+         #xfefb0703
+         #xff0b0f0c
+         #x150af4f1
+         #xfa080e15
+         #xf70203fd
+         #x70809f8
+         #x200ff0b
+         #x10c07fc
+         #xfe000703
+         #x60c0502
+         #x1703eff5
+         #x50d1014
+         #xfd00fff8
+         #x80ffdf4
+         #x2fc0709
+         #xa0afd00
+         #x2040401
+         #x903fe01
+         #xdf4f501
+         #x8080e0c
+         #xf9ff00fd
+         #xb0bfaf5
+         #xf9050a
+         #x907fb04
+         #x5030805
+         #x3fc000b
+         #x5fbfe02
+         #x3020e0a
+         #xf5020200
+         #xb05f9f4
+         #xfef8040a
+         #x402ff09
+         #x3080f03
+         #x70c
+         #x601fdfe
+         #xfc03120b
+         #xfa0a00fb
+         #xa00faf2
+         #xfbf9020a
+         #x1020509
+         #x5110fff
+         #x505090a
+         #x701fafe
+         #xf9071409
+         #x40cf7f2
+         #x6fcfaf4
+         #xfafa000b
+         #x2070a04
+         #xc1707fc
+         #xd050608
+         #x4fdfa06
+         #xff0d0f05
+         #xd01eaef
+         #xfff8fdfd
+         #xfdfafe0a
+         #x60b0b00
+         #x111200ff
+         #xc02070a
+         #x2fe000e
+         #x20d0807
+         #xcf2e3f1
+         #xf5fb0305
+         #xf90005
+         #x81008fd
+         #xf070105
+         #x8050a0b
+         #x7010411
+         #x20b0811
+         #xe6e4f2
+         #xf0010a0a
+         #xf702fc
+         #x81405fd
+         #xa000a0c
+         #x80d0a06
+         #x10ff0411
+         #x30e1215
+         #xf3e6e7eb
+         #xf3080d09
+         #xfdf802f3
+         #x1114ff00
+         #x500120d
+         #xe10ff05
+         #xdf70810
+         #xc15170c
+         #xeeebe4e7
+         #xfb070c05
+         #xfcfcfff1
+         #x1b0ffa01
+         #x3130d
+         #xf0bfa06
+         #xfff61110
+         #x191610fe
+         #xedebe0f0
+         #x1020b01
+         #xfa00f9f7
+         #x1f07fa00
+         #xfa081110
+         #xd030008
+         #xf400160a
+         #x1e0d05fb
+         #xece7e103
+         #xfefd0dfd
+         #xfd03f8fd
+         #x1c01fcfc
+         #xf70c0f17
+         #xa020c04
+         #xf80b0e03
+         #x17010000
+         #xe9e5eb14
+         #xf8ff0cf5
+         #x304f900
+         #x1500fef8
+         #xf80b111e
+         #xa0a13fe
+         #x20a0202
+         #x8fb0306
+         #xe8edfe18
+         #xf30406ea
+         #xb05fbfe
+         #xd02fcf7
+         #xfd09151f
+         #xe1312f9
+         #x5fefa07
+         #xfe0501
+         #xeffd080c
+         #xf504fae5
+         #xf01fdfa
+         #x804fa00
+         #x51819
+         #x13180afa
+         #xfdf4fe10
+         #x20000f7
+         #xfb080703
+         #xf8fdf0e8
+         #xcfffdfb
+         #xa05fa07
+         #xff031713
+         #x16180700
+         #xf2f50812
+         #x5fbf4f1
+         #x40a0103
+         #xf6f2eef1
+         #x800fefc
+         #xd02fe0a
+         #xfa061612
+         #x17170a02
+         #xf2000e0f
+         #xffeeeffa
+         #x6080209
+         #xf0edf4f7
+         #x700fefd
+         #xc020207
+         #xf7081413
+         #x19180fff
+         #xff08080c
+         #xf0e7f506
+         #x7090805
+         #xecf2f7f7
+         #x70000fc
+         #x8050302
+         #xfa0b1413
+         #x1a1a0ef8
+         #xa040111
+         #xe5ed000e
+         #x80f0cf7
+         #xedf8f3f6
+         #x7ff02fa
+         #x4090000
+         #x20b1611
+         #x1b1a06f7
+         #xdf90017
+         #xeafa070b
+         #xf1403e5
+         #xf4f5ecf9
+         #x4fd07fb
+         #x608fb04
+         #x90b180d
+         #x1817fe00
+         #x4f30818
+         #xf8010604
+         #x1211f5e0
+         #xf7eaeb01
+         #x1000dff
+         #xa04f806
+         #xb0c1706
+         #x1511fd0c
+         #xfcf71213
+         #x3fe0300
+         #xd07e9e9
+         #xf3e0f309
+         #xfd081102
+         #xcfffc05
+         #x8111000
+         #x140d0514
+         #xf800130b
+         #x3f70500
+         #x5ffe8f8
+         #xebe1ff08
+         #x151101
+         #xafdfefe
+         #x9170600
+         #x13070f14
+         #xfa060d09
+         #xfef90800
+         #x1fced00
+         #xe5e90500
+         #xb1a0dfe
+         #x7fefff8
+         #xd130004
+         #xc051611
+         #xfd06080c
+         #xfd010800
+         #x1fcf3ff
+         #xe5f603f9
+         #x161807fb
+         #x2fffbf9
+         #x110aff06
+         #x2051811
+         #x5060b
+         #x3060202
+         #x5fcf4fc
+         #xecfefffa
+         #x190d05fa
+         #xff01f903
+         #x11000005
+         #xfd091613
+         #x4060605
+         #x7030007
+         #x3f9f600
+         #xf3fffefe
+         #x140505fc
+         #x3fb0b
+         #xbfb0302
+         #xfc0b1417
+         #xa0802fd
+         #x500030e
+         #xfef9fb04
+         #xf9000200
+         #xb020600
+         #x303ff0c
+         #x1fc0600
+         #xfd0b1515
+         #x1108fcf7
+         #xff010914
+         #xfafc0002
+         #xfd0306fd
+         #x5010602
+         #x5050208
+         #xfbff0600
+         #xd150d
+         #x1504f5f4
+         #xfe070d17
+         #xfb0000fc
+         #xa05f7
+         #x3000606
+         #x7090202
+         #xfb030500
+         #x50d0e04
+         #x16fcf0f8
+         #x30d0e16
+         #xfd0100f8
+         #x60f00f4
+         #x2fd0609
+         #x80c00ff
+         #x40400
+         #xa080101
+         #x11f5f1fe
+         #xa0b1708
+         #xfb00fd00
+         #xe09f7f8
+         #xfd000b07
+         #x1001fb06
+         #x2050204
+         #x7ff0003
+         #xfcf4fc06
+         #x5061203
+         #xf9010004
+         #xe04f7f5
+         #xfafe0909
+         #xcfd0009
+         #x1090606
+         #xfffc0808
+         #xfefdff03
+         #xfe061207
+         #xfd060002
+         #xb00f6f0
+         #xf8fe060c
+         #x5fe0707
+         #x4120802
+         #x20d05
+         #x4fffb00
+         #xfc0b1208
+         #x808fbfa
+         #x6fef4f1
+         #xf9fd060d
+         #x3030a02
+         #xc1703ff
+         #x5060a03
+         #x5fcfa04
+         #xf0f04
+         #x1100f0f4
+         #xfffcf4fa
+         #xfbfc070b
+         #x50a09fe
+         #x1512fdff
+         #x7040707
+         #x1fa000d
+         #x60f0703
+         #xff1e9f6
+         #xf8fefb06
+         #xfcfa0904
+         #x80f05ff
+         #x1408ff03
+         #x505080b
+         #x2fd0710
+         #x70a0609
+         #x1e6e9f8
+         #xf403040b
+         #xfbf909fa
+         #xc100202
+         #xd010706
+         #x50a070d
+         #x6ff0b0d
+         #x5080f0e
+         #xf2e5eaf5
+         #xf8090c09
+         #xf9fb05f1
+         #x120fff05
+         #x5030d08
+         #xd0c000a
+         #x5fc0c0b
+         #x90f1b05
+         #xebe8e3f2
+         #xff0a0e01
+         #xf8fefcef
+         #x1c08fe03
+         #xc0d0a
+         #x1206fd06
+         #xf8ff120c
+         #x111418f8
+         #xeee7e0f9
+         #x3080dfb
+         #xf900f5f6
+         #x1e02ff00
+         #xfc100d12
+         #xefd0203
+         #xee07160b
+         #x17110bf3
+         #xf0e3e30a
+         #xff070cf7
+         #xff01f5ff
+         #x18ff00fb
+         #xfe110d1b
+         #x5fd0cff
+         #xf3120e07
+         #x120701fc
+         #xece0ed19
+         #xf90b09f2
+         #x500faff
+         #xe00fef8
+         #xe131f
+         #x3060ff9
+         #x10f0304
+         #x8000205
+         #xe8e3fe1c
+         #xf60f01eb
+         #x8fefffa
+         #x801fafc
+         #x20a191e
+         #x8120bf7
+         #x802fc06
+         #xff000703
+         #xebf30b12
+         #xfa0ff6e6
+         #x9fe00f5
+         #x702f704
+         #x3091d19
+         #x121702f9
+         #xfff6ff0b
+         #x204f7
+         #xf7010905
+         #xfe04ece8
+         #x8fefff6
+         #xb00f90c
+         #xb1c12
+         #x171400ff
+         #xf1f6080f
+         #x2fffaee
+         #x3060204
+         #xfbf8eaf0
+         #x5fffef9
+         #xbfdff0f
+         #xfd0e1710
+         #x18120400
+         #xee000e10
+         #xfff5f0f3
+         #x9030109
+         #xf2f1eff9
+         #x4ff00fa
+         #xaff050b
+         #xfc101412
+         #x19140afb
+         #xf9090b10
+         #xf2ebf301
+         #x9030808
+         #xecf4f4fd
+         #x50002f6
+         #x6020407
+         #xfe0f1512
+         #x1a1808f6
+         #x6060612
+         #xe7ecff0a
+         #x90a0bfa
+         #xedfaf3fc
+         #x5ff03f2
+         #x6060108
+         #x20f180f
+         #x1d1900f6
+         #x8fc0616
+         #xe8f60907
+         #xd1203e7
+         #xf5f8effe
+         #x1ff04f2
+         #x904fd0a
+         #x60f160a
+         #x1e15f8fe
+         #xfef70e18
+         #xf3fe0dfd
+         #x140ff2e3
+         #xf8ecef04
+         #xfd0105f9
+         #xdfefc0b
+         #x7141206
+         #x1c0cfb06
+         #xf2fd1414
+         #xfd000af6
+         #x1504e5ed
+         #xf2e2f70a
+         #xfc0908ff
+         #xdfa0106
+         #x7190d05
+         #x1906050b
+         #xef07140f
+         #xfefb07f6
+         #xff6e2fe
+         #xe7e4000a
+         #x1130cff
+         #x8fb04fe
+         #xc1a0406
+         #x12030f0a
+         #xf40c0c0f
+         #xf8fd06f9
+         #x8f0eb04
+         #xe1f00503
+         #xe170cf8
+         #x3fe00f7
+         #x1312ff09
+         #xb05140b
+         #xfa0a0913
+         #xf70105fc
+         #x5f1f400
+         #xe1fd01fe
+         #x18150af0
+         #x100fafd
+         #x1606000a
+         #x40b150f
+         #xff070a11
+         #xff060100
+         #x5f5f8fd
+         #xe902fafc
+         #x1a0e07ed
+         #xfff609
+         #x11ff0508
+         #xe1413
+         #x2070b08
+         #x5030005
+         #x3f5f7ff
+         #xf301f900
+         #x120705f0
+         #x2fdfa14
+         #x7fd0602
+         #x101316
+         #x70807fd
+         #x4ff030c
+         #xfff5fa04
+         #xf900fe03
+         #xa0505f6
+         #x5fd0015
+         #x400
+         #x1101614
+         #xd07fff7
+         #xff000a12
+         #xfcf8ff04
+         #xfb020200
+         #x30406fb
+         #x7ff050e
+         #xfc040100
+         #x210190b
+         #x1100f7f6
+         #xff051015
+         #xfcfb00ff
+         #xff0900fa
+         #x20307fe
+         #x8030407
+         #xfd060101
+         #x6121302
+         #xff9f2f8
+         #x40a1513
+         #xfdfefffb
+         #x40dfbf8
+         #x10800
+         #xb050004
+         #x60103
+         #xa0e09fe
+         #x8f1f3fe
+         #x90c170b
+         #xfd00fdfb
+         #xc0df8f8
+         #xfeff0b05
+         #x1005fc05
+         #x1050103
+         #x9030001
+         #xf1f904
+         #x80f16fc
+         #xfafefe09
+         #x11fef8f8
+         #xfb07060d
+         #xbfb0301
+         #x205020d
+         #x1ff0501
+         #xf5f90008
+         #x20d0f00
+         #xfd020308
+         #xbfdf5f2
+         #xfb04070f
+         #x4fb0800
+         #x50c050b
+         #xfc030c00
+         #xfffdff02
+         #xfe100f05
+         #x80401fe
+         #x6fcf0f3
+         #xfa02090f
+         #x20bfd
+         #xf110305
+         #x90900
+         #x3fafd01
+         #x2130c03
+         #xf00f9f7
+         #x1fbeefd
+         #xfb000c0c
+         #x10908fb
+         #x170e0002
+         #x5090404
+         #xf70007
+         #xa120800
+         #xdf4f0f7
+         #xfcfaf40a
+         #xfaff0e03
+         #x80d04fd
+         #x1804fe02
+         #x407030f
+         #xfcfb080a
+         #xb0b0502
+         #xe9effb
+         #xfbfe0010
+         #xf8000cfb
+         #xe0c0101
+         #xf000205
+         #x6080412
+         #xff000d09
+         #x7060c04
+         #xf0e6effe
+         #xfe040b0b
+         #xf60204f3
+         #x14070103
+         #x6060707
+         #xc08040e
+         #xff040e06
+         #x40b1800
+         #xe9e7eafc
+         #x3090f00
+         #xf804f8f2
+         #x19040400
+         #x10e070b
+         #xf010008
+         #xf8050e09
+         #x91516f3
+         #xede4e4ff
+         #x60d0cf7
+         #xfd01f0f9
+         #x170105fc
+         #x2120714
+         #x9f90601
+         #xf00e110f
+         #x101707f1
+         #xefe1e709
+         #x30e08f5
+         #xfef2ff
+         #x100004f9
+         #x7100b1d
+         #xfa0bfd
+         #xf7150e0c
+         #x120ffafb
+         #xebe0f217
+         #xff1103f4
+         #x2fafbfe
+         #x802fef9
+         #xa0c161f
+         #xfd040afa
+         #x8140406
+         #x805fd08
+         #xe4e10419
+         #x14fdef
+         #x4fb01f8
+         #x501f900
+         #x90b1d1b
+         #x41002fb
+         #xf07fe03
+         #x1030407
+         #xe1ed110f
+         #x411f5ea
+         #x3fe01f3
+         #x7fff707
+         #x70f1f14
+         #xf12fcfe
+         #x6fafe06
+         #x606fa
+         #xeb001004
+         #x906ebe8
+         #x200fcf4
+         #x9fafb0e
+         #x4131c10
+         #x180ffb00
+         #xf5f7050c
+         #x205fcee
+         #xfc040602
+         #x5f8e8f0
+         #x100fafa
+         #x8f8030f
+         #x217170f
+         #x180b0100
+         #xee000c10
+         #xfcf0ef
+         #x4010406
+         #xfaf0ecfa
+         #x200fcfa
+         #x4fb090c
+         #x2161411
+         #x160d05fb
+         #xf6090c12
+         #xf6f1eefd
+         #x5000a06
+         #xf1f2f301
+         #x20000f5
+         #x2010908
+         #x3131511
+         #x181302f6
+         #x4080914
+         #xeaedfb06
+         #x4060dfb
+         #xf2f7f602
+         #x20100ee
+         #x5040509
+         #x612170e
+         #x1e14faf6
+         #x6000916
+         #xe7f40903
+         #x80f05eb
+         #xf8f5f402
+         #x2fdee
+         #x901030b
+         #x715160a
+         #x1f0ef4fc
+         #xfdfe0e18
+         #xee000ef8
+         #x120ef3e4
+         #xfbedf406
+         #xff04fbf5
+         #xdfb040c
+         #x7190f09
+         #x1d04f702
+         #xf0031417
+         #xf70308ef
+         #x1700e4ed
+         #xf3e6fa0c
+         #x8fefd
+         #x8fb0803
+         #xa1b0809
+         #x17ff0303
+         #xef0d1318
+         #xfa0302f1
+         #x13efe4fb
+         #xe7e8010f
+         #x40e05fc
+         #x1fe09fb
+         #x1118050c
+         #x10000c03
+         #xf7100d18
+         #xf803fdf7
+         #x8e6ef01
+         #xe0f5050c
+         #xe130bf2
+         #xfe0200f9
+         #x190e040d
+         #x9050d07
+         #xc0b19
+         #xf705fbfc
+         #xe9fbfd
+         #xe4000006
+         #x171409e9
+         #x2f800
+         #x1902070b
+         #x40c0d0f
+         #x2090e15
+         #xfc06fcfe
+         #xfcf0fdf8
+         #xed03fc04
+         #x191103e4
+         #x2fdf60e
+         #x13fe0907
+         #x4110e17
+         #x30a1008
+         #x304fd01
+         #xfcf4fafa
+         #xf700fb05
+         #x120cfee7
+         #x3f6fc19
+         #x6ff0803
+         #x7121117
+         #x50c0afd
+         #x3000208
+         #xfbf4fb01
+         #xfcfbff06
+         #xa0afcf0
+         #x3f70618
+         #x50401
+         #x8121611
+         #xa0b01f8
+         #xff000a0e
+         #xf8f4ff04
+         #xfcfe0103
+         #x609fef6
+         #x2fb0c10
+         #xff070003
+         #x8131809
+         #xd04f9f8
+         #xfd041210
+         #xf8f90200
+         #xff0400ff
+         #x40800f9
+         #x3010b07
+         #x5ff05
+         #x9151400
+         #x9faf4fa
+         #x20b180c
+         #xfafcfffc
+         #x608fcfc
+         #x20704fc
+         #x7030504
+         #x3040006
+         #xd140afe
+         #x1f4f4fc
+         #x80e1a04
+         #xfafdfcff
+         #xd04f8fc
+         #xff060400
+         #xb000104
+         #x4030008
+         #xd0c02ff
+         #xf8f2f802
+         #x90f18fd
+         #xfafffc05
+         #x1100f8fa
+         #xfd060709
+         #xffd0004
+         #x204010b
+         #x5000302
+         #xf4f6fe08
+         #x8160af9
+         #xfdff0508
+         #x9faf8f5
+         #x1070613
+         #xfe0007f9
+         #x5020810
+         #xfe050500
+         #xf8fb0305
+         #x6140901
+         #x3030700
+         #x4faf0f5
+         #x40a12
+         #xfa0407f7
+         #xc070a0b
+         #xc0400
+         #xfffb00fe
+         #x9140b01
+         #xb0300f6
+         #x1f6ecff
+         #xff040f0d
+         #xfe0a04f8
+         #x15070503
+         #x70cff06
+         #xfdf90100
+         #xe1308fd
+         #x8fbf6f6
+         #xf1f30d
+         #xfc050f06
+         #x60d01fa
+         #x16020101
+         #x907ff10
+         #xf8fa0604
+         #x110d04fb
+         #xfdf0f3ff
+         #xfdf20114
+         #xf9070bfe
+         #xe0900fd
+         #xeff0104
+         #x8050417
+         #xf8020b05
+         #xa0607fd
+         #xeeebf402
+         #xfffc0e0d
+         #xfa0a00f8
+         #x120503fe
+         #x5030308
+         #xa040812
+         #xfb070b05
+         #x3090dfd
+         #xe8ebf301
+         #x3061200
+         #xfd08f5f8
+         #x110306fa
+         #x40b040e
+         #xb000a08
+         #xfc0b0a0b
+         #x5150df7
+         #xeae5edff
+         #x70d0bf5
+         #x101eefd
+         #x100407f6
+         #x90f0717
+         #x4fa0901
+         #xfa0f0b12
+         #x101cfef5
+         #xebe0ec04
+         #x71103f4
+         #x3f9f200
+         #x80704f7
+         #xe09101e
+         #xf9fb0800
+         #x1130d10
+         #x1513f100
+         #xe6e0f60d
+         #x61200f6
+         #x2f5fbff
+         #x306fefb
+         #xf07171b
+         #xf7040301
+         #xf120906
+         #x1106f30e
+         #xe1e40712
+         #x912fdf3
+         #xfff900f9
+         #x402f801
+         #xa0b1e17
+         #xdfe02
+         #x180800ff
+         #x701000f
+         #xe0f2130b
+         #xf0df8ec
+         #xfefffdf7
+         #x7fdfa08
+         #x8141f11
+         #xe0df902
+         #xefefe00
+         #x2050701
+         #xe2011202
+         #x1202f0e7
+         #x2f6fb
+         #x7f7ff0a
+         #x71c1c0e
+         #x1507fa02
+         #xfcf90109
+         #x509fff1
+         #xf20808ff
+         #xdf6eaea
+         #x201f301
+         #x3f7070b
+         #x91e160e
+         #x14040000
+         #xf1fe0812
+         #x602eff0
+         #xff040503
+         #xedecf7
+         #x200f702
+         #xfefd0d07
+         #xc1a1310
+         #x110703fd
+         #xf7060b15
+         #xfef5eafb
+         #x904
+         #xf6ecf400
+         #x200fcfb
+         #xfd020c06
+         #xb15150e
+         #x140dfff9
+         #x3080b15
+         #xf1edf505
+         #xfd070dfb
+         #xf4f1fa03
+         #x102fbf1
+         #x1060907
+         #xb15170b
+         #x1b0ff7fb
+         #x8040b17
+         #xe9f30402
+         #x31006ed
+         #xf9f3fc02
+         #x204f4f0
+         #x7020908
+         #xa181409
+         #x1e07f4fe
+         #xff010e1a
+         #xeb0009f7
+         #xe0ef6e5
+         #xfbeffb05
+         #x204f1f6
+         #x7ff0a05
+         #xc1b0e0b
+         #x1afef800
+         #xf506121e
+         #xf50901ef
+         #x17ffe7e9
+         #xf4eafe0d
+         #x404f5ff
+         #x3ff0e00
+         #x101c0b0e
+         #x11fa0000
+         #xf50e131f
+         #xfc0af6f4
+         #x11ece7f4
+         #xe7ed0313
+         #x80800fb
+         #xfb050bfb
+         #x17130a0e
+         #x9fe0403
+         #xf101f
+         #xfe07f0fc
+         #x2e4f2f9
+         #xe1f70714
+         #xe0d07f0
+         #xfa0801fc
+         #x1d0a0a0b
+         #x505030a
+         #x80b0f1c
+         #xfe04f101
+         #xf4e9fef6
+         #xe700080f
+         #x141105e4
+         #x5f804
+         #x18020c07
+         #x50b0315
+         #xa071415
+         #x3f402
+         #xeff3fff1
+         #xf2000208
+         #x1712fbe0
+         #x4fbf711
+         #xe000d04
+         #x60d0a1a
+         #x70b160a
+         #x400f803
+         #xf1f8fbf4
+         #xfcfb0105
+         #x160ff1e5
+         #x3f30019
+         #x4040a04
+         #x90e1117
+         #x8110f00
+         #x2fefd07
+         #xf4f7fafd
+         #xfef70405
+         #x110beef0
+         #xfef40c18
+         #x80504
+         #xc101610
+         #xc1001fb
+         #xfe00060d
+         #xf4f6ff01
+         #xfcfa0603
+         #xc08f3f7
+         #xfafd120f
+         #x2080105
+         #xc131706
+         #xe07f9fd
+         #xfd050f0d
+         #xf4f902ff
+         #xfe0004ff
+         #xa07f8f8
+         #xfc040f07
+         #x5030206
+         #xd171001
+         #x9fef6fe
+         #xc1607
+         #xf5fe00fb
+         #x40200fe
+         #x807fbfb
+         #x60904
+         #x6000306
+         #x11160801
+         #xf6f4ff
+         #x61217ff
+         #xf7fefcfe
+         #xb00fefc
+         #x508fd00
+         #x5020503
+         #x5000409
+         #x120f0201
+         #xf7f5f602
+         #x91413f8
+         #xf8fcfc06
+         #xdfcfcfa
+         #x308fe0a
+         #x5fe0400
+         #x400050d
+         #xc070102
+         #xf2f5fa08
+         #x9160cf7
+         #xfbfe010a
+         #xcfafaf6
+         #x2080212
+         #x1fe06fb
+         #x3010811
+         #x20501
+         #xf5fa0108
+         #xf1501fb
+         #x40a01
+         #x1fbf3f6
+         #x5031011
+         #xf90700fb
+         #x6021107
+         #x208ff03
+         #xfaff05fd
+         #xf1407fe
+         #x50804f9
+         #xf4eeff
+         #x104130e
+         #xfd0cfefa
+         #xc050c00
+         #xa0bfc08
+         #xfafd00fa
+         #x131208fa
+         #x603f9fa
+         #xfeebf60b
+         #xff091108
+         #x70afcfb
+         #xf0305fe
+         #xe04fd12
+         #xf5fd0101
+         #x140d02f6
+         #xfef9f301
+         #xfaea0411
+         #xff0e0a03
+         #xe07fefb
+         #xb000102
+         #xa000619
+         #xf5010506
+         #xe0700f9
+         #xf1f1f609
+         #xf9f5130b
+         #x10d00ff
+         #xf0401f8
+         #x3020108
+         #x8000f14
+         #xfb080708
+         #x50703fd
+         #xeaf0f906
+         #xfd0514fd
+         #x509f6fe
+         #xb0504f6
+         #x406040f
+         #x6010f0a
+         #xb070b
+         #x40f02fd
+         #xebedf800
+         #x4110cf2
+         #x7fff200
+         #x70904f6
+         #xa060915
+         #xb03
+         #x30b0911
+         #x1118f8ff
+         #xe8e4f4fd
+         #x91300f2
+         #x5f4f503
+         #x50c00f9
+         #x11031319
+         #xf8000705
+         #x90d0f11
+         #x1d10ec08
+         #xe2e2f806
+         #xc10fef4
+         #xfff2fd01
+         #x609fa00
+         #x10041c17
+         #xf505000b
+         #x140f0e02
+         #x1901f114
+         #xe0e9030d
+         #x100dfff2
+         #xfbf7ffff
+         #x802f803
+         #x90d1f12
+         #xfe09fc0b
+         #x1b0a06f8
+         #xdf90116
+         #xe0f70f0d
+         #x1508feeb
+         #xfbfff900
+         #x9fafd05
+         #x6181e0c
+         #xb08fc08
+         #x13fffdfa
+         #x5000a08
+         #xe1050f05
+         #x1600f5e3
+         #x1f105
+         #x4f70204
+         #xa1f180d
+         #x1202ff04
+         #xf9fe06
+         #x60704f7
+         #xed0c0700
+         #x10f7ece1
+         #x3fef00c
+         #xfefa0903
+         #xf1f150e
+         #xfff0101
+         #xf4fb0413
+         #xa05f3f2
+         #xfd080201
+         #x3eeebec
+         #x4faf70c
+         #xf8000d04
+         #x141c150e
+         #xa020200
+         #xf7020b16
+         #x5f6e9fb
+         #xfe030504
+         #xf7ebf4fa
+         #x3fbfd03
+         #xf9060c04
+         #x1416170a
+         #xd08fd00
+         #x2060e14
+         #xf8ecf104
+         #xfc070900
+         #xf2eefd00
+         #x200fbf9
+         #x90a05
+         #x10161605
+         #x1508f700
+         #x7050c15
+         #xebef0004
+         #x1006f3
+         #xf5f301ff
+         #x402f2f4
+         #x4070a04
+         #xf1a1206
+         #x1a01f501
+         #x2030e1c
+         #xecfd04fb
+         #xd0ff7e8
+         #xf7f30000
+         #x7ffedf9
+         #x3040c03
+         #x111b0e0a
+         #x14faf800
+         #xfb05121f
+         #xf608fcf6
+         #x1501eae6
+         #xf2f20009
+         #x8fbf2fe
+         #xfe070d00
+         #x16160d0d
+         #xaf8fd01
+         #xfd0b161f
+         #x10aeef9
+         #xfeee6ec
+         #xe9f30515
+         #x7fcfffb
+         #xf90d09fd
+         #x1c10100c
+         #x2fdff06
+         #x50c161f
+         #x603ea03
+         #xfce7f0f3
+         #xe4f90e18
+         #x90406ee
+         #xfd0d0001
+         #x1d091205
+         #x102fc10
+         #xd0a1719
+         #x6fdee08
+         #xebecfaf4
+         #xeaff1011
+         #xf0e00e3
+         #x506f808
+         #x16061000
+         #x305fe19
+         #xc091b11
+         #x5faf506
+         #xe6f8fbf2
+         #xf5000f06
+         #x1512f3e1
+         #x9faf912
+         #xa070b00
+         #x706081c
+         #x60d1a09
+         #x5f9f805
+         #xecfdf5f6
+         #xfcfc0cff
+         #x190de6e9
+         #x3f20418
+         #x20b0804
+         #xa081516
+         #x7131203
+         #x2f8fb09
+         #xf2faf4fd
+         #xfcf909fc
+         #x1705e3f3
+         #xfaf61017
+         #xd0707
+         #xb0d1a0b
+         #xf120502
+         #xfefa0010
+         #xf4f8fb00
+         #xf8fb09fd
+         #x1300ebfa
+         #xf3011611
+         #x50a0605
+         #xc121603
+         #x1309fb03
+         #xfd020b0f
+         #xf3fa00fd
+         #xf90108fb
+         #xffff3fa
+         #xf70b110a
+         #x8020502
+         #xe150e03
+         #xdfef704
+         #xc1108
+         #xf4fffff9
+         #x304f9
+         #xc01f7fb
+         #xfe0c0a07
+         #x6000601
+         #x12140604
+         #x2f8f704
+         #x81211ff
+         #xf6fffafc
+         #x60001f9
+         #xa03f701
+         #x3070505
+         #x3000705
+         #x15100206
+         #xfaf5f607
+         #xc170bf8
+         #xf8fcfb03
+         #x7fd00f8
+         #xa03fa0a
+         #x2020402
+         #x1000909
+         #x10080205
+         #xf6f4f80b
+         #xe1803f7
+         #xfafa0107
+         #x5fcfcf5
+         #x9020112
+         #xfd0203fe
+         #x2000c0c
+         #x7050203
+         #xf6f5ff0b
+         #x101700fa
+         #xfe000905
+         #x2fcf5f4
+         #x6030b13
+         #xf80601fa
+         #x400110b
+         #x1070003
+         #xf9fb0502
+         #x160e02fa
+         #x10c0502
+         #xfff5f1fc
+         #x1071709
+         #x204f902
+         #x20c0ffb
+         #xa03fe06
+         #xf80200fd
+         #x160f05f8
+         #x709f902
+         #xfceaf705
+         #xd1409
+         #xa05f9ff
+         #x70b04f9
+         #xdff000f
+         #xf7fffb02
+         #x170e00f5
+         #x4fef209
+         #xf4e9040b
+         #x3100d06
+         #xf02fbfc
+         #x607ff00
+         #x9fb0a14
+         #xf700000b
+         #x1107faf7
+         #xfbf4f610
+         #xeff51207
+         #x80f0501
+         #xc01fef9
+         #x303000a
+         #x3fe1412
+         #xfc04040d
+         #x804fafd
+         #xf1f1fe0e
+         #xf30814fb
+         #xd09fdfd
+         #x704fef8
+         #x302040e
+         #x31609
+         #x207060c
+         #x608fb01
+         #xeff3ff03
+         #xfe1409f0
+         #xbfdf9fe
+         #x509fcfb
+         #x8010c10
+         #xff060c05
+         #x7070b0e
+         #xf0bf805
+         #xebeffafd
+         #x814ffef
+         #x4f3fc01
+         #x70bf900
+         #xb011510
+         #xf9050409
+         #xa091109
+         #x1b06f20b
+         #xe2e9f703
+         #xf0ffdf1
+         #xfbf10003
+         #xb07f805
+         #xa031a0f
+         #xf8060010
+         #x100e13fc
+         #x1af8f815
+         #xe0ecfe11
+         #x130800ee
+         #xf5f7ff05
+         #xe00fa05
+         #x5131c0d
+         #xff07020f
+         #x160f0af0
+         #xdf10817
+         #xe0f70714
+         #x1507ffe6
+         #xf7fef909
+         #xbfaff01
+         #x41d1a0c
+         #x8040408
+         #x1106fdf4
+         #xf9140c
+         #xe3050b0f
+         #x1305f6e0
+         #xf40f
+         #x3f904ff
+         #xd1f140c
+         #xbfe0402
+         #x2fbf903
+         #x2060bfc
+         #xf20b0506
+         #xdfeebe0
+         #x5f8f614
+         #xfafe07ff
+         #x161f140d
+         #x7fd0302
+         #xf6f90111
+         #x805fbf4
+         #x70004
+         #x3f4e6e4
+         #x4f3fe13
+         #xf5040903
+         #x1b1b1509
+         #x4010105
+         #xf5fe0b13
+         #x9f8edf9
+         #x1030108
+         #xf7ededf2
+         #xf6060a
+         #xf90a0805
+         #x19171602
+         #x706fe07
+         #xfe041011
+         #xfcebf202
+         #xfe050507
+         #xf0f0fafa
+         #xfc02fe
+         #xc0806
+         #x14181400
+         #xf05f908
+         #x4060f11
+         #xeeebfe04
+         #x20d04fd
+         #xf1f600fa
+         #x3fff8f8
+         #x60a0905
+         #x121b0e01
+         #x13fff906
+         #x3040f18
+         #xeaf803ff
+         #xd0efaed
+         #xf3fcfffb
+         #x8faf1f8
+         #x4090a04
+         #x16190a06
+         #xdf9fa05
+         #xfe05151f
+         #xf503fafb
+         #x1602ece6
+         #xf2fafe05
+         #x7f3f5fc
+         #xff0c0904
+         #x1a150e09
+         #x3f8fb05
+         #xff081a1f
+         #x304efff
+         #xff2e6ea
+         #xecf90312
+         #x2f300f8
+         #xff100606
+         #x1b0f1206
+         #xfefbf90c
+         #x50c1d1a
+         #xbfbec06
+         #xfbe9eaf3
+         #xe9fb1019
+         #xfe06ed
+         #x4100006
+         #x1a0c11ff
+         #xf815
+         #xb0c1f11
+         #x8f2f509
+         #xe9eef1f9
+         #xed01190f
+         #x70afee3
+         #xd05fa0a
+         #x120f0cfc
+         #x400fe1b
+         #x8101f0a
+         #x3effd05
+         #xe6f8f3fd
+         #xf5031800
+         #x110fede3
+         #xffafd0f
+         #x90f0700
+         #x5fe0a1a
+         #x3141d07
+         #xf2ff02
+         #xeffcf000
+         #xfb0410f4
+         #x1a08e1ec
+         #x4f40615
+         #x4100406
+         #x4021812
+         #x4191304
+         #xfdf3fe09
+         #xf8f8f003
+         #xf90409f2
+         #x1afce1f5
+         #xf6fa1218
+         #x50e0709
+         #x50c1b07
+         #xf160805
+         #xfaf50012
+         #xf9f5f603
+         #xf60506f4
+         #x14f4eaf9
+         #xef051617
+         #x90a0903
+         #xa151402
+         #x160a0007
+         #xfafc0813
+         #xf6f8fdff
+         #xf60705f7
+         #xcf4f5f9
+         #xf50f1213
+         #xa0509fc
+         #xf170b03
+         #x11fffd08
+         #xff06100b
+         #xf5fdfcfa
+         #xfc0802f6
+         #x9f9f8f8
+         #x100b0f
+         #x60207fb
+         #x13130507
+         #x5f8fc08
+         #x7100d01
+         #xfafff8fb
+         #x10600f4
+         #x8fcf8fd
+         #x70b060d
+         #x10305ff
+         #x130d0408
+         #xfdf5fb0a
+         #xf1406fc
+         #xfcfaf803
+         #x202fef4
+         #xafdfb06
+         #x5050409
+         #xff040704
+         #x11090604
+         #xf9f2fb0f
+         #x131400fa
+         #xfbf80007
+         #x1fbf4
+         #x8fc030c
+         #xff040206
+         #x40d07
+         #xb060403
+         #xf8f2000f
+         #x1512fdf9
+         #xfaff0606
+         #xff00f5f4
+         #x5fe0e0d
+         #xfd06ff04
+         #x61204
+         #x6050203
+         #xf6f70507
+         #x160f00fa
+         #xff080901
+         #xfaf2f9
+         #x103160c
+         #xff07fa02
+         #x10810ff
+         #x805fe05
+         #xf80004fd
+         #x150b01f9
+         #xa09fb0e
+         #xfcedf600
+         #x1121306
+         #xbfcfc01
+         #x41500fc
+         #x8fc0402
+         #xfbfffa08
+         #x150dfef8
+         #xdfef612
+         #xf0eb0107
+         #x7150f05
+         #xdfcfcfd
+         #x80efb02
+         #x3f80b0a
+         #xfcfbfe11
+         #x1308f6f9
+         #x4f2fa18
+         #xe8f90d06
+         #xd110bfe
+         #xafefbfb
+         #x604fd0b
+         #xfdff150b
+         #xfdfe0611
+         #xc01f5fd
+         #xf9f00315
+         #xec0b0efe
+         #xf0905f7
+         #x501fafd
+         #x400050f
+         #xfc081607
+         #x1010a0c
+         #x500f802
+         #xf2f60709
+         #xfb1804f3
+         #xd0001f5
+         #x604f704
+         #x4000e0d
+         #xfd0c0d05
+         #x5050d07
+         #xb02fa05
+         #xf0f7ff00
+         #xa16faf0
+         #x3f700fb
+         #xb04f70a
+         #x503120a
+         #xff0a040a
+         #x7081204
+         #x1300fb09
+         #xeaf2f805
+         #x120bf9f0
+         #xf8f50103
+         #x1100f90a
+         #x30b1509
+         #xff050410
+         #x91013f9
+         #x12f3010f
+         #xe0edf915
+         #x1306feea
+         #xf2fa0009
+         #x13fcfe06
+         #x117130b
+         #x3070f
+         #xe1609ee
+         #x3ee1013
+         #xe1f2031e
+         #x1208fce2
+         #xf7fefd0f
+         #xbf902fd
+         #x51f110d
+         #x6020d04
+         #xf0df9f2
+         #xf8f91a0d
+         #xe7fe0a17
+         #x100af3e0
+         #xfefcfb14
+         #x1fc04fa
+         #x111f120f
+         #x7010b00
+         #x6fff300
+         #xfa0815ff
+         #xf6060a0b
+         #xd05e8e0
+         #x2f40017
+         #xf80103fe
+         #x1c1d130d
+         #x2000404
+         #xf9f6fc0d
+         #x50b01f4
+         #x2050305
+         #x5f9e2e4
+         #xfff00a14
+         #xf8060305
+         #x1f191605
+         #x2000c
+         #xf3fb0a0e
+         #x8fef3f5
+         #x500010a
+         #xfbefe2ef
+         #xf9f4100b
+         #xfc090509
+         #x1e1814fd
+         #x304fe12
+         #xf8041009
+         #xffedf3fd
+         #x50e
+         #xf2eff0f8
+         #xf8fc0c00
+         #x30a0708
+         #x181b0efa
+         #xa04fd10
+         #x80f09
+         #xeeebfe02
+         #x2060704
+         #xf0f8faf8
+         #xff0000f7
+         #x90a0804
+         #x171d08ff
+         #xefefd0c
+         #x1080f13
+         #xe9f50200
+         #xd0afff4
+         #xf3fffaf9
+         #x3faf8f5
+         #x80b0805
+         #x19190704
+         #x8f9fd08
+         #x6151c
+         #xf200fefd
+         #x1502f1e8
+         #xf500f704
+         #x1f1faf7
+         #x40d070a
+         #x1c120b06
+         #xf9fa0c
+         #xfe0a1e1b
+         #x1fff4ff
+         #xff4e7eb
+         #xf3fc0012
+         #xfbf101f5
+         #x60e050c
+         #x1a100f02
+         #xfdfaf810
+         #x10f1f13
+         #x8f5f403
+         #xfeeae6f7
+         #xf0fc0f16
+         #xf7fb04ee
+         #xd0b030a
+         #x16130dfd
+         #xfffbfa18
+         #x4151f08
+         #x3ebfd05
+         #xedebeb02
+         #xf1011b0c
+         #x8fbe6
+         #x13040009
+         #x101605fd
+         #x2f8021c
+         #x4181d04
+         #xfbec0401
+         #xebf1f007
+         #xf60d1afa
+         #xe0ceae6
+         #x10fb020a
+         #xc15ff04
+         #x1f81116
+         #x11b1905
+         #xf6f10300
+         #xf4f4f107
+         #xfb1310ee
+         #x1802e0ed
+         #x3f80910
+         #xa10000b
+         #xffff1c0d
+         #x51d1306
+         #xf5f5ff07
+         #xfdf1f306
+         #xfb1102ed
+         #x19f3e3f4
+         #xf4fd1119
+         #xc0b070c
+         #xff0c1b05
+         #x101b0a05
+         #xf4f40212
+         #xfceff904
+         #xfa0ffdf2
+         #xfeaeef6
+         #xf008161e
+         #xd080d01
+         #x6170e02
+         #x18100305
+         #xf4f80a16
+         #xf8f3feff
+         #xfa0dfdf6
+         #x4ecf7f3
+         #xf811151c
+         #xd090af7
+         #xf170406
+         #x13020106
+         #xf900110d
+         #xf7fafdfb
+         #xfe0cfef5
+         #xf4f9f3
+         #x5111018
+         #x80802f4
+         #x14120209
+         #x5fb0208
+         #x20c1002
+         #xfbfcf7fc
+         #x20afcf4
+         #x2f8f8f8
+         #xc0b0c12
+         #x20800fc
+         #x130b0608
+         #xfcf8010c
+         #xc1106fd
+         #xfef8f701
+         #x308faf4
+         #x3f8fb00
+         #xa06090f
+         #x80103
+         #xf080904
+         #xf9f4000f
+         #x140f00fa
+         #xfcf5fd09
+         #x205f6f6
+         #x3f90404
+         #x303060d
+         #x80805
+         #xa080700
+         #xf6f2040f
+         #x150b00f7
+         #xf8fb040a
+         #x102f4f6
+         #xfc0e05
+         #x103020c
+         #x10b0d01
+         #x8070300
+         #xf1f7090a
+         #x160900f5
+         #xfb06060b
+         #x1fbf1f7
+         #xfc041304
+         #x4010009
+         #x1110bfc
+         #x9040201
+         #xf1ff0705
+         #x140a02f8
+         #x40d000a
+         #xfff0f4fd
+         #xe1507
+         #xafefd05
+         #x21504fa
+         #x8ff0203
+         #xf902fd03
+         )
+  )
+  
diff --git a/goal_src/engine/gfx/ocean/ocean-h.gc b/goal_src/engine/gfx/ocean/ocean-h.gc
index 7e5fbbd041..f1fa9b2971 100644
--- a/goal_src/engine/gfx/ocean/ocean-h.gc
+++ b/goal_src/engine/gfx/ocean/ocean-h.gc
@@ -411,3 +411,4 @@
   :size-assert         #x110
   :flag-assert         #x900000110
   )
+
diff --git a/goal_src/engine/gfx/ocean/ocean-trans-tables.gc b/goal_src/engine/gfx/ocean/ocean-trans-tables.gc
index e4c5da3fcd..6ba58cda9d 100644
--- a/goal_src/engine/gfx/ocean/ocean-trans-tables.gc
+++ b/goal_src/engine/gfx/ocean/ocean-trans-tables.gc
@@ -5,3 +5,1091 @@
 ;; name in dgo: ocean-trans-tables
 ;; dgos: GAME, ENGINE
 
+(define *ocean-left-table*
+    (new 'static 'array float 28
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-right-table*
+    (new 'static 'array float 28
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-up-table*
+    (new 'static 'array float 28
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-down-table*
+    (new 'static 'array float 28
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-down-left-table*
+    (new 'static 'array float 40
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-down-right-table*
+    (new 'static 'array float 40
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-up-right-table*
+    (new 'static 'array float 40
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-up-left-table*
+    (new 'static 'array float 40
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-trans-left-table*
+    (new 'static 'array float 44
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-trans-right-table*
+    (new 'static 'array float 44
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-up-table*
+    (new 'static 'array float 44
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-trans-down-table*
+    (new 'static 'array float 44
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-down-left-table*
+    (new 'static 'array float 72
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-down-right-table*
+    (new 'static 'array float 72
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-up-right-table*
+    (new 'static 'array float 72
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-trans-up-left-table*
+    (new 'static 'array float 72
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.875000
+         0.000000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.625000
+         0.000000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.625000
+         0.000000
+         0.375000
+         0.000000
+         0.625000
+         0.375000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.875000
+         0.000000
+         0.125000
+         0.000000
+         0.875000
+         0.125000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         )
+  )
+(define *ocean-trans-corner-table*
+    (new 'static 'array float 100
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.562500
+         0.187500
+         0.187500
+         0.062500
+         0.375000
+         0.375000
+         0.125000
+         0.125000
+         0.187500
+         0.562500
+         0.062500
+         0.187500
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.375000
+         0.125000
+         0.375000
+         0.125000
+         0.250000
+         0.250000
+         0.250000
+         0.250000
+         0.125000
+         0.375000
+         0.125000
+         0.375000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.187500
+         0.062500
+         0.562500
+         0.187500
+         0.125000
+         0.125000
+         0.375000
+         0.375000
+         0.062500
+         0.187500
+         0.187500
+         0.562500
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-strip-array*
+    (new 'static 'array float 160
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.000000
+         0.562500
+         0.187500
+         0.187500
+         0.062500
+         0.500000
+         0.500000
+         0.000000
+         0.000000
+         0.375000
+         0.375000
+         0.125000
+         0.125000
+         0.250000
+         0.750000
+         0.000000
+         0.000000
+         0.187500
+         0.562500
+         0.062500
+         0.187500
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.562500
+         0.187500
+         0.187500
+         0.062500
+         0.375000
+         0.125000
+         0.375000
+         0.125000
+         0.375000
+         0.375000
+         0.125000
+         0.125000
+         0.250000
+         0.250000
+         0.250000
+         0.250000
+         0.187500
+         0.562500
+         0.062500
+         0.187500
+         0.125000
+         0.375000
+         0.125000
+         0.375000
+         0.000000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.375000
+         0.125000
+         0.375000
+         0.125000
+         0.187500
+         0.062500
+         0.562500
+         0.187500
+         0.250000
+         0.250000
+         0.250000
+         0.250000
+         0.125000
+         0.125000
+         0.375000
+         0.375000
+         0.125000
+         0.375000
+         0.125000
+         0.375000
+         0.062500
+         0.187500
+         0.187500
+         0.562500
+         0.000000
+         0.500000
+         0.000000
+         0.500000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         0.187500
+         0.062500
+         0.562500
+         0.187500
+         0.000000
+         0.000000
+         0.750000
+         0.250000
+         0.125000
+         0.125000
+         0.375000
+         0.375000
+         0.000000
+         0.000000
+         0.500000
+         0.500000
+         0.062500
+         0.187500
+         0.187500
+         0.562500
+         0.000000
+         0.000000
+         0.250000
+         0.750000
+         0.000000
+         0.250000
+         0.000000
+         0.750000
+         0.000000
+         0.000000
+         0.000000
+         1.000000
+         )
+  )
+(define *ocean-trans-st-table*
+    (new 'static 'array float 16
+         0.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         1.000000
+         0.000000
+         0.000000
+         1.000000
+         1.000000
+         0.000000
+         1.000000
+         1.000000
+         1.000000
+         0.000000
+         )
+  )
diff --git a/goal_src/engine/gfx/shadow/shadow-cpu-h.gc b/goal_src/engine/gfx/shadow/shadow-cpu-h.gc
index 28efd1c71d..ffabc3da32 100644
--- a/goal_src/engine/gfx/shadow/shadow-cpu-h.gc
+++ b/goal_src/engine/gfx/shadow/shadow-cpu-h.gc
@@ -5,3 +5,261 @@
 ;; name in dgo: shadow-cpu-h
 ;; dgos: GAME, ENGINE
 
+(deftype shadow-settings (structure)
+  ((center        vector :inline :offset-assert 0)
+   (flags         int32          :offset 12)
+   (shadow-dir    vector :inline :offset-assert 16)
+   (dist-to-locus float          :offset 28)
+   (bot-plane     plane  :inline :offset-assert 32)
+   (top-plane     plane  :inline :offset-assert 48)
+   (fade-dist     float          :offset-assert 64)
+   (fade-start    float          :offset-assert 68)
+   (dummy-2       int32          :offset-assert 72)
+   (dummy-3       int32          :offset-assert 76)
+   )
+  :method-count-assert 9
+  :size-assert         #x50
+  :flag-assert         #x900000050
+  )
+
+(deftype shadow-control (basic)
+  ((settings shadow-settings :inline :offset-assert 16)
+   )
+  :method-count-assert 16
+  :size-assert         #x60
+  :flag-assert         #x1000000060
+  (:methods
+   (new (symbol type float float float float float) _type_ 0)
+   (clear-offset-bit (shadow-control) none 9)
+   (set-offset-bit (shadow-control) none 10)
+   (set-top-plane-offset (shadow-control float) none 11)
+   (set-bottom-plane-offset (shadow-control float) none 12)
+   (dummy-13 () none 13)
+   (dummy-14 () none 14)
+   (dummy-15 () none 15)
+   )
+  )
+
+(defmethod clear-offset-bit shadow-control ((obj shadow-control))
+  "Clear a bit in w for the center of the shadow."
+  (set! (-> obj settings center w)
+        (the-as float (logand -33 (the-as int (-> obj settings center w))))
+        )
+  (none)
+  )
+
+(defmethod set-offset-bit shadow-control ((obj shadow-control))
+  "Set a bit in w for the center position of the shadow"
+  (set! (-> obj settings center w)
+        (the-as float (logior (the-as int (-> obj settings center w))
+                              32)
+                )
+        )
+  (none)
+  )
+
+
+(defmethod set-bottom-plane-offset shadow-control ((obj shadow-control) (arg0 float))
+  (set! (-> obj settings bot-plane d) (- arg0))
+  (none)
+  )
+
+(defmethod set-top-plane-offset shadow-control ((obj shadow-control) (arg0 float))
+  (set! (-> obj settings top-plane d) (- arg0))
+  (none)
+  )
+
+(deftype shadow-data (structure)
+  ((texoffset           vector     :inline :offset-assert 0)
+   (texscale            vector     :inline :offset-assert 16)
+   (clrs                uint128    2       :offset-assert 32)
+   (dma-unpack-template dma-packet :inline :offset-assert 64)
+   (dma-cnt             uint64             :offset-assert 80)
+   (vif-nop             uint32             :offset-assert 88)
+   (vif-unpack-v4-8     uint32             :offset-assert 92)
+   (pdc                 basic              :offset-assert 96)
+   (dist                float              :offset-assert 100)
+   (oddeven             uint8              :offset-assert 104)
+   (waits               uint32             :offset-assert 108)
+   )
+  :method-count-assert 9
+  :size-assert         #x70
+  :flag-assert         #x900000070
+  )
+
+(deftype shadow-work (structure)
+  ((shadow-data shadow-data :inline :offset-assert 0)
+   (inbuf       uint128     600     :offset-assert 112)
+   )
+  :method-count-assert 9
+  :size-assert         #x25f0
+  :flag-assert         #x9000025f0
+  )
+
+(deftype shadow-run (structure)
+  ((first uint32  :offset-assert 0)
+   (next  uint32  :offset-assert 4)
+   )
+  :allow-misaligned
+  :method-count-assert 9
+  :size-assert         #x8
+  :flag-assert         #x900000008
+  )
+
+(deftype shadow-queue (structure)
+  ((num-runs uint32     :offset-assert 0)
+   (cur-run  uint32     :offset-assert 4)
+   (run      shadow-run 15 :inline :offset-assert 8)
+   )
+  :method-count-assert 9
+  :size-assert         #xf8
+  :flag-assert         #x9000000f8
+  )
+
+(defun shadow-queue-append ((arg0 shadow-queue))
+  "Increment the run counter"
+  (local-vars (v0-0 uint))
+  (set! v0-0 (+ (-> arg0 cur-run) 1))
+  (set! (-> arg0 cur-run) v0-0)
+  v0-0
+  )
+
+(defun shadow-queue-reset ((arg0 shadow-queue))
+  "Reset the run counter"
+  (set! (-> arg0 cur-run) 0)
+  0
+  )
+
+(define *shadow-queue* (new 'global 'shadow-queue))
+
+(deftype shadow-vertex (structure)
+  ((x      float  :offset-assert 0)
+   (y      float  :offset-assert 4)
+   (z      float  :offset-assert 8)
+   (weight float  :offset-assert 12)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+(deftype shadow-matrix-ref (structure)
+  ((joint-0 uint8  :offset-assert 0)
+   (joint-1 uint8  :offset-assert 1)
+   )
+  :method-count-assert 9
+  :size-assert         #x2
+  :flag-assert         #x900000002
+  )
+
+;; BUG:
+;; the shadow-edge type is multiply defined.
+;; it seems like the first definition is not used.
+;; The OpenGOAL compiler doesn't like this, so this is commented out.
+#|
+;; shadow-cpu-h
+; (deftype shadow-edge (structure)      ;
+;   ((ind-0 uint16  :offset-assert 0)   ;
+;    (ind-1 uint16  :offset-assert 2)   ;
+;    (tri-0 uint16  :offset-assert 4)   ;
+;    (tri-1 uint16  :offset-assert 6)   ;
+;    )                                  ;
+;   :method-count-assert 9              ;
+;   :size-assert         #x4            ;
+;   :flag-assert         #x900000004    ;
+;   )                                   ;
+|#
+
+(deftype shadow-tri (structure)
+  ((ind-0 uint8  :offset-assert 0)
+   (ind-1 uint8  :offset-assert 1)
+   (ind-2 uint8  :offset-assert 2)
+   (faces uint8  :offset-assert 3)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+(deftype shadow-edge (structure)
+  ((ind-0 uint8  :offset-assert 0)
+   (ind-1 uint8  :offset-assert 1)
+   (tri-0 uint8  :offset-assert 2)
+   (tri-1 uint8  :offset-assert 3)
+   )
+  :method-count-assert 9
+  :size-assert         #x4
+  :flag-assert         #x900000004
+  )
+
+(deftype shadow-header (structure)
+  ((qwc-data         uint32  :offset-assert 0)
+   (num-joints       uint32  :offset-assert 4)
+   (num-verts        uint16  :offset-assert 8)
+   (num-twos         uint16  :offset-assert 10)
+   (num-single-tris  uint16  :offset-assert 12)
+   (num-single-edges uint16  :offset-assert 14)
+   (num-double-tris  uint16  :offset-assert 16)
+   (num-double-edges uint16  :offset-assert 18)
+   (ofs-verts        uint32  :offset-assert 20)
+   (ofs-refs         uint32  :offset-assert 24)
+   (ofs-single-tris  uint32  :offset-assert 28)
+   (ofs-single-edges uint32  :offset-assert 32)
+   (ofs-double-tris  uint32  :offset-assert 36)
+   (ofs-double-edges uint32  :offset-assert 40)
+   )
+  :method-count-assert 9
+  :size-assert         #x2c
+  :flag-assert         #x90000002c
+  )
+
+(deftype shadow-geo (art-element)
+  ((total-size uint32                 :offset-assert 32)
+   (header     shadow-header :inline  :offset 32)
+   (rest       uint64       :dynamic :offset-assert 80)
+   )
+  :method-count-assert 13
+  :size-assert         #x50
+  :flag-assert         #xd00000050
+  (:methods
+   (dummy-9 () none 9)
+   (dummy-10 () none 10)
+   (dummy-11 () none 11)
+   (dummy-12 () none 12)
+   )
+  )
+
+(defmethod new shadow-control ((allocation symbol) (type-to-make type)
+                               (bottom-offset float)
+                               (top-offset float)
+                               (dir float)
+                               (center float)
+                               (fade float)
+                               )
+  (local-vars (v0-0 shadow-control) (v1-2 vector) (v1-3 plane) (v1-4 plane))
+  (set! v0-0
+        (object-new allocation type-to-make (the-as int (-> type-to-make size)))
+        )
+  (set! (-> v0-0 settings center data 3) center)
+  (set! v1-2 (-> v0-0 settings shadow-dir))
+  (set! (-> v1-2 x) 0.000000)
+  (set! (-> v1-2 y) -1.000000)
+  (set! (-> v1-2 z) 0.000000)
+  (set! (-> v1-2 w) dir)
+  (set! v1-3 (-> v0-0 settings bot-plane))
+  (set! (-> v1-3 a) 0.000000)
+  (set! (-> v1-3 b) 1.000000)
+  (set! (-> v1-3 c) 0.000000)
+  (set! (-> v1-3 d) (- bottom-offset))
+  (set! v1-4 (-> v0-0 settings top-plane))
+  (set! (-> v1-4 a) 0.000000)
+  (set! (-> v1-4 b) 1.000000)
+  (set! (-> v1-4 c) 0.000000)
+  (set! (-> v1-4 d) (- top-offset))
+  (set! (-> v0-0 settings fade-dist) fade)
+  v0-0
+  )
+
+(define *shadow* #f)
+(define *shadow-object* #f)
+(define *shadow-debug* #f)
diff --git a/goal_src/engine/gfx/shadow/shadow-vu1-h.gc b/goal_src/engine/gfx/shadow/shadow-vu1-h.gc
index d1b9a620ff..6027c891f8 100644
--- a/goal_src/engine/gfx/shadow/shadow-vu1-h.gc
+++ b/goal_src/engine/gfx/shadow/shadow-vu1-h.gc
@@ -5,3 +5,4 @@
 ;; name in dgo: shadow-vu1-h
 ;; dgos: GAME, ENGINE
 
+;; empty!
diff --git a/goal_src/engine/gfx/sky/sky-h.gc b/goal_src/engine/gfx/sky/sky-h.gc
index 711bafbfb3..aa2ab1f9a0 100644
--- a/goal_src/engine/gfx/sky/sky-h.gc
+++ b/goal_src/engine/gfx/sky/sky-h.gc
@@ -5,3 +5,177 @@
 ;; name in dgo: sky-h
 ;; dgos: GAME, ENGINE
 
+(deftype sky-color-hour (structure)
+  ((snapshot1   int32  :offset-assert 0)
+   (snapshot2   int32  :offset-assert 4)
+   (morph-start float  :offset-assert 8)
+   (morph-end   float  :offset-assert 12)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+(deftype sky-color-day (structure)
+  ((hour sky-color-hour 24 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x180
+  :flag-assert         #x900000180
+  )
+
+
+(deftype sky-circle-data (structure)
+  ((data vector 17 :inline :offset-assert 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x110
+  :flag-assert         #x900000110
+  )
+
+(deftype sky-sun-data (structure)
+  ((data           uint128 4       :offset-assert 0)
+   (pos            vector  :inline :offset 0)
+   (r-sun          float           :offset 16)
+   (r-halo         float           :offset 20)
+   (r-aurora       float           :offset 24)
+   (c-sun-start    uint32          :offset 32)
+   (c-sun-end      uint32          :offset 48)
+   (c-halo-start   uint32          :offset 36)
+   (c-halo-end     uint32          :offset 52)
+   (c-aurora-start uint32          :offset 40)
+   (c-aurora-end   uint32          :offset 56)
+   )
+  :method-count-assert 9
+  :size-assert         #x40
+  :flag-assert         #x900000040
+  )
+
+(deftype sky-moon-data (structure)
+  ((data  uint128 2       :offset-assert 0)
+   (pos   vector  :inline :offset 0)
+   (scale vector  :inline :offset 16)
+   )
+  :method-count-assert 9
+  :size-assert         #x20
+  :flag-assert         #x900000020
+  )
+
+(deftype sky-orbit (structure)
+  ((high-noon float  :offset-assert 0)
+   (tilt      float  :offset-assert 4)
+   (rise      float  :offset-assert 8)
+   (dist      float  :offset-assert 12)
+   (min-halo  float  :offset-assert 16)
+   (max-halo  float  :offset-assert 20)
+   )
+  :allow-misaligned
+  :method-count-assert 9
+  :size-assert         #x18
+  :flag-assert         #x900000018
+  )
+
+(deftype sky-upload-data (basic)
+  (
+   ;;(data   UNKNOWN         27      :offset-assert 16)
+   (circle sky-circle-data :inline :offset-assert 16)
+   (sun    sky-sun-data 2 :inline       :offset-assert 288)
+   (moon   sky-moon-data   :inline :offset-assert 416)
+   (data   uint128         27      :offset 16)
+   )
+  :method-count-assert 9
+  :size-assert         #x1c0
+  :flag-assert         #x9000001c0
+  )
+
+(deftype sky-parms (basic)
+  ;; check - the alignment on some of these.
+  ((orbit             sky-orbit 3     :inline :offset-assert 4)
+   (upload-data       sky-upload-data :inline :offset-assert 112)
+   (sun-lights        light-group     :inline :offset-assert 560)
+   (moon-lights       light-group     :inline :offset-assert 752)
+   (default-lights    light-group     :inline :offset-assert 944)
+   (default-vu-lights vu-lights       :inline :offset-assert 1136)
+   )
+  (:methods
+   (new (symbol type) _type_ 0)
+   )
+  :method-count-assert 9
+  :size-assert         #x4e0
+  :flag-assert         #x9000004e0
+  )
+
+(defmethod new sky-parms ((allocation symbol) (type-to-make type))
+  (local-vars (v0-0 sky-parms))
+  (set! v0-0
+        (object-new allocation type-to-make (the-as int (-> type-to-make size)))
+        )
+  (set! (-> v0-0 upload-data type) sky-upload-data)
+  v0-0
+  )
+
+(define *sky-parms* (new 'global 'sky-parms))
+(define *sky-upload-data* (new 'global 'sky-upload-data))
+
+;; generate some sky data.
+(let ((gp-0 0))
+  (while (< gp-0 17)
+    (let* ((f30-0 (+ (the-as float #xc0490fda)
+                     (* (the-as float #x3ec90fda) (the float (logand gp-0 15)))
+                     )
+             )
+           (f0-2 (* (the-as float #x400ccccd) (sin-rad f30-0)))
+           )
+
+      (set! (-> *sky-upload-data* circle data gp-0 data 0)
+            (* (the-as float #x400ccccd) (sin-rad f30-0))
+            )
+      (set! (-> *sky-upload-data* circle data gp-0 data 1) (cos-rad f30-0))
+      (set! (-> *sky-upload-data* circle data gp-0 data 2) 0.000000)
+      (set! (-> *sky-upload-data* circle data gp-0 data 3) 0.000000)
+      (+! gp-0 1)
+      )
+    )
+  )
+
+(deftype sky-tng-data (basic)
+  ((giftag-base  qword   :inline :offset-assert 16)
+   (giftag-roof  qword   :inline :offset-assert 32)
+   (giftag-ocean qword   :inline :offset-assert 48)
+   (fog          vector  :inline :offset-assert 64)
+   (sky          uint32 8       :offset-assert 80)
+   (time         float           :offset-assert 112)
+   (off-s-0      uint16          :offset-assert 116)
+   (off-t-0      uint16          :offset-assert 118)
+   (off-s-1      uint16          :offset-assert 120)
+   (off-t-1      uint16          :offset-assert 122)
+   )
+  :method-count-assert 9
+  :size-assert         #x7c
+  :flag-assert         #x90000007c
+  )
+
+(deftype sky-work (structure)
+  ((adgif-tmpl dma-gif-packet :inline :offset-assert 0)
+   (draw-tmpl  dma-gif-packet :inline :offset-assert 32)
+   (blend-tmpl dma-gif-packet :inline :offset-assert 64)
+   (sky-data   uint128        5       :offset-assert 96)
+   (cloud-data uint128        5       :offset-assert 176)
+   )
+  :method-count-assert 9
+  :size-assert         #x100
+  :flag-assert         #x900000100
+  )
+
+(deftype sky-vertex (structure)
+  ((pos vector :inline :offset-assert 0)
+   (stq vector :inline :offset-assert 16)
+   (col vector :inline :offset-assert 32)
+   )
+  :method-count-assert 9
+  :size-assert         #x30
+  :flag-assert         #x900000030
+  )
+
+(define *sky-drawn* #f)
+(define *cloud-drawn* #f)
diff --git a/goal_src/engine/gfx/wind-h.gc b/goal_src/engine/gfx/wind-h.gc
index 8890c9da26..b7e60a24ca 100644
--- a/goal_src/engine/gfx/wind-h.gc
+++ b/goal_src/engine/gfx/wind-h.gc
@@ -5,3 +5,46 @@
 ;; name in dgo: wind-h
 ;; dgos: GAME, ENGINE
 
+(deftype wind-vector (structure)
+  ((wind-pos vector2w :inline :offset-assert 0)
+   (wind-vel vector2w :inline :offset-assert 8)
+   )
+  :method-count-assert 9
+  :size-assert         #x10
+  :flag-assert         #x900000010
+  )
+
+ (define *wind-scales* (new 'static 'boxed-array uint8 32
+                            #x2 #x5 #x2 #x3
+                            #x2 #x2 #x3 #x10
+                            #xa #x2 #x4 #x2
+                            #x8 #x2 #x2 #x10
+                            #x2 #x2 #x8 #x2
+                            #x10 #x2 #x4 #x10
+                            #xa #x2 #x4 #x2
+                            #x8 #x2 #x2 #x10
+                            )
+   )
+
+(deftype wind-work (basic)
+  ((wind-array  vector  64 :inline      :offset-assert 16)
+   (wind-normal vector  :inline :offset-assert 1040)
+   (wind-temp   vector  :inline :offset-assert 1056)
+   (wind-force  float 64      :offset-assert 1072)
+   (wind-time   uint32          :offset-assert 1328)
+   )
+  :method-count-assert 9
+  :size-assert         #x534
+  :flag-assert         #x900000534
+  )
+
+(define-extern *wind-work* wind-work)
+
+(defun wind-get-hashed-index ((arg0 vector))
+  (logand (+ (the int (-> arg0 data 0))
+             (the int (-> arg0 data 2))
+             (the-as int (-> *wind-work* wind-time))
+             )
+          63
+          )
+  )
diff --git a/goal_src/engine/level/load-boundary.gc b/goal_src/engine/level/load-boundary.gc
index cdff82105c..e1d3e6de50 100644
--- a/goal_src/engine/level/load-boundary.gc
+++ b/goal_src/engine/level/load-boundary.gc
@@ -5,3 +5,23 @@
 ;; name in dgo: load-boundary
 ;; dgos: GAME, ENGINE
 
+
+(defmethod reset! load-state ((obj load-state))
+  (local-vars (v1-1 int))
+  (set! (-> obj want 0 name) #f)
+  (set! (-> obj want 0 display?) #f)
+  (set! (-> obj want 0 force-vis?) #f)
+  (set! (-> obj want 0 force-inside?) #f)
+  (set! (-> obj want 1 name) #f)
+  (set! (-> obj want 1 display?) #f)
+  (set! (-> obj want 1 force-vis?) #f)
+  (set! (-> obj want 1 force-inside?) #f)
+  (set! (-> obj command-list) '())
+  (set! v1-1 0)
+  (while (< v1-1 256)
+   (set! (-> obj object-name v1-1) #f)
+   (set! (-> obj object-status v1-1) (the basic 0))
+   (+! v1-1 1)
+   )
+  obj
+  )
diff --git a/goal_src/engine/physics/dynamics-h.gc b/goal_src/engine/physics/dynamics-h.gc
index f966bb7b07..34cfa35528 100644
--- a/goal_src/engine/physics/dynamics-h.gc
+++ b/goal_src/engine/physics/dynamics-h.gc
@@ -5,3 +5,49 @@
 ;; name in dgo: dynamics-h
 ;; dgos: GAME, ENGINE
 
+;; 1 / 300.
+(defconstant TICKS_TO_SECONDS (the-as float #x3b5a740e))
+
+(deftype dynamics (basic)
+  ((name           basic          :offset-assert 4)
+   (gravity-max    float         :offset-assert 8) ;; meters
+   (gravity-length float         :offset-assert 12) ;; meters
+   (gravity        vector :inline :offset-assert 16)
+   (gravity-normal vector :inline :offset-assert 32)
+   (walk-distance  float         :offset-assert 48)  ;meters
+   (run-distance   float         :offset-assert 52) ; meters
+   )
+  :method-count-assert 9
+  :size-assert         #x38
+  :flag-assert         #x900000038
+  )
+
+(defun time-to-apex ((arg0 float) (arg1 float))
+  (the int (/ arg0 (- (* TICKS_TO_SECONDS arg1)))) 
+  )
+
+(defun time-to-ground ((velocity float) (gravity float) (height float))
+  "How long to fall from height?"
+  (local-vars (v0-0 int) (position float))
+  (set! position 0.000000)
+  (set! v0-0 0)
+  ;; loop in ticks until below the ground.
+  (while (< (- height) position)
+   (set! velocity (- velocity (* TICKS_TO_SECONDS gravity)))
+   (+! position (* TICKS_TO_SECONDS velocity))
+   (+! v0-0 1)
+   )
+  v0-0
+  )
+
+(define *standard-dynamics*
+    (new 'static 'dynamics
+         :name 'standard
+         :gravity-max 163840.000000
+         :gravity-length 245760.000000
+         :gravity  (new 'static 'vector :y 245760.000000 :w 1.000000)
+         :gravity-normal (new 'static 'vector :y 1.000000 :w 1.000000)
+         :walk-distance 8192.000000
+         :run-distance 20480.000000
+         )
+  )
diff --git a/goal_src/engine/ps2/memcard-h.gc b/goal_src/engine/ps2/memcard-h.gc
index d5ffc9687b..2d2e89e9dc 100644
--- a/goal_src/engine/ps2/memcard-h.gc
+++ b/goal_src/engine/ps2/memcard-h.gc
@@ -5,3 +5,60 @@
 ;; name in dgo: memcard-h
 ;; dgos: GAME, ENGINE
 
+(deftype mc-handle (int32)
+  ()
+  :flag-assert #x900000004
+  )
+
+(deftype mc-file-info (structure)
+  ((present               int32      :offset-assert 0)
+   (blind-data            float 16 :offset-assert 4)
+   (blind-data-int8       int8 64 :offset 4)
+   (level-index           int32      :offset 4)
+   (fuel-cell-count       float      :offset 8)
+   (money-count           float      :offset 12)
+   (buzzer-count          float      :offset 16)
+   (completion-percentage float      :offset 20)
+   (minute                uint8      :offset 24)
+   (hour                  uint8      :offset 25)
+   (week                  uint8      :offset 26)
+   (day                   uint8      :offset 27)
+   (month                 uint8      :offset 28)
+   (year                  uint8      :offset 29)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x44
+  :flag-assert         #x900000044
+  )
+
+(deftype mc-slot-info (structure)
+  ((handle       int32     :offset-assert 0)
+   (known        int32     :offset-assert 4)
+   (formatted    int32     :offset-assert 8)
+   (inited       int32     :offset-assert 12)
+   (last-file    int32     :offset-assert 16)
+   (mem-required int32     :offset-assert 20)
+   (mem-actual   int32     :offset-assert 24)
+   (file         mc-file-info 4 :inline :offset-assert 28)
+   )
+  :pack-me
+  :method-count-assert 9
+  :size-assert         #x12c
+  :flag-assert         #x90000012c
+  )
+
+(defun mc-sync ()
+  "Block here, waiting for the memory card to finish being read/written.
+   Note - this will freeze the entire game, so this should not be used
+   outside of debugging."
+  (local-vars (v0-0 int))
+  (set! v0-0 0)
+  (while (zero? v0-0)
+    ;; run the memory card state machine (in C Kenrel)
+    (mc-run)
+    ;; see if we got a good response
+    (set! v0-0 (mc-check-result))
+    )
+  v0-0
+  )
diff --git a/goal_src/engine/target/surface-h.gc b/goal_src/engine/target/surface-h.gc
index 7d5ec044a2..e1a7426476 100644
--- a/goal_src/engine/target/surface-h.gc
+++ b/goal_src/engine/target/surface-h.gc
@@ -4,4 +4,3 @@
 ;; name: surface-h.gc
 ;; name in dgo: surface-h
 ;; dgos: GAME, ENGINE
-
diff --git a/goal_src/kernel-defs.gc b/goal_src/kernel-defs.gc
index 332329e896..d5fd488bfd 100644
--- a/goal_src/kernel-defs.gc
+++ b/goal_src/kernel-defs.gc
@@ -80,13 +80,13 @@
 (define-extern dgo-load (function string kheap int int none))
 (define-extern link-begin (function pointer string int kheap int int))
 (define-extern link-resume (function int))
-;; mc-run
+(define-extern mc-run (function none))
 ;; mc-format
 ;; mc-unformat
 ;; mc-create-file
 ;; mc-save
 ;; mc-load
-;; mc-check-result
+(define-extern mc-check-result (function int))
 ;; mc-get-slot-info
 ;; mc-makefile
 ;; kset-language
diff --git a/scripts/decomp_progress.py b/scripts/decomp_progress.py
index 45b0d431ca..a21326a942 100644
--- a/scripts/decomp_progress.py
+++ b/scripts/decomp_progress.py
@@ -41,7 +41,7 @@ def main():
 
 	file_stats = []
 	total_gc_files = 0
-	excluded_files = {"all_files.gc", "goal-lib.gc"}
+	excluded_files = {"all_files.gc", "goal-lib.gc", "ocean-trans-tables.gc", "ocean-frames.gc"}
 
 
 	for fn in all_files:
diff --git a/test/decompiler/test_DataParser.cpp b/test/decompiler/test_DataParser.cpp
index cb05cfbf44..bbc1d4deab 100644
--- a/test/decompiler/test_DataParser.cpp
+++ b/test/decompiler/test_DataParser.cpp
@@ -216,4 +216,129 @@ TEST_F(DataDecompTest, VifDisasmArray) {
       "  (new 'static 'vif-disasm-element :mask #x7f :tag #x1 :print #x2 :string1 \"stcycl\")\n"
       "  (new 'static 'vif-disasm-element :mask #x7f :tag #x2 :print #x1 :string1 \"offset\" "
       "      :string2 \"offset\"))");
+}
+
+TEST_F(DataDecompTest, ContinuePoint) {
+  std::string input =
+      "    .type continue-point\n"
+      "L63:\n"
+      "    .word L69\n"
+      "    .symbol finalboss\n"
+      "    .word 0x0\n"
+      "    .word 0x4b303728\n"
+      "    .word 0x4a073f00\n"
+      "    .word 0xcb94152d\n"
+      "    .word 0x3f800000\n"
+      "    .word 0x0\n"
+      "    .word 0x3f3b851f\n"
+      "    .word 0x0\n"
+      "    .word 0x3f2e425b\n"
+      "    .word 0x4b2faddf\n"
+      "    .word 0x4a0869de\n"
+      "    .word 0xcb94485e\n"
+      "    .word 0x3f800000\n"
+      "    .word 0x3f169ad4\n"
+      "    .word 0x0\n"
+      "    .word 0xbf4ef9db\n"
+      "    .word 0x3ddbf488\n"
+      "    .word 0x3f7db8bb\n"
+      "    .word 0x3d9ff2e5\n"
+      "    .word 0x3f4d288d\n"
+      "    .word 0xbe07fcb9\n"
+      "    .word 0x3f15460b\n"
+      "    .word L64\n"
+      "    .symbol fin\n"
+      "    .symbol finalboss\n"
+      "    .symbol display\n"
+      "    .symbol citadel\n"
+      "    .symbol special\n"
+      "    .word 0x0\n"
+      "L64: (offset 2)\n"
+      "    .word L65\n"
+      "    .empty-list\n"
+      "L65: (offset 2)\n"
+      "    .symbol special\n"
+      "    .word L66\n"
+      "L66: (offset 2)\n"
+      "    .word L68\n"
+      "    .word L67\n"
+      "L67: (offset 2)\n"
+      "    .symbol #t\n"
+      "    .empty-list\n"
+      "    .type string\n"
+      "L68:\n"
+      "    .word 0x10\n"
+      "    .word 0x62746963\n"
+      "    .word 0x6978652d\n"
+      "    .word 0x6c702d74\n"
+      "    .word 0x342d7461\n"
+      "    .word 0x0\n"
+      "    .word 0x0\n"
+      "    .type string\n"
+      "L69:\n"
+      "    .word 0xf\n"
+      "    .word 0x616e6966\n"
+      "    .word 0x736f626c\n"
+      "    .word 0x74732d73\n"
+      "    .word 0x747261";
+  auto parsed = parse_data(input);
+  auto decomp =
+      decompile_at_label_guess_type(parsed.label("L63"), parsed.labels, {parsed.words}, dts->ts);
+  check_forms_equal(decomp.print(),
+                    "(new 'static 'continue-point\n"
+                    "     :name \"finalboss-start\"\n"
+                    "     :level 'finalboss\n"
+                    "     :trans (new 'static 'vector\n"
+                    "                 :x 11548456.000000\n"
+                    "                 :y 2215872.000000\n"
+                    "                 :z -19409498.000000\n"
+                    "                 :w 1.000000\n"
+                    "                 )\n"
+                    "     :quat (new 'static 'vector\n"
+                    "                :y (the-as float #x3f3b851f)\n"
+                    "                :w (the-as float #x3f2e425b)\n"
+                    "                )\n"
+                    "     :camera-trans (new 'static 'vector\n"
+                    "                        :x 11513311.000000\n"
+                    "                        :y (the-as float #x4a0869de)\n"
+                    "                        :z -19435708.000000\n"
+                    "                        :w 1.000000\n"
+                    "                        )\n"
+                    "     :camera-rot (new 'static 'array 'float 9\n"
+                    "                      (the-as float #x3f169ad4)\n"
+                    "                      0.000000\n"
+                    "                      (the-as float #xbf4ef9db)\n"
+                    "                      (the-as float #x3ddbf488)\n"
+                    "                      (the-as float #x3f7db8bb)\n"
+                    "                      (the-as float #x3d9ff2e5)\n"
+                    "                      (the-as float #x3f4d288d)\n"
+                    "                      (the-as float #xbe07fcb9)\n"
+                    "                      (the-as float #x3f15460b)\n"
+                    "                      )\n"
+                    "     :load-commands (('special \"citb-exit-plat-4\" #t))\n"
+                    "     :vis-nick 'fin\n"
+                    "     :lev0 'finalboss\n"
+                    "     :disp0 'display\n"
+                    "     :lev1 'citadel\n"
+                    "     :disp1 'special\n"
+                    "     )");
+}
+
+TEST_F(DataDecompTest, FloatArray) {
+  std::string input =
+      "    .type continue-point\n"
+      "L63:\n"
+      "    .word 0x3f800000\n"
+      "    .word 0x0\n"
+      "    .word 0x3f800000\n"
+      "    .word 0x0\n"
+      "    .word 0x3f800000\n"
+      "    .word 0x0\n"
+      "    .word 0x3f800000\n\n";
+  auto parsed = parse_data(input);
+  auto decomp = decompile_at_label_with_hint({"(pointer float)", true, 7}, parsed.label("L63"),
+                                             parsed.labels, {parsed.words}, *dts);
+  check_forms_equal(decomp.print(),
+                    "(new 'static 'array 'float 7\n"
+                    "1.0 0.0 1.0 0.0 1.0 0.0 1.0)");
 }
\ No newline at end of file
diff --git a/test/decompiler/test_FormExpressionBuild.cpp b/test/decompiler/test_FormExpressionBuild.cpp
index 730a6813d4..97f868b451 100644
--- a/test/decompiler/test_FormExpressionBuild.cpp
+++ b/test/decompiler/test_FormExpressionBuild.cpp
@@ -2534,4 +2534,37 @@ TEST_F(FormRegressionTest, ExprAssert) {
 
   std::string expected = "(begin (if (not arg0) (format (quote #t) \"A ~A\" arg1)) 0)";
   test_with_expr(func, type, expected, false, "", {{"L17", "A ~A"}});
-}
\ No newline at end of file
+}
+//
+// TEST_F(FormRegressionTest, ExprTerminal2) {
+//  std::string func =
+//      "sll r0, r0, 0\n"
+//      "L29:\n"
+//      "    daddiu sp, sp, -16\n"
+//      "    sd fp, 8(sp)\n"
+//      "    or fp, t9, r0\n"
+//
+//      //"    lwc1 f0, L71(fp)\n"
+//      "    mtc1 f0, r0\n"
+//      "    mtc1 f1, a0\n"
+//      "    mul.s f0, f0, f1\n"
+//      "    mtc1 f1, a1\n"
+//      "    sub.s f0, f0, f1\n"
+//      "    mtc1 f1, a2\n"
+//      "    div.s f0, f0, f1\n"
+//      "    sqrt.s f0, f0\n"
+//      "    mtc1 f1, a1\n"
+//      "    mtc1 f2, a2\n"
+//      "    mul.s f3, f0, f0\n"
+//      "    mul.s f2, f2, f3\n"
+//      "    add.s f1, f1, f2\n"
+//      "    sub.s f0, f0, f1\n"
+//      "    mfc1 v0, f0\n"
+//      "    ld fp, 8(sp)\n"
+//      "    jr ra\n"
+//      "    daddiu sp, sp, 16\n";
+//  std::string type = "(function float float float float float)";
+//
+//  std::string expected = "(begin (if (not arg0) (format (quote #t) \"A ~A\" arg1)) 0)";
+//  test_with_expr(func, type, expected, false, "", {{"L17", "A ~A"}});
+//}
\ No newline at end of file