From e7bb0fb68d254e6a82f6a86ea4771e2cafb8eb46 Mon Sep 17 00:00:00 2001 From: Tyler Wilding Date: Sun, 16 Oct 2022 18:09:15 -0400 Subject: [PATCH] d/jak2: decompile `ambient` | `speech` and `bigmap-data` (#1954) fma-sphere not completed due to #1888 --- .gitignore | 1 + .vscode/extensions.json | 9 + decompiler/config/jak2/all-types.gc | 258 +- decompiler/config/jak2/label_types.jsonc | 3 +- decompiler/config/jak2/stack_structures.jsonc | 17 +- decompiler/config/jak2/type_casts.jsonc | 67 + decompiler/util/data_decompile.cpp | 62 + goal_src/jak2/engine/ambient/ambient-h.gc | 32 +- goal_src/jak2/engine/ambient/ambient.gc | 472 + goal_src/jak2/engine/anim/fma-sphere.gc | 147 +- goal_src/jak2/engine/game/game-info.gc | 2 +- goal_src/jak2/engine/game/main-h.gc | 4 +- .../jak2/engine/gfx/generic/generic-vu1-h.gc | 8 +- goal_src/jak2/engine/gfx/lightning-h.gc | 19 +- .../process-drawable/process-drawable-h.gc | 2 + goal_src/jak2/engine/sound/speech-h.gc | 74 +- goal_src/jak2/engine/sound/speech.gc | 489 + goal_src/jak2/engine/target/target-h.gc | 1 - goal_src/jak2/engine/ui/bigmap-data.gc | 15397 +++++++++++++++ goal_src/jak2/engine/ui/bigmap-h.gc | 93 +- goal_src/jak2/levels/common/elec-gate.gc | 24 +- .../jak2/engine/ambient/ambient-h_REF.gc | 22 +- .../jak2/engine/ambient/ambient_REF.gc | 563 + .../engine/gfx/generic/generic-vu1-h_REF.gc | 2 +- .../jak2/engine/gfx/lightning-h_REF.gc | 18 +- .../reference/jak2/engine/math/matrix_REF.gc | 1 + .../jak2/engine/sound/speech-h_REF.gc | 52 +- .../reference/jak2/engine/sound/speech_REF.gc | 521 + .../jak2/engine/target/target-darkjak_REF.gc | 6 +- .../jak2/engine/ui/bigmap-data_REF.gc | 15399 ++++++++++++++++ .../reference/jak2/engine/ui/bigmap-h_REF.gc | 42 +- .../jak2/levels/common/elec-gate_REF.gc | 24 +- 32 files changed, 33516 insertions(+), 315 deletions(-) create mode 100644 .vscode/extensions.json create mode 100644 test/decompiler/reference/jak2/engine/ambient/ambient_REF.gc create mode 100644 test/decompiler/reference/jak2/engine/sound/speech_REF.gc create mode 100644 test/decompiler/reference/jak2/engine/ui/bigmap-data_REF.gc diff --git a/.gitignore b/.gitignore index e5568db9e..54b409f92 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +28,7 @@ savestate-out/ savestate_out/ failures/ ee-results*.json +search-results.json .env /search-results.json diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 000000000..cadc99d8a --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations. + // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp + + // List of extensions which should be recommended for users of this workspace. + "recommendations": ["opengoal.opengoal", "naumovs.color-highlight"], + // List of extensions recommended by VS Code that should not be recommended for users of this workspace. + "unwantedRecommendations": [] +} diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index a311aee67..1d4dd6846 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -1646,7 +1646,7 @@ (define-extern matrix-rotate-yzx! (function matrix vector matrix)) (define-extern matrix-rotate-yxy! (function matrix vector matrix)) (define-extern matrix-rotate-yx! (function matrix float float matrix)) -(define-extern matrix-axis-sin-cos-vu! (function matrix vector float float none)) +(define-extern matrix-axis-sin-cos-vu! "@unused" (function matrix vector float float none)) (define-extern matrix-axis-sin-cos! (function matrix vector float float matrix)) (define-extern matrix-axis-angle! (function matrix vector float matrix)) (define-extern matrix-lerp! (function matrix matrix matrix float matrix)) @@ -7483,27 +7483,27 @@ ) (deftype bigmap-compressed-layers (structure) - ((data uint32 20 :offset-assert 0 :score -1) - (layer0 uint32 :offset 0) - (layer1 uint32 :offset 4) - (layer2 uint32 :offset 8) - (layer3 uint32 :offset 12) - (layer4 uint32 :offset 16) - (layer5 uint32 :offset 20) - (layer6 uint32 :offset 24) - (layer7 uint32 :offset 28) - (layer8 uint32 :offset 32) - (layer9 uint32 :offset 36) - (layer10 uint32 :offset 40) - (layer11 uint32 :offset 44) - (layer12 uint32 :offset 48) - (layer13 uint32 :offset 52) - (layer14 uint32 :offset 56) - (layer15 uint32 :offset 60) - (layer16 uint32 :offset 64) - (layer17 uint32 :offset 68) - (layer18 uint32 :offset 72) - (layer19 uint32 :offset 76) + ((data (pointer uint32) 20 :offset-assert 0 :score -1) + (layer0 (pointer uint32) :offset 0) + (layer1 (pointer uint32) :offset 4) + (layer2 (pointer uint32) :offset 8) + (layer3 (pointer uint32) :offset 12) + (layer4 (pointer uint32) :offset 16) + (layer5 (pointer uint32) :offset 20) + (layer6 (pointer uint32) :offset 24) + (layer7 (pointer uint32) :offset 28) + (layer8 (pointer uint32) :offset 32) + (layer9 (pointer uint32) :offset 36) + (layer10 (pointer uint32) :offset 40) + (layer11 (pointer uint32) :offset 44) + (layer12 (pointer uint32) :offset 48) + (layer13 (pointer uint32) :offset 52) + (layer14 (pointer uint32) :offset 56) + (layer15 (pointer uint32) :offset 60) + (layer16 (pointer uint32) :offset 64) + (layer17 (pointer uint32) :offset 68) + (layer18 (pointer uint32) :offset 72) + (layer19 (pointer uint32) :offset 76) ) :method-count-assert 9 :size-assert #x50 @@ -7585,6 +7585,18 @@ ;; settings-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defenum language-enum + :type int64 + (english) + (french) + (german) + (spanish) + (italian) + (japanese) + (korean) + (uk-english) + ) + (defenum game-feature :type uint64 :bitfield #t @@ -7616,18 +7628,6 @@ (darkjak-giant) (board-training)) -(defenum language-enum - :type int64 - (english) - (french) - (german) - (spanish) - (italian) - (japanese) - (korean) - (uk-english) - ) - (deftype user-setting-data (structure) ((border-mode symbol) (process-mask process-mask) @@ -8278,7 +8278,9 @@ (actor-marks) (special-fma-spheres) (scene-controls-7) - (scene-controls-8)) + (scene-controls-8) + (display-controls) + ) ;; ---main-h:scene-controls (define-extern *display-scene-control* scene-controls) @@ -8669,8 +8671,6 @@ ) ) -(declare-type drawable-inline-array-region-prim drawable) - (deftype drawable-tree-region-prim (drawable-tree) ((name basic :offset 8) (data2 drawable-inline-array :dynamic :offset 32 :score 1)) @@ -11313,7 +11313,7 @@ (deftype gcf-control (structure) ((matrix matrix :inline :offset-assert 0) (giftag generic-gif-tag :inline :offset-assert 64) - (adnops uint32 2 :offset-assert 80) ;; guess + (adnops gs-adcmd 2 :inline :offset-assert 80) (num-strips uint32 :offset 76) (num-dps uint32 :offset 92) (kick-offset uint32 :offset 108) @@ -12619,9 +12619,6 @@ ) ;; ---memcard-h:mc-status-code -(declare-type entity-perm-array inline-array-class) -(declare-type continue-point basic) -(declare-type game-save basic) ;; +++game-info-h:game-secrets (defenum game-secrets @@ -12670,6 +12667,10 @@ (reverse-race-3) ) +(declare-type entity-perm-array inline-array-class) +(declare-type continue-point basic) +(declare-type game-save basic) +(declare-type talker-speech-class structure) (declare-type entity-perm structure) (deftype game-info (basic) ((mode symbol :offset-assert 4) @@ -12714,7 +12715,7 @@ (sub-task-list (array game-task-node-info) :offset-assert 252) (mission-list (array game-task-node-info) :offset-assert 256) (task-counter uint32 :offset-assert 260) - (unknown-pad6 (array uint16) :offset-assert 264) + (unknown-pad6 (array uint16) :offset-assert 264) (level-opened uint8 32 :offset-assert 268) (total-deaths int32 :offset-assert 300) (continue-deaths int32 :offset-assert 304) @@ -12953,38 +12954,37 @@ :method-count-assert 14 :size-assert #x18 :flag-assert #xe00000018 - ;; field on-close uses ~A with a signed load (:methods - (talker-speech-class-method-9 () none 9) + (talker-speech-class-method-9 (_type_) symbol 9) (talker-speech-class-method-10 (_type_) none 10) - (talker-speech-class-method-11 () none 11) + (talker-speech-class-method-11 (_type_) none 11) (talker-speech-class-method-12 (_type_ int) none 12) (talker-speech-class-method-13 (_type_ int) none 13) ) ) (deftype talker (process) - ((trans vector :inline :offset-assert 128) + ((trans vector :inline :offset-assert 128 :score 999) (message talker-speech-class :offset-assert 144) (total-time time-frame :offset-assert 152) (total-off-time time-frame :offset-assert 160) (start-time time-frame :offset-assert 168) (state-time time-frame :offset-assert 176) - (voicebox uint64 :offset-assert 184) - (voice-id uint32 :offset-assert 192) - (message-id uint32 :offset-assert 196) + (voicebox handle :offset-assert 184) + (voice-id sound-id :offset-assert 192) + (message-id sound-id :offset-assert 196) (region region :offset-assert 200) (interp float :offset-assert 204) - (save? basic :offset-assert 208) + (save? symbol :offset-assert 208) ) :method-count-assert 18 :size-assert #xd4 :flag-assert #x12006000d4 (:methods - (talker-method-14 () _type_ :state 14) - (talker-method-15 () none 15) - (talker-method-16 () none 16) - (talker-method-17 () none 17) + (idle () _type_ :state 14) + (active () _type_ :state 15) + (exit () _type_ :state 16) + (talker-method-17 (_type_) none 17) ) ) @@ -12994,34 +12994,46 @@ ;; speech-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +++speech-h:speech-type-flag (defenum speech-type-flag :type uint8 :bitfield #t (random-order 0) ) +;; ---speech-h:speech-type-flag (deftype speech-type-info (structure) - ((channel uint8) - (flags speech-type-flag) - (priority int8) - (request-timeout uint16) - (min-delay uint16) - (max-delay uint16) - (delay uint16) - (play-index int16) - (list (array string)) + ((channel uint8 :offset-assert 0) + (flags speech-type-flag :offset-assert 1) + (priority int8 :offset-assert 2) + (request-timeout uint16 :offset-assert 4) + (min-delay uint16 :offset-assert 6) + (max-delay uint16 :offset-assert 8) + (delay uint16 :offset-assert 10) + (play-index int16 :offset-assert 12) + (list (array string) :offset-assert 16) ) :method-count-assert 9 :size-assert #x14 :flag-assert #x900000014 - ;; Failed to read fields. ) +;; +++speech-h:speech-type +(defenum speech-type + :type int8 + :bitfield #t + (speech-type-0 0) + (speech-type-1 1) + (speech-type-2 2) + (speech-type-3 3) + ) +;; ---speech-h:speech-type + (deftype speech-request (structure) - ((handle uint64 :offset-assert 0) + ((handle handle :offset-assert 0) (time time-frame :offset-assert 8) (priority float :offset-assert 16) - (speech-type int8 :offset-assert 20) + (speech-type speech-type :offset-assert 20) ) :pack-me :method-count-assert 9 @@ -13029,54 +13041,56 @@ :flag-assert #x900000015 ) +;; +++speech-h:speech-channel-flag (defenum speech-channel-flag :type uint8 :bitfield #t (disable 0) ) +;; ---speech-h:speech-channel-flag (deftype speech-channel (structure) - ((flags speech-channel-flag) - (gui-channel gui-channel) - (delay uint16) - (id uint32) - (update-time time-frame :offset-assert 8) - (start-time time-frame) - (end-time time-frame) - (request speech-request :inline) - (last-request speech-request :inline) - (target-pos vector :inline) - (speech-table uint32) + ((flags speech-channel-flag :offset-assert 0) + (gui-channel gui-channel :offset-assert 1) + (delay uint16 :offset-assert 2) + (id sound-id :offset-assert 4) + (update-time time-frame :offset-assert 8) + (start-time time-frame :offset-assert 16) + (end-time time-frame :offset-assert 24) + (request speech-request :inline :offset-assert 32) + (last-request speech-request :inline :offset-assert 56) + (target-pos vector :inline :offset-assert 80) + (speech-table (pointer speech-type-info) :offset-assert 96) ) :method-count-assert 14 :size-assert #x64 :flag-assert #xe00000064 (:methods - (speech-channel-method-9 () none 9) - (speech-channel-method-10 () none 10) - (speech-channel-method-11 () none 11) - (speech-channel-method-12 () none 12) - (speech-channel-method-13 () none 13) + (speech-channel-method-9 (_type_ process-drawable speech-type) none 9) + (speech-channel-method-10 (_type_ handle) none 10) + (speech-channel-method-11 (_type_) none 11) + (speech-channel-method-12 (_type_) none 12) + (speech-channel-method-13 (_type_) none 13) ) ) (deftype speech-control (structure) ((channel-array speech-channel 2 :inline :offset-assert 0) - (speech-table speech-type-info 57 :offset-assert 224) ;; guess + (speech-table speech-type-info 57 :offset-assert 224) ) :method-count-assert 17 :size-assert #x1c4 :flag-assert #x11000001c4 (:methods - (speech-control-method-9 () none 9) + (speech-control-method-9 (_type_) none 9) (speech-control-method-10 (_type_ int speech-type-info) none 10) (speech-control-method-11 (_type_) none 11) - (speech-control-method-12 () none 12) - (speech-control-method-13 () none 13) - (speech-control-method-14 () none 14) - (speech-control-method-15 () none 15) - (speech-control-method-16 () none 16) + (speech-control-method-12 (_type_ process-drawable speech-type) none 12) + (speech-control-method-13 (_type_ handle) none 13) + (speech-control-method-14 (_type_) none 14) + (speech-control-method-15 (_type_ process-drawable) none 15) + (speech-control-method-16 (_type_) none 16) ) ) @@ -13795,9 +13809,9 @@ (flags lightning-spec-flags :offset-assert 8) (rand-func uint8 :offset-assert 10) (adjust-distance uint8 :offset-assert 11) - (start-color uint32 :offset-assert 12) - (end-color uint32 :offset-assert 16) - (fade-to-color uint32 :offset-assert 20) + (start-color rgba :offset-assert 12) + (end-color rgba :offset-assert 16) + (fade-to-color rgba :offset-assert 20) (fade-start-factor float :offset-assert 24) (fade-time float :offset-assert 28) (texture uint32 :offset-assert 32) @@ -13838,8 +13852,8 @@ (line vector-array :offset-assert 128) (meet vector-array :offset-assert 132) (path vector-array :offset-assert 136) - (start-color uint32 :offset-assert 140) - (end-color uint32 :offset-assert 144) + (start-color rgba :offset-assert 140) + (end-color rgba :offset-assert 144) ) :method-count-assert 9 :size-assert #x94 @@ -13848,7 +13862,7 @@ (deftype lightning-control (basic) ((spec lightning-spec :offset-assert 4) - (process process :offset-assert 8) + (process (pointer process) :offset-assert 8) (state lightning-state :inline :offset-assert 16) ) :method-count-assert 14 @@ -27221,7 +27235,7 @@ ;; ambient ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(define-extern can-display-query? (function symbol)) +(define-extern can-display-query? (function process string float symbol)) (define-extern talker-surpress! (function none)) (define-extern talker-displayed? (function symbol)) (define-extern kill-current-talker (function symbol pair symbol none)) ;; see (exit play-anim scene-player) @@ -27248,6 +27262,7 @@ ;; fma-sphere ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +++fma-sphere:fma-sphere-mode (defenum fma-sphere-mode :type uint32 :bitfield #t @@ -27255,16 +27270,18 @@ (kill-once 1) (danger 2) (deadly-overlap 3)) +;; ---fma-sphere:fma-sphere-mode (deftype fma-sphere (process-drawable) - ((first-time? symbol :offset-assert 200) - (mode fma-sphere-mode :offset-assert 204) - (track-handle handle :offset-assert 208) - (track-joint int32 :offset-assert 216) - (attack-id uint32 :offset-assert 220) - (duration time-frame :offset-assert 224) - (sphere sphere :inline :offset-assert 240) - (danger traffic-danger-info :inline :offset-assert 256) + ((root-override collide-shape :offset 128 :score 999) + (first-time? symbol :offset-assert 200) + (mode fma-sphere-mode :offset-assert 204) + (track-handle handle :offset-assert 208) + (track-joint int32 :offset-assert 216) + (attack-id uint32 :offset-assert 220) + (duration time-frame :offset-assert 224) + (sphere sphere :inline :offset-assert 240) + (danger traffic-danger-info :inline :offset-assert 256) ) :method-count-assert 21 :size-assert #x136 @@ -27274,7 +27291,8 @@ ) ) -(define-extern fma-sphere-init-by-other (function fma-sphere-mode process-drawable int time-frame object object fma-sphere)) +;; TODO - takes vectors, but hits an assertion! +(define-extern fma-sphere-init-by-other (function fma-sphere-mode process-drawable int time-frame object object fma-sphere :behavior fma-sphere)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; script ;; @@ -27395,7 +27413,6 @@ ;; lightning ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype lightning-globals (structure) ((gcf-buf uint16 :offset-assert 0) (vtx-buf uint16 :offset-assert 2) @@ -27404,22 +27421,21 @@ :size-assert #x4 :flag-assert #x900000004 ) -|# (define-extern *lightning-spec-id-table* (array lightning-spec)) -;; (define-extern *lightning-gcf* object) -;; (define-extern lightning-fractal-gen function) -;; (define-extern lightning-uniform-gen function) -;; (define-extern lightning-trail-uniform-gen function) -;; (define-extern lightning-trail-fractal-gen function) -;; (define-extern gs-packed-rgba-lerp! function) -;; (define-extern rgba-lerp function) -;; (define-extern lightning-fade function) -;; (define-extern lightning-update function) -;; (define-extern lightning-draw function) -;; (define-extern lightning-start function) -;; (define-extern *lightning-globals* object) -;; (define-extern *lightning* object) +(define-extern *lightning-gcf* gcf-control) +(define-extern lightning-fractal-gen (function (inline-array vector) int int float lightning-spec none)) +(define-extern lightning-uniform-gen (function (inline-array vector) int int float lightning-spec none)) +(define-extern lightning-trail-uniform-gen (function (inline-array vector) (inline-array vector) float int symbol)) +(define-extern lightning-trail-fractal-gen (function (inline-array vector) (inline-array vector) int int float lightning-spec none)) +(define-extern gs-packed-rgba-lerp! (function gs-packed-rgba rgba rgba float gs-packed-rgba)) +(define-extern rgba-lerp (function rgba rgba rgba rgba)) +(define-extern lightning-fade (function lightning-control int :behavior process)) +(define-extern lightning-update (function lightning-control symbol)) +(define-extern lightning-draw (function dma-buffer lightning-control lightning-globals symbol)) +(define-extern lightning-start (function float float (pointer process))) +(define-extern *lightning-globals* lightning-globals) +(define-extern *lightning* symbol) (define-extern lightning-draw-all (function none)) (define-extern unlink-lightning-spec-by-heap (function kheap none)) @@ -28227,7 +28243,7 @@ ;; (define-extern remote-track function) ;; (define-extern cam-remote state) ;; (define-extern voicebox-init-by-other function) ;; (function vector handle none :behavior voicebox) -;; (define-extern voicebox-spawn function) ;; (function process vector (pointer process)) +(define-extern voicebox-spawn (function process-drawable vector (pointer process))) ;; (function process vector (pointer process)) ;; (define-extern judge-init-by-other function) ;; (define-extern judge-spawn function) diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index dfdba5631..a75f1496f 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -437,5 +437,6 @@ ["L125", "uint64", true], ["L124", "uint64", true], ["L123", "uint64", true] - ] + ], + "fma-sphere": [["L43", "attack-info"]] } diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc index 89e6269d9..08f62abe7 100644 --- a/decompiler/config/jak2/stack_structures.jsonc +++ b/decompiler/config/jak2/stack_structures.jsonc @@ -999,6 +999,19 @@ "(method 17 sky-work)": [ [16, "vector"] ], - // placeholder - "placeholder-do-not-add-below": [] + "(method 18 drawable-region-face)": [ + [16, "vector"], + [32, "vector"] + ], + // stack casts can't be guessed in a "run in process" (since the arg numbers are shifted?) + "lightning-start": [ + [16, "vector"], + [32, "vector"] + ], + "lightning-trail-fractal-gen": [ + [16, "vector"], + [32, "vector"], + [48, "vector"], + [64, "vector"] + ] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index 303aa85fb..26edbe0ff 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -3638,5 +3638,72 @@ "scene-player-init": [ [[37, 44], "s5", "(array scene)"], [83, "v0", "(array scene)"] + ], + "(trans idle fma-sphere)": [[39, "a2", "process-drawable"]], + "(method 10 talker)": [[29, "t9", "(function process none)"]], + "(exit active talker)": [[19, "s5", "process-drawable"]], + "(method 11 speech-channel)": [ + [66, "v1", "process-drawable"], + [223, "s4", "process-drawable"], + [237, "s4", "process-drawable"], + [240, "s4", "process-drawable"], + [212, "v0", "sound-rpc-set-param"] + ], + "lightning-fractal-gen": [ + [37, "v1", "float"], + [64, "v1", "float"], + [91, "v1", "float"] + ], + "lightning-uniform-gen": [ + [38, "v1", "float"], + [60, "v1", "float"], + [82, "v1", "float"] + ], + "lightning-trail-uniform-gen": [ + [21, "v1", "float"], + [43, "v1", "float"], + [65, "v1", "float"] + ], + "lightning-trail-fractal-gen": [ + [52, "v1", "float"], + [71, "v1", "float"], + [90, "v1", "float"] + ], + "lightning-draw": [ + [[407, 444], "v1", "(inline-array vector)"], + [[66, 76], "v1", "gs-packed-rgba"], + [[101, 112], "v1", "gs-packed-rgba"], + [[134, 143], "a0", "gs-packed-rgba"], + [[149, 159], "a0", "gs-packed-rgba"], + [173, "a1", "gcf-vertex"], + [181, "a1", "gcf-vertex"], + [189, "a1", "gcf-vertex"], + [196, "a1", "gcf-vertex"], + [213, "a2", "gcf-vertex"], + [221, "a2", "gcf-vertex"], + [229, "a2", "gcf-vertex"], + [236, "a0", "gcf-vertex"], + [[255, 264], "a0", "gs-packed-rgba"], + [[270, 280], "a0", "gs-packed-rgba"], + [295, "a2", "gcf-vertex"], + [303, "a2", "gcf-vertex"], + [311, "a2", "gcf-vertex"], + [318, "a0", "gcf-vertex"], + [335, "a2", "gcf-vertex"], + [343, "a2", "gcf-vertex"], + [351, "a2", "gcf-vertex"], + [358, "a0", "gcf-vertex"], + [374, "a2", "gcf-vertex"], + [382, "a2", "gcf-vertex"], + [390, "a2", "gcf-vertex"], + [397, "a0", "gcf-vertex"], + [[472, 487], "a0", "dma-packet"], + [[559, 576], "a0", "dma-packet"], + [[597, 602], "a0", "dma-packet"] + ], + "lightning-draw-all": [ + [39, "v1", "connection"], + [40, "s1", "dma-buffer"], + [[88, 91], "v1", "dma-packet"] ] } diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp index 8ebeece98..b52f87ca2 100644 --- a/decompiler/util/data_decompile.cpp +++ b/decompiler/util/data_decompile.cpp @@ -729,6 +729,68 @@ const std::unordered_map< {{"data", ArrayFieldDecompMeta(TypeSpec("int8"), 1, ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}}, + // kinda want to add regex support now... + {"bigmap-compressed-layers", + {{"layer0", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer1", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer2", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer3", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer4", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer5", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer6", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer7", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer8", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer9", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer10", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer11", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer12", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer13", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer14", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer15", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer16", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer17", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer18", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}, + {"layer19", ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}}, {"lightning-probe-vars", {{"probe-dirs", ArrayFieldDecompMeta(TypeSpec("vector"), 16)}}}, {"nav-mesh", {{"poly-array", ArrayFieldDecompMeta(TypeSpec("nav-poly"), 64)}, diff --git a/goal_src/jak2/engine/ambient/ambient-h.gc b/goal_src/jak2/engine/ambient/ambient-h.gc index 6a61f8790..bd3bc0bda 100644 --- a/goal_src/jak2/engine/ambient/ambient-h.gc +++ b/goal_src/jak2/engine/ambient/ambient-h.gc @@ -5,6 +5,13 @@ ;; name in dgo: ambient-h ;; dgos: ENGINE, GAME +(declare-type talker-speech-class structure) +(define-extern talker-spawn-func (function talker-speech-class process-tree vector region int)) +(define-extern talker-surpress! (function none)) +(declare-type talker process) +(define-extern talker-init (function talker-speech-class vector region none :behavior talker)) +(define-extern voicebox-spawn (function process-drawable vector (pointer process))) + ;; NOTE - for scene (define-extern kill-current-talker (function symbol pair symbol none)) @@ -27,9 +34,9 @@ :size-assert #x18 :flag-assert #xe00000018 (:methods - (talker-speech-class-method-9 () none 9) + (talker-speech-class-method-9 (_type_) symbol 9) (talker-speech-class-method-10 (_type_) none 10) - (talker-speech-class-method-11 () none 11) + (talker-speech-class-method-11 (_type_) none 11) (talker-speech-class-method-12 (_type_ int) none 12) (talker-speech-class-method-13 (_type_ int) none 13) ) @@ -43,22 +50,22 @@ (total-off-time time-frame :offset-assert 160) (start-time time-frame :offset-assert 168) (state-time time-frame :offset-assert 176) - (voicebox uint64 :offset-assert 184) - (voice-id uint32 :offset-assert 192) - (message-id uint32 :offset-assert 196) + (voicebox handle :offset-assert 184) + (voice-id sound-id :offset-assert 192) + (message-id sound-id :offset-assert 196) (region region :offset-assert 200) (interp float :offset-assert 204) - (save? basic :offset-assert 208) + (save? symbol :offset-assert 208) ) :heap-base #x60 :method-count-assert 18 :size-assert #xd4 :flag-assert #x12006000d4 (:methods - (talker-method-14 () _type_ :state 14) - (talker-method-15 () none 15) - (talker-method-16 () none 16) - (talker-method-17 () none 17) + (idle () _type_ :state 14) + (active () _type_ :state 15) + (exit () _type_ :state 16) + (talker-method-17 (_type_) none 17) ) ) @@ -1666,8 +1673,3 @@ ) ) ) - -(define-extern talker-surpress! (function none)) - - - diff --git a/goal_src/jak2/engine/ambient/ambient.gc b/goal_src/jak2/engine/ambient/ambient.gc index bf5785aac..6a63e2c54 100644 --- a/goal_src/jak2/engine/ambient/ambient.gc +++ b/goal_src/jak2/engine/ambient/ambient.gc @@ -9,6 +9,36 @@ ;; DECOMP BEGINS +(defun can-display-query? ((arg0 process) (arg1 string) (arg2 float)) + (let ((a1-3 (gui-control-method-12 + *gui-control* + arg0 + (gui-channel query) + (gui-action play) + (if arg1 + arg1 + (symbol->string (-> arg0 type symbol)) + ) + 0 + arg2 + (new 'static 'sound-id) + ) + ) + ) + (= (gui-control-method-17 *gui-control* a1-3) (gui-action playing)) + ) + ) + +(defun talker-surpress! () + (set! (-> *game-info* hint-play-time) (-> *display* base-clock frame-counter)) + 0 + (none) + ) + +(defun talker-displayed? () + #f + ) + (defun kill-current-talker ((arg0 symbol) (arg1 pair) (arg2 symbol)) (if (not (member 'daxter arg1)) (gui-control-method-16 @@ -71,3 +101,445 @@ 0 (none) ) + +(defun string->talker-speech ((arg0 string)) + (dotimes (s5-0 465) + (let ((s4-0 (-> *talker-speech* s5-0))) + (if (string= arg0 (-> s4-0 name)) + (return s4-0) + ) + ) + ) + (-> *talker-speech* 0) + ) + +(defmethod talker-speech-class-method-9 talker-speech-class ((obj talker-speech-class)) + (and (>= (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) (-> obj pos)) + (>= (-> obj neg) (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) + ) + ) + +(defmethod talker-speech-class-method-10 talker-speech-class ((obj talker-speech-class)) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) (the-as uint #xffff)) + 0 + (none) + ) + +(defmethod talker-speech-class-method-11 talker-speech-class ((obj talker-speech-class)) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) (the-as uint 0)) + 0 + (none) + ) + +(defmethod talker-speech-class-method-12 talker-speech-class ((obj talker-speech-class) (arg0 int)) + (if (>= arg0 0) + (set! (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (* (-> obj speech) 2))) #xfff0 arg0)) + ) + (set! (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (* (-> obj speech) 2))) 0 (- arg0))) + ) + ) + (if (talker-speech-class-method-9 obj) + (talker-spawn-func obj *entity-pool* (target-pos 0) (the-as region #f)) + ) + 0 + (none) + ) + +(defmethod talker-speech-class-method-13 talker-speech-class ((obj talker-speech-class) (arg0 int)) + (if (>= arg0 0) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) #xfff0 arg0)) + ) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) 0 (- arg0))) + ) + ) + 0 + (none) + ) + +(defun talker-spawn-func ((arg0 talker-speech-class) (arg1 process-tree) (arg2 vector) (arg3 region)) + (local-vars (s2-0 int)) + (when (or (not arg0) (zero? (-> arg0 speech)) (not (talker-speech-class-method-9 arg0))) + (set! s2-0 0) + (goto cfg-27) + ) + (if (and (or (not (-> *setting-control* user-current play-hints)) + (= (-> *setting-control* user-current dialog-volume) 0.0) + ) + (logtest? (-> arg0 flags) 1) + ) + (talker-speech-class-method-10 arg0) + ) + (set! s2-0 (gui-control-method-14 *gui-control* (-> arg0 name) (-> arg0 channel) (gui-action none))) + (set! s2-0 (cond + ((zero? s2-0) + (let ((v1-17 (process-spawn talker :init talker-init arg0 arg2 arg3 :to arg1))) + (cond + (v1-17 + (if (nonzero? (-> (the-as talker (-> v1-17 0)) voice-id)) + (the-as int (-> (the-as talker (-> v1-17 0)) voice-id)) + (the-as int (-> (the-as talker (-> v1-17 0)) message-id)) + ) + ) + (else + (empty) + s2-0 + ) + ) + ) + ) + (else + (empty) + s2-0 + ) + ) + ) + (label cfg-27) + s2-0 + ) + +(defbehavior talker-init talker ((arg0 talker-speech-class) (arg1 vector) (arg2 region)) + (set! (-> self trans quad) (-> arg1 quad)) + (let ((v1-2 (shr (the-as int (-> arg0 channel)) 4))) + (if (not (or (or (= v1-2 4) (= v1-2 5)) + (or (not (-> *setting-control* user-current play-hints)) + (= (-> *setting-control* user-current dialog-volume) 0.0) + ) + ) + ) + (set! (-> self voice-id) + (gui-control-method-9 *gui-control* self (-> arg0 channel) (gui-action queue) (-> arg0 name) 81920.0 0) + ) + ) + ) + (when (nonzero? (-> arg0 text-message)) + (let* ((a0-6 *gui-control*) + (t9-1 (method-of-object a0-6 gui-control-method-9)) + (a1-3 self) + (v1-15 (shr (the-as int (-> arg0 channel)) 4)) + ) + (set! (-> self message-id) (t9-1 + a0-6 + a1-3 + (if (or (= v1-15 4) (= v1-15 5)) + (the-as gui-channel (the-as int (-> arg0 channel))) + (gui-channel message) + ) + (gui-action play) + (-> arg0 name) + 81920.0 + 0 + ) + ) + ) + ) + (set! (-> self message) arg0) + (set! (-> self region) arg2) + (set! (-> self total-time) 0) + (set! (-> self total-off-time) 0) + (set! (-> self start-time) (-> self clock frame-counter)) + (set! (-> self voicebox) (the-as handle #f)) + (set! (-> self save?) #f) + (if (logtest? (-> self message flags) 96) + (set! (-> self interp) 0.0) + (set! (-> self interp) 1.0) + ) + (go-virtual idle) + 0 + (none) + ) + +(defmethod deactivate talker ((obj talker)) + (send-event (handle->process (-> obj voicebox)) 'die) + ((the-as (function process none) (find-parent-method talker 10)) obj) + (none) + ) + +(defmethod talker-method-17 talker ((obj talker)) + (let ((gp-0 (new + 'stack + 'font-context + *font-default-matrix* + 36 + 310 + 0.0 + (font-color default-#cddbcd) + (font-flags shadow kerning) + ) + ) + ) + (let ((f0-0 320.0)) + (let ((v1-2 gp-0)) + (set! (-> v1-2 scale) 0.75) + ) + (case (-> obj message channel) + (((gui-channel notice)) + (cond + ((logtest? (-> obj message flags) 128) + (let ((v1-9 gp-0) + (a1-1 36) + (a0-4 140) + ) + (set! (-> v1-9 origin x) (the float a1-1)) + (set! (-> v1-9 origin y) (the float a0-4)) + ) + ) + (else + (let ((v1-10 gp-0)) + (set! (-> v1-10 scale) 0.6) + ) + (let ((v1-11 gp-0) + (a1-2 36) + (a0-6 160) + ) + (set! (-> v1-11 origin x) (the float a1-2)) + (set! (-> v1-11 origin y) (the float a0-6)) + ) + ) + ) + (set! f0-0 160.0) + ) + ) + (let ((v1-14 gp-0)) + (set! (-> v1-14 width) (the float (the-as float #x1b8))) + ) + (let ((v1-15 gp-0)) + (set! (-> v1-15 height) (the float (the-as float #x8c))) + ) + (set! (-> gp-0 flags) (font-flags shadow kerning middle large)) + (if (logtest? (-> obj message flags) 32) + (set! (-> gp-0 alpha) (-> obj interp)) + (set! (-> gp-0 alpha) 1.0) + ) + (when (logtest? (-> obj message flags) 64) + (let ((s4-0 gp-0) + (s3-0 36) + (v1-27 (the int (lerp-scale 400.0 f0-0 (-> obj interp) 0.0 1.0))) + ) + (set! (-> s4-0 origin x) (the float s3-0)) + (set! (-> s4-0 origin y) (the float v1-27)) + ) + ) + ) + (let ((s4-1 print-game-text) + (a0-11 (lookup-text! *common-text* (the-as game-text-id (-> obj message text-message)) #f)) + (a2-3 #f) + (a3-2 44) + (v1-31 (-> obj message channel)) + ) + (s4-1 + a0-11 + gp-0 + a2-3 + a3-2 + (if (or (= v1-31 (gui-channel notice)) (= v1-31 (gui-channel notice-low)) (= v1-31 (gui-channel subtitle))) + 322 + 320 + ) + ) + ) + ) + 0 + (none) + ) + +(defstate idle (talker) + :virtual #t + :code (behavior () + (let ((gp-0 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-0) (the-as time-frame (-> self message delay))) + (suspend) + ) + ) + (case (-> self message channel) + (((gui-channel voicebox)) + (if *target* + (set! (-> self voicebox) (ppointer->handle (voicebox-spawn *target* (target-pos 0)))) + ) + ) + ) + (while (< (- (-> self clock frame-counter) (-> self start-time)) (the-as time-frame (+ (-> self message delay) 300))) + (if (and (or (zero? (-> self voice-id)) (= (gui-control-method-17 *gui-control* (-> self voice-id)) (gui-action play))) + (or (zero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + ) + ) + (go-virtual active) + ) + (suspend) + ) + (go-virtual exit) + (none) + ) + ) + +(defstate active (talker) + :virtual #t + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (if (logtest? (-> self message flags) 1) + (talker-speech-class-method-10 (-> self message)) + ) + (set-setting! 'hint (process->ppointer self) 0 0) + (set-setting! 'speech-control #f 0 0) + (if (nonzero? (-> self voice-id)) + (gui-control-method-16 + *gui-control* + (gui-action play) + (-> self voice-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (when (and (nonzero? (-> self voice-id)) (logtest? (-> self message flags) 2)) + (add-setting! 'music-volume 'rel (-> *setting-control* user-current music-volume-movie) 0) + (add-setting! 'sfx-volume 'rel (-> *setting-control* user-current sfx-movie-volume) 0) + (add-setting! 'dialog-volume 'rel (-> *setting-control* user-current dialog-volume-hint) 0) + ) + (if (logtest? (-> self message flags) 4) + (auto-save-user) + ) + (apply-settings *setting-control*) + (none) + ) + :exit (behavior () + (let ((gp-0 (-> self message on-close))) + (when gp-0 + (let* ((s5-0 (handle->process (-> self voicebox))) + (v1-5 (if (type? s5-0 process-drawable) + (the-as process-drawable s5-0) + ) + ) + ) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (if v1-5 + (-> v1-5 root trans) + ) + ) + (the-as pair gp-0) + ) + ) + ) + ) + (when (and (logtest? (-> self message flags) 8) (not (-> self save?))) + (set! (-> self save?) #t) + (auto-save-user) + ) + (if (nonzero? (-> self voice-id)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> self voice-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (if (nonzero? (-> self message-id)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> self message-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (remove-setting! 'music-volume) + (remove-setting! 'sfx-volume) + (remove-setting! 'dialog-volume) + (remove-setting! 'hint) + (remove-setting! 'speech-control) + (apply-settings *setting-control*) + (none) + ) + :code (behavior () + (local-vars (v1-43 symbol)) + (let ((gp-1 (zero? (logand (-> self message flags) 2)))) + (while (or (and (nonzero? (-> self voice-id)) + (let ((v1-34 (gui-control-method-17 *gui-control* (-> self voice-id)))) + (or (= v1-34 (gui-action play)) (= v1-34 (gui-action playing))) + ) + (begin + (dotimes (s5-2 4) + (when (and (string-charp= (-> self message name) (the-as (pointer uint8) (-> *sound-iop-info* stream-name s5-2))) + (= (-> self voice-id) (-> *sound-iop-info* stream-id s5-2)) + (logtest? (-> *sound-iop-info* stream-status s5-2) (stream-status ststatus-six)) + ) + (set! v1-43 #f) + (goto cfg-39) + ) + ) + (set! v1-43 #t) + (label cfg-39) + (and v1-43 (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 120))) + ) + ) + (and (nonzero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + (or (< (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self message text-duration))) + (and (logtest? (-> self message flags) 16) (-> self region) (region-method-9 (-> self region) (target-pos 0))) + ) + ) + (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.05)) + ) + (when (and (nonzero? (-> self voice-id)) + (not gp-1) + (zero? (gui-control-method-17 *gui-control* (-> self voice-id))) + ) + (remove-setting! 'music-volume) + (remove-setting! 'sfx-volume) + (remove-setting! 'dialog-volume) + (set! gp-1 #t) + ) + (when (and (nonzero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + (not (paused?)) + ) + (if (logtest? (-> self message flags) 32) + (seek! (-> self interp) 1.0 (* 0.5 (-> self clock seconds-per-frame))) + (seek! (-> self interp) 1.0 (* 4.0 (-> self clock seconds-per-frame))) + ) + (talker-method-17 self) + ) + (suspend) + ) + ) + (when (and (nonzero? (-> self message-id)) (logtest? (-> self message flags) 96)) + (while (!= (-> self interp) 0.0) + (if (logtest? (-> self message flags) 32) + (seek! (-> self interp) 0.0 (* 0.5 (-> self clock seconds-per-frame))) + (seek! (-> self interp) 0.0 (* 4.0 (-> self clock seconds-per-frame))) + ) + (talker-method-17 self) + (suspend) + ) + ) + (when (and (logtest? (-> self message flags) 8) (not (-> self save?))) + (let ((gp-2 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-2) (seconds 1)) + (suspend) + ) + ) + (set! (-> self save?) #t) + (auto-save-user) + ) + (go-virtual exit) + (none) + ) + ) + +(defstate exit (talker) + :virtual #t + :code (the-as (function none :behavior talker) nothing) + ) diff --git a/goal_src/jak2/engine/anim/fma-sphere.gc b/goal_src/jak2/engine/anim/fma-sphere.gc index 082a281f9..e23499af7 100644 --- a/goal_src/jak2/engine/anim/fma-sphere.gc +++ b/goal_src/jak2/engine/anim/fma-sphere.gc @@ -5,9 +5,9 @@ ;; name in dgo: fma-sphere ;; dgos: ENGINE, GAME -;; DECOMP BEGINS - +;; og:ignore-form:(defbehavior fma-sphere-init-by-other +;; +++fma-sphere-mode (defenum fma-sphere-mode :type uint32 :bitfield #t @@ -15,17 +15,25 @@ (kill-once 1) (danger 2) (deadly-overlap 3)) +;; ---fma-sphere-mode + +(declare-type fma-sphere process-drawable) +(define-extern fma-sphere-init-by-other (function fma-sphere-mode process-drawable int time-frame object object fma-sphere :behavior fma-sphere)) + +;; DECOMP BEGINS (deftype fma-sphere (process-drawable) - ((first-time? symbol :offset-assert 200) - (mode fma-sphere-mode :offset-assert 204) - (track-handle handle :offset-assert 208) - (track-joint int32 :offset-assert 216) - (attack-id uint32 :offset-assert 220) - (duration time-frame :offset-assert 224) - (sphere sphere :inline :offset-assert 240) - (danger traffic-danger-info :inline :offset-assert 256) + ((root-override collide-shape :offset 128) + (first-time? symbol :offset-assert 200) + (mode fma-sphere-mode :offset-assert 204) + (track-handle handle :offset-assert 208) + (track-joint int32 :offset-assert 216) + (attack-id uint32 :offset-assert 220) + (duration time-frame :offset-assert 224) + (sphere sphere :inline :offset-assert 240) + (danger traffic-danger-info :inline :offset-assert 256) ) + :heap-base #xc0 :method-count-assert 21 :size-assert #x136 :flag-assert #x1500c00136 @@ -34,4 +42,121 @@ ) ) -(define-extern fma-sphere-init-by-other (function fma-sphere-mode process-drawable int time-frame object object fma-sphere)) + +(defmethod run-logic? fma-sphere ((obj fma-sphere)) + (or (logtest? *display-scene-control* (scene-controls display-controls)) + (and *display-nav-marks* (logtest? (-> obj mode) (fma-sphere-mode nav))) + (logtest? (-> obj mode) (fma-sphere-mode deadly-overlap)) + (>= (-> obj track-joint) 0) + (-> obj first-time?) + ) + ) + +(defstate idle (fma-sphere) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('touched) + (let ((v1-1 (-> event param 0))) + (when v1-1 + (let ((a1-2 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-2 from) (process->ppointer self)) + (set! (-> a1-2 num-params) 2) + (set! (-> a1-2 message) 'attack) + (set! (-> a1-2 param 0) v1-1) + (let ((v1-2 (new 'static 'attack-info :mask (attack-info-mask mode id attacker-velocity damage knock)))) + (set! (-> v1-2 id) (-> self attack-id)) + (set! (-> v1-2 mode) 'eco-red) + (set! (-> v1-2 attacker-velocity quad) (-> self root-override transv quad)) + (set! (-> v1-2 damage) 2.0) + (set! (-> v1-2 knock) (the-as uint 2)) + (set! (-> a1-2 param 1) (the-as uint v1-2)) + ) + (send-event-function proc a1-2) + ) + ) + ) + ) + ) + ) + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self first-time?) #f) + (if (logtest? (-> self mode) (fma-sphere-mode kill-once)) + (send-event *traffic-manager* 'kill-traffic-sphere (-> self sphere)) + ) + (none) + ) + :trans (behavior () + (local-vars (at-0 int)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 (-> self duration))) + (if (and (nonzero? v1-0) (>= (- (-> self clock frame-counter) (-> self state-time)) v1-0)) + (go empty-state) + ) + ) + (let ((v1-5 (-> self track-joint))) + (when (>= v1-5 0) + (let ((a2-0 (handle->process (-> self track-handle))) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (when a2-0 + (set! (-> gp-0 quad) (-> self sphere quad)) + (set! (-> gp-0 w) 1.0) + (vector-matrix*! gp-0 gp-0 (-> (the-as process-drawable a2-0) node-list data v1-5 bone transform)) + (let ((v1-9 (-> self root-override))) + (vector-! (-> v1-9 transv) gp-0 (-> v1-9 trans)) + (let ((a0-12 (-> v1-9 transv))) + (.lvf vf1 (&-> (-> v1-9 transv) quad)) + (let ((f0-1 (-> self clock frames-per-second))) + (.mov at-0 f0-1) + ) + (.mov vf2 at-0) + (.mov.vf vf1 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> a0-12 quad) vf1) + ) + ) + (collide-shape-method-29 (-> self root-override) gp-0) + (set! (-> self danger sphere x) (-> gp-0 x)) + (set! (-> self danger sphere y) (-> gp-0 y)) + (set! (-> self danger sphere z) (-> gp-0 z)) + ) + ) + ) + ) + (if (logtest? (-> self mode) (fma-sphere-mode danger)) + (send-event *traffic-manager* 'add-danger-sphere (-> self danger)) + ) + (when (logtest? (-> self mode) (fma-sphere-mode deadly-overlap)) + (let ((a1-10 (new 'stack-no-clear 'overlaps-others-params))) + (set! (-> a1-10 options) (overlaps-others-options)) + (set! (-> a1-10 collide-with-filter) (the-as collide-spec -1)) + (set! (-> a1-10 tlist) *touching-list*) + (find-overlapping-shapes (-> self root-override) a1-10) + ) + ) + (if (or (logtest? *display-scene-control* (scene-controls display-controls)) + (and *display-nav-marks* (logtest? (-> self mode) (fma-sphere-mode nav))) + ) + (add-debug-sphere + #t + (bucket-id debug2) + (-> self root-override trans) + (-> self sphere r) + (new 'static 'rgba :r #x80 :g #x40 :a #x80) + ) + ) + (none) + ) + ) + :code (the-as (function none :behavior fma-sphere) sleep-code) + ) + +;; ERROR: failed type prop at 36: Could not figure out load: (set! a0 (l.q a0)) +;; WARN: Return type mismatch none vs fma-sphere. +;; ERROR: Unsupported inline assembly instruction kind - [sllv v1, v1, r0] diff --git a/goal_src/jak2/engine/game/game-info.gc b/goal_src/jak2/engine/game/game-info.gc index 57bc2e45c..464cebccb 100644 --- a/goal_src/jak2/engine/game/game-info.gc +++ b/goal_src/jak2/engine/game/game-info.gc @@ -1377,7 +1377,7 @@ (let ((conts (-> (the-as level-load-info (-> (the-as symbol (car levels)) value)) continues))) (while (not (null? conts)) (let ((cont (the-as continue-point (car conts)))) - (if (zero? (logand (-> cont flags) (continue-flags cf2))) + (if (not (logtest? (-> cont flags) (continue-flags cf2))) (format #t "~S~%" (-> cont name)) ) ) diff --git a/goal_src/jak2/engine/game/main-h.gc b/goal_src/jak2/engine/game/main-h.gc index 1a5e2e212..5f7bfc1f5 100644 --- a/goal_src/jak2/engine/game/main-h.gc +++ b/goal_src/jak2/engine/game/main-h.gc @@ -36,7 +36,9 @@ (actor-marks) (special-fma-spheres) (scene-controls-7) - (scene-controls-8)) + (scene-controls-8) + (display-controls) + ) ;; ---scene-controls ;; +++bot-marks-controls diff --git a/goal_src/jak2/engine/gfx/generic/generic-vu1-h.gc b/goal_src/jak2/engine/gfx/generic/generic-vu1-h.gc index 615a89420..2f13bce95 100644 --- a/goal_src/jak2/engine/gfx/generic/generic-vu1-h.gc +++ b/goal_src/jak2/engine/gfx/generic/generic-vu1-h.gc @@ -19,6 +19,7 @@ :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) @@ -29,6 +30,7 @@ :flag-assert #x900000180 ) + (deftype generic-constants (structure) ((fog vector :inline :offset-assert 0) (adgif gs-gif-tag :inline :offset-assert 16) @@ -44,6 +46,7 @@ :flag-assert #x900000080 ) + (deftype generic-shrub-constants (structure) ((shrub-giftag generic-gif-tag :inline :offset-assert 0) (shrub-adnop qword :inline :offset-assert 16) @@ -53,6 +56,7 @@ :flag-assert #x900000020 ) + (deftype gcf-shader (structure) ((adgif uint128 5 :offset-assert 0) (shader adgif-shader :inline :offset 0) @@ -64,10 +68,11 @@ :flag-assert #x900000050 ) + (deftype gcf-control (structure) ((matrix matrix :inline :offset-assert 0) (giftag generic-gif-tag :inline :offset-assert 64) - (adnops uint32 2 :offset-assert 80) + (adnops gs-adcmd 2 :inline :offset-assert 80) (num-strips uint32 :offset 76) (num-dps uint32 :offset 92) (kick-offset uint32 :offset 108) @@ -78,6 +83,7 @@ :flag-assert #x900000070 ) + (deftype gcf-vertex (structure) ((tex vector4w :inline :offset-assert 0) (clr gs-packed-rgba :inline :offset-assert 16) diff --git a/goal_src/jak2/engine/gfx/lightning-h.gc b/goal_src/jak2/engine/gfx/lightning-h.gc index cf5a66fbe..82bc3a6ac 100644 --- a/goal_src/jak2/engine/gfx/lightning-h.gc +++ b/goal_src/jak2/engine/gfx/lightning-h.gc @@ -41,9 +41,9 @@ (flags lightning-spec-flags :offset-assert 8) (rand-func uint8 :offset-assert 10) (adjust-distance uint8 :offset-assert 11) - (start-color uint32 :offset-assert 12) - (end-color uint32 :offset-assert 16) - (fade-to-color uint32 :offset-assert 20) + (start-color rgba :offset-assert 12) + (end-color rgba :offset-assert 16) + (fade-to-color rgba :offset-assert 20) (fade-start-factor float :offset-assert 24) (fade-time float :offset-assert 28) (texture uint32 :offset-assert 32) @@ -64,6 +64,7 @@ :flag-assert #x900000050 ) + (defun lookup-lightning-spec-by-name ((arg0 string)) (let* ((s5-0 *lightning-spec-id-table*) (s4-0 (-> s5-0 length)) @@ -88,8 +89,8 @@ (line vector-array :offset-assert 128) (meet vector-array :offset-assert 132) (path vector-array :offset-assert 136) - (start-color uint32 :offset-assert 140) - (end-color uint32 :offset-assert 144) + (start-color rgba :offset-assert 140) + (end-color rgba :offset-assert 144) ) :method-count-assert 9 :size-assert #x94 @@ -98,9 +99,9 @@ (deftype lightning-control (basic) - ((spec lightning-spec :offset-assert 4) - (process process :offset-assert 8) - (state lightning-state :inline :offset-assert 16) + ((spec lightning-spec :offset-assert 4) + (process (pointer process) :offset-assert 8) + (state lightning-state :inline :offset-assert 16) ) :method-count-assert 14 :size-assert #xa4 @@ -207,7 +208,7 @@ ) (set! (-> obj state box-size) f0-0) ) - (set! (-> obj process) (the-as process (process->ppointer arg1))) + (set! (-> obj process) (process->ppointer arg1)) (set! (-> obj state mode) (lightning-mode lm1)) (set! (-> obj state line) ((method-of-type vector-array new) allocation vector-array s3-0)) (set! (-> obj state meet) ((method-of-type vector-array new) allocation vector-array s3-0)) diff --git a/goal_src/jak2/engine/process-drawable/process-drawable-h.gc b/goal_src/jak2/engine/process-drawable/process-drawable-h.gc index 636c7bce1..c6e4a9643 100644 --- a/goal_src/jak2/engine/process-drawable/process-drawable-h.gc +++ b/goal_src/jak2/engine/process-drawable/process-drawable-h.gc @@ -24,6 +24,8 @@ (define-extern rider-trans (function none :behavior process-drawable)) ;; NOTE - for base-plat (define-extern rider-post (function none :behavior process-drawable)) +;; NOTE - for fma-sphere +(define-extern sleep-code (function symbol)) ;; DECOMP BEGINS diff --git a/goal_src/jak2/engine/sound/speech-h.gc b/goal_src/jak2/engine/sound/speech-h.gc index 7a298d834..5ef0e09ba 100644 --- a/goal_src/jak2/engine/sound/speech-h.gc +++ b/goal_src/jak2/engine/sound/speech-h.gc @@ -5,22 +5,36 @@ ;; name in dgo: speech-h ;; dgos: ENGINE, GAME +;; NOTE - for settings +(declare-type speech-control structure) +(define-extern *speech-control* speech-control) +;; +++speech-type-flag (defenum speech-type-flag :type uint8 :bitfield #t (random-order 0) ) +;; ---speech-type-flag +;; +++speech-type +(defenum speech-type + :type int8 + :bitfield #t + (speech-type-0 0) + (speech-type-1 1) + (speech-type-2 2) + (speech-type-3 3) + ) +;; ---speech-type + +;; +++speech-channel-flag (defenum speech-channel-flag :type uint8 :bitfield #t (disable 0) ) - -;; NOTE - for settings -(declare-type speech-control structure) -(define-extern *speech-control* speech-control) +;; ---speech-channel-flag ;; DECOMP BEGINS @@ -42,10 +56,10 @@ (deftype speech-request (structure) - ((handle uint64 :offset-assert 0) - (time time-frame :offset-assert 8) - (priority float :offset-assert 16) - (speech-type int8 :offset-assert 20) + ((handle handle :offset-assert 0) + (time time-frame :offset-assert 8) + (priority float :offset-assert 16) + (speech-type speech-type :offset-assert 20) ) :pack-me :method-count-assert 9 @@ -55,27 +69,27 @@ (deftype speech-channel (structure) - ((flags speech-channel-flag :offset-assert 0) - (gui-channel gui-channel :offset-assert 1) - (delay uint16 :offset-assert 2) - (id uint32 :offset-assert 4) - (update-time time-frame :offset-assert 8) - (start-time time-frame :offset-assert 16) - (end-time time-frame :offset-assert 24) - (request speech-request :inline :offset-assert 32) - (last-request speech-request :inline :offset-assert 56) - (target-pos vector :inline :offset-assert 80) - (speech-table uint32 :offset-assert 96) + ((flags speech-channel-flag :offset-assert 0) + (gui-channel gui-channel :offset-assert 1) + (delay uint16 :offset-assert 2) + (id sound-id :offset-assert 4) + (update-time time-frame :offset-assert 8) + (start-time time-frame :offset-assert 16) + (end-time time-frame :offset-assert 24) + (request speech-request :inline :offset-assert 32) + (last-request speech-request :inline :offset-assert 56) + (target-pos vector :inline :offset-assert 80) + (speech-table (pointer speech-type-info) :offset-assert 96) ) :method-count-assert 14 :size-assert #x64 :flag-assert #xe00000064 (:methods - (speech-channel-method-9 () none 9) - (speech-channel-method-10 () none 10) - (speech-channel-method-11 () none 11) - (speech-channel-method-12 () none 12) - (speech-channel-method-13 () none 13) + (speech-channel-method-9 (_type_ process-drawable speech-type) none 9) + (speech-channel-method-10 (_type_ handle) none 10) + (speech-channel-method-11 (_type_) none 11) + (speech-channel-method-12 (_type_) none 12) + (speech-channel-method-13 (_type_) none 13) ) ) @@ -88,13 +102,13 @@ :size-assert #x1c4 :flag-assert #x11000001c4 (:methods - (speech-control-method-9 () none 9) + (speech-control-method-9 (_type_) none 9) (speech-control-method-10 (_type_ int speech-type-info) none 10) (speech-control-method-11 (_type_) none 11) - (speech-control-method-12 () none 12) - (speech-control-method-13 () none 13) - (speech-control-method-14 () none 14) - (speech-control-method-15 () none 15) - (speech-control-method-16 () none 16) + (speech-control-method-12 (_type_ process-drawable speech-type) none 12) + (speech-control-method-13 (_type_ handle) none 13) + (speech-control-method-14 (_type_) none 14) + (speech-control-method-15 (_type_ process-drawable) none 15) + (speech-control-method-16 (_type_) none 16) ) ) diff --git a/goal_src/jak2/engine/sound/speech.gc b/goal_src/jak2/engine/sound/speech.gc index 12a9b3e6e..c1741f11a 100644 --- a/goal_src/jak2/engine/sound/speech.gc +++ b/goal_src/jak2/engine/sound/speech.gc @@ -7,3 +7,492 @@ ;; DECOMP BEGINS +(defmethod speech-channel-method-12 speech-channel ((obj speech-channel)) + (set! (-> obj request handle) (the-as handle #f)) + (set! (-> obj request priority) -10000000000000000000000000000000000000.0) + 0 + (none) + ) + +(defmethod speech-channel-method-13 speech-channel ((obj speech-channel)) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + (set! (-> obj last-request priority) -10000000000000000000000000000000000000.0) + 0 + (none) + ) + +(defmethod speech-channel-method-11 speech-channel ((obj speech-channel)) + (local-vars (v1-44 int)) + (with-pp + (logclear! (-> obj flags) (speech-channel-flag disable)) + (if (or (not (-> *setting-control* user-current speech-control)) + (load-in-progress? *level*) + (nonzero? (-> obj id)) + ) + (logior! (-> obj flags) (speech-channel-flag disable)) + ) + (set! (-> obj target-pos quad) (-> (target-pos 0) quad)) + (when (not (logtest? (-> obj flags) (speech-channel-flag disable))) + (let ((s5-1 (-> obj speech-table (-> obj request speech-type)))) + (cond + (s5-1 + (let ((a0-8 (- (-> obj update-time) (-> obj request time))) + (v1-20 (handle->process (-> obj request handle))) + ) + (if (or (< (the-as time-frame (-> s5-1 request-timeout)) a0-8) + (or (not v1-20) + (let ((f0-0 245760.0)) + (< (* f0-0 f0-0) + (vector-vector-distance-squared (-> obj target-pos) (-> (the-as process-drawable v1-20) root trans)) + ) + ) + ) + ) + (speech-channel-method-12 obj) + ) + ) + (let ((s4-0 (handle->process (-> obj request handle)))) + (when s4-0 + (when (or (and (>= (-> obj request priority) 0.0) + (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> s5-1 delay))) + ) + (and (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> s5-1 delay))) + (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> obj delay))) + ) + ) + (let ((s3-0 (-> s5-1 list length)) + (v1-43 (-> s5-1 play-index)) + ) + (when (> s3-0 0) + (cond + ((logtest? (-> s5-1 flags) (speech-type-flag random-order)) + (set! v1-44 (rand-vu-int-count s3-0)) + (when (= v1-44 (-> s5-1 play-index)) + (+! v1-44 1) + (if (>= v1-44 s3-0) + (set! v1-44 0) + ) + ) + ) + (else + (set! v1-44 (+ v1-43 1)) + (if (>= v1-44 s3-0) + (set! v1-44 0) + ) + ) + ) + (set! (-> s5-1 play-index) v1-44) + (let ((s3-1 (-> s5-1 list v1-44))) + (mem-copy! (the-as pointer (-> obj last-request)) (the-as pointer (-> obj request)) 21) + (set! (-> obj start-time) (-> pp clock frame-counter)) + (set! (-> obj delay) + (the-as uint (rand-vu-int-range (the-as int (-> s5-1 min-delay)) (the-as int (-> s5-1 max-delay)))) + ) + (set! (-> s5-1 delay) (-> obj delay)) + (set! (-> obj id) + (gui-control-method-9 *gui-control* s4-0 (-> obj gui-channel) (gui-action play) s3-1 -99.0 0) + ) + ) + (speech-channel-method-12 obj) + (logior! (-> obj flags) (speech-channel-flag disable)) + ) + ) + ) + ) + ) + ) + (else + (speech-channel-method-12 obj) + ) + ) + ) + ) + (set! (-> obj update-time) (-> pp clock frame-counter)) + (when (nonzero? (-> obj id)) + (let ((s4-1 (handle->process (-> obj last-request handle)))) + (cond + ((and s4-1 (-> *setting-control* user-current speech-control)) + (when *sound-player-enable* + (let ((s5-2 (the-as sound-rpc-set-param (get-sound-buffer-entry)))) + (set! (-> s5-2 command) (sound-command set-param)) + (set! (-> s5-2 id) (-> obj id)) + (set! (-> s5-2 params fo-min) 15) + (set! (-> s5-2 params fo-max) 90) + (set! (-> s5-2 params fo-curve) 9) + (let ((a1-12 (-> (the-as process-drawable s4-1) root trans))) + (let ((s4-2 pp)) + (when (= a1-12 #t) + (if (and s4-2 (type? s4-2 process-drawable) (nonzero? (-> (the-as process-drawable s4-2) root))) + (set! a1-12 (-> (the-as process-drawable s4-2) root trans)) + (set! a1-12 (the-as vector #f)) + ) + ) + ) + (sound-trans-convert (the-as vector3w (-> s5-2 params trans)) a1-12) + ) + (set! (-> s5-2 params mask) (the-as uint 480)) + (-> s5-2 id) + ) + ) + ) + (else + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + 0 + ) + ) + ) + (case (gui-control-method-17 *gui-control* (-> obj id)) + (((gui-action queue)) + (when (>= (- (-> pp clock frame-counter) (-> obj start-time)) (seconds 1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj end-time) (-> obj update-time)) + ) + ) + (((gui-action none)) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + (set! (-> obj end-time) (-> obj update-time)) + ) + ) + ) + 0 + (none) + ) + ) + +(defmethod speech-channel-method-9 speech-channel ((obj speech-channel) (arg0 process-drawable) (arg1 speech-type)) + (with-pp + (let ((f0-0 (vector-vector-distance-squared (-> arg0 root trans) (-> obj target-pos))) + (f1-0 245760.0) + ) + (when (< f0-0 (* f1-0 f1-0)) + (let* ((f1-3 -1.0) + (f2-0 409600.0) + (f0-2 (+ (* f0-0 (/ f1-3 (* f2-0 f2-0))) (the float (-> obj speech-table arg1 priority)))) + ) + (when (< (-> obj request priority) f0-2) + (set! (-> obj request priority) f0-2) + (set! (-> obj request handle) (process->handle arg0)) + (set! (-> obj request speech-type) arg1) + (set! (-> obj request time) (-> pp clock frame-counter)) + ) + ) + ) + ) + 0 + (none) + ) + ) + +(defmethod speech-channel-method-10 speech-channel ((obj speech-channel) (arg0 handle)) + (when (= arg0 (handle->process (-> obj last-request handle))) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + ) + 0 + (none) + ) + +(defmethod speech-control-method-12 speech-control ((obj speech-control) (arg0 process-drawable) (arg1 speech-type)) + (let ((v1-2 (-> obj speech-table arg1))) + (when v1-2 + (let ((a0-1 (-> obj channel-array (-> v1-2 channel)))) + (if (not (logtest? (-> a0-1 flags) (speech-channel-flag disable))) + (speech-channel-method-9 a0-1 arg0 arg1) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod speech-control-method-11 speech-control ((obj speech-control)) + (dotimes (s5-0 2) + (speech-channel-method-11 (-> obj channel-array s5-0)) + ) + 0 + (none) + ) + +(defmethod speech-control-method-10 speech-control ((obj speech-control) (arg0 int) (arg1 speech-type-info)) + (set! (-> obj speech-table arg0) arg1) + 0 + (none) + ) + +(defmethod speech-control-method-13 speech-control ((obj speech-control) (arg0 handle)) + (dotimes (s4-0 2) + (speech-channel-method-10 (-> obj channel-array s4-0) arg0) + ) + 0 + (none) + ) + +(defmethod speech-control-method-14 speech-control ((obj speech-control)) + (speech-control-method-9 obj) + (let ((s5-0 (-> obj channel-array))) + ((method-of-type speech-channel speech-channel-method-13) (the-as speech-channel s5-0)) + (set! (-> s5-0 0 speech-table) (-> obj speech-table)) + (set! (-> s5-0 0 gui-channel) (gui-channel guard)) + ) + (let ((s5-1 (-> obj channel-array 1))) + (speech-channel-method-13 s5-1) + (set! (-> s5-1 speech-table) (-> obj speech-table)) + (set! (-> s5-1 gui-channel) (gui-channel citizen)) + ) + 0 + (none) + ) + +(defmethod speech-control-method-15 speech-control ((obj speech-control) (arg0 process-drawable)) + (when (not (logtest? (-> obj channel-array 0 flags) (speech-channel-flag disable))) + (let ((v1-3 *target*)) + (when v1-3 + (cond + ((logtest? (focus-status dark) (-> v1-3 focus-status)) + (speech-control-method-12 obj arg0 (speech-type speech-type-3)) + ) + ((logtest? (focus-status pilot) (-> v1-3 focus-status)) + (speech-control-method-12 obj arg0 (speech-type speech-type-0 speech-type-1 speech-type-2)) + ) + (else + (speech-control-method-12 obj arg0 (speech-type speech-type-1 speech-type-2)) + ) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod speech-control-method-16 speech-control ((obj speech-control)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel guard) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel citizen) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (dotimes (s5-0 2) + (speech-channel-method-12 (-> obj channel-array s5-0)) + ) + 0 + (none) + ) + +(defmethod speech-control-method-9 speech-control ((obj speech-control)) + (dotimes (v1-0 57) + (set! (-> obj speech-table v1-0) #f) + ) + (dotimes (s5-0 2) + (speech-channel-method-12 (-> obj channel-array s5-0)) + ) + (speech-control-method-10 obj 0 (new 'static 'speech-type-info + :priority 3 + :request-timeout #x12c + :min-delay #x12c + :max-delay #x12c + :list (new 'static 'boxed-array :type string) + ) + ) + (speech-control-method-10 obj 3 (new 'static 'speech-type-info + :priority 3 + :request-timeout #x12c + :min-delay #x12c + :max-delay #x12c + :list (new 'static 'boxed-array :type string + "kg136" + "kg139" + "kg140" + "kg141" + "kg142" + "kg134" + "kg157" + "kg143" + "kg156" + "kg176" + "kg177" + "kg536" + "kg551" + ) + ) + ) + (speech-control-method-10 obj 9 (new 'static 'speech-type-info + :priority 1 + :min-delay #x258 + :max-delay #x4b0 + :list (new 'static 'boxed-array :type string + "kg133" + "kg135" + "kg137" + "kg138" + "kg144" + "kg145" + "kg146" + "kg147" + "kg148" + "kg149" + "kg150" + "kg151" + "kg152" + "kg153" + "kg154" + "kg155" + "kg158" + "kg159" + "kg160" + "kg163" + "kg164" + "kg507" + "kg508" + "kg509" + "kg511" + "kg513" + "kg514" + "kg515" + "kg516" + "kg517" + "kg518" + "kg520" + "kg521" + "kg523" + "kg526" + "kg527" + "kg528" + "kg529" + "kg530" + "kg532" + "kg534" + "kg535" + "kg537" + "kg538" + "kg539" + "kg540" + "kg541" + "kg542" + "kg543" + "kg544" + "kg545" + "kg546" + "kg549" + "kg550" + ) + ) + ) + (speech-control-method-10 obj 10 (new 'static 'speech-type-info + :flags (speech-type-flag random-order) + :priority #xa + :request-timeout #x258 + :min-delay #x258 + :max-delay #x4b0 + :list (new 'static 'boxed-array :type string + "kg165" + "kg165a" + "kg165b" + "kg166" + "kg166a" + "kg166b" + "kg167" + "kg167a" + "kg167b" + "kg168" + "kg168a" + "kg168b" + "kg169" + "kg169a" + "kg169b" + "kg170" + "kg170a" + "kg170b" + "kg171" + "kg171a" + "kg171b" + "kg172" + "kg172a" + "kg172b" + "kg173" + "kg173a" + "kg173b" + "kg174" + "kg174a" + "kg174b" + "kg175" + "kg175a" + "kg175b" + "kg510" + ) + ) + ) + (speech-control-method-10 obj 11 (new 'static 'speech-type-info + :priority 2 + :min-delay #x1e + :max-delay #x1e + :list (new 'static 'boxed-array :type string + "kg386a" + "kg428a" + "kg641" + "kg650" + "kg338a" + "kg339a" + "kg340a" + "kg341a" + "kg342a" + "kg343a" + "kg344a" + "kg512" + ) + ) + ) + 0 + (none) + ) + +(define *speech-control* (new 'static 'speech-control)) + +(speech-control-method-14 *speech-control*) diff --git a/goal_src/jak2/engine/target/target-h.gc b/goal_src/jak2/engine/target/target-h.gc index d2411b16b..b5acff5ea 100644 --- a/goal_src/jak2/engine/target/target-h.gc +++ b/goal_src/jak2/engine/target/target-h.gc @@ -69,7 +69,6 @@ (define-extern target-double-jump (state float float target)) (define-extern target-flop (state float float float target)) (define-extern target-jump-event-handler (function process int symbol event-message-block object :behavior target)) -(define-extern talker-spawn-func (function talker-speech-class process-tree vector region int)) (define-extern target-launch (state float symbol vector int target)) (define-extern ja-group-size (function int :behavior process-drawable)) (define-extern target-falling-anim (function int time-frame symbol :behavior target)) diff --git a/goal_src/jak2/engine/ui/bigmap-data.gc b/goal_src/jak2/engine/ui/bigmap-data.gc index c8a00f2fb..934346456 100644 --- a/goal_src/jak2/engine/ui/bigmap-data.gc +++ b/goal_src/jak2/engine/ui/bigmap-data.gc @@ -5,5 +5,15402 @@ ;; name in dgo: bigmap-data ;; dgos: ENGINE, GAME +;; og:ignore-from-loc + ;; DECOMP BEGINS +(define *bigmap-compressed-layers* (new 'static 'bigmap-compressed-layers + :layer0 (new 'static 'array uint32 600 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4003e00 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #xff007a77 + #xff440204 + #xff007a40 + #xff440204 + #xfb007a40 + #x54554404 + #xfb007a40 + #x54554504 + #xfb007a40 + #x54555505 + #xff007640 + #xfe550505 + #x764054 + #x550505ff + #x7650ff + #x51501fe + #x7350ff55 + #x7707fb00 + #x5157177 + #x7350ff55 + #x7707fb00 + #x5157177 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x4440304 + #x7470ff77 + #x304ff00 + #xff770444 + #xff007470 + #xff440204 + #xff770447 + #xff007470 + #x5440204 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x3007770 + #x1711fc77 + #x777077 + #x11fc7703 + #x77707717 + #xfc770300 + #x70771711 + #x77030077 + #x771711fc + #xfe007b70 + #x7d1011 + #x7d1011fe + #x1011fe00 + #x44fd007c + #x44021411 + #x7840ff + #x141144fd + #x40ff4402 + #x44fd0078 + #x44021411 + #x7840ff + #x40ff4405 + #x44050078 + #x7840ff + #x40ff4405 + #x44050078 + #x7840ff + #x40ff4405 + #x41f90078 + #x44141111 + #x784044 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x7b101111 + #x1101fc00 + #x7b1011 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x7b101111 + #x1101fc00 + #x7b1011 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x73101111 + #x73550b00 + #x73550b00 + #x73550b00 + #x73550b00 + #xfd550800 + #x73455444 + #xfd550800 + #x73455444 + #x2550800 + #x8007366 + #x2660255 + #x204ff00 + #x7077fe44 + #x5508006a + #x77026602 + #x440274ff + #x57677fe + #x8006466 + #x2660255 + #x274ff77 + #x7677fe44 + #x646605 + #x66025508 + #x74ff7702 + #x77fe4402 + #x64660576 + #x2550800 + #xff770266 + #xfe440274 + #x66057677 + #x55040064 + #x15fe1101 + #x2660255 + #x274ff77 + #x7677fe44 + #x646605 + #x11015504 + #x66025501 + #x74ff7702 + #x77fe4402 + #x64660576 + #xfc550400 + #x55551511 + #x77026602 + #x440274ff + #x57677fe + #x4006466 + #x1511fc55 + #x66025555 + #x74ff7702 + #x66074402 + #x55040064 + #x551511fc + #x1660355 + #x274ff77 + #x64660744 + #x4550800 + #x7477fe66 + #x66074402 + #x55060064 + #x67fe6606 + #x7440274 + #x4006466 + #x3653fe55 + #x44026608 + #x64ff6606 + #x624403 + #x330203ff + #x660836ff + #x66064402 + #x440364ff + #x3ff0062 + #x36ff3302 + #x64fd6608 + #x66064644 + #x624404 + #x330203ff + #x660936ff + #x64644fe + #x62440466 + #x203ff00 + #x7637fe33 + #x44ff6608 + #x44046607 + #x3ff0062 + #x77013302 + #x65fe6608 + #x4660656 + #xfc006244 + #x37333303 + #x66077702 + #x56ff5501 + #x44016605 + #x447477fd + #x4ff005b + #x77044408 + #x55036605 + #x660556ff + #x70ff7702 + #x4ff005b + #x77044408 + #x776676fb + #x55056666 + #x660456ff + #x70ff7702 + #x4ff005b + #x77054408 + #x777767fd + #x56ff5507 + #x77026603 + #x5b70ff + #x440804ff + #x75ff7707 + #x66035508 + #x70ff7702 + #x4ff005b + #x67ff4408 + #x99017703 + #xc7577fe + #xff770255 + #xff005b70 + #xfe440704 + #x77036646 + #x77fe9901 + #x2550c75 + #x5b70ff77 + #x704ff00 + #x6646fd44 + #x1770266 + #xc330199 + #xff770255 + #xff005b70 + #xf6440704 + #x63666646 + #x99997777 + #x550c3333 + #x70ff7702 + #x4ff005b + #x45fb4407 + #x33336666 + #x33017702 + #x550a1101 + #x70ff7702 + #x4ff005b + #x55fb4407 + #x37333356 + #x33017702 + #x550a1101 + #x70ff7702 + #x4ff005b + #x45fa4406 + #x33335555 + #x1220432 + #x3550a11 + #x5a30ff33 + #x504ff00 + #xfc660144 + #x33335365 + #x11012205 + #x3303550a + #x5a30ff + #x440404ff + #x660256ff + #x333363fd + #x550c2205 + #x30ff3303 + #x4ff005a + #x45fe4403 + #xfd660256 + #x5333363 + #x3550c22 + #x5a30ff33 + #x304ff00 + #x2550144 + #x3363fd66 + #xc220533 + #xff330355 + #xf8005a30 + #x74777707 + #x54555544 + #x550c440a + #x30ff3303 + #x7ff005a + #x75fc7702 + #x6545555 + #x2422fc44 + #x550c4444 + #x330253ff + #x5a30ff + #x770207ff + #x555575fc + #xfc440654 + #x44442422 + #x75ff7705 + #x53ff5505 + #x30ff3302 + #x7ff005a + #x55027702 + #x440654ff + #x442422fc + #xff770544 + #xff550575 + #xff330253 + #x4005730 + #x7737fe33 + #x54ff5502 + #x7706440a + #x53ff5505 + #x30ff3302 + #x33050057 + #x660236ff + #x440a64ff + #x55057706 + #x5b50ff + #x36ff3305 + #x64ff6602 + #x7706440a + #x550475ff + #x5a7077fe + #xff330500 + #xff660236 + #x6440a64 + #x375ff77 + #x7757fd55 + #x5005a70 + #x236ff33 + #xa64ff66 + #x3770744 + #xff770155 + #x5005a70 + #x236ff33 + #xa64ff66 + #x2770844 + #x5b770155 + #xff330500 + #xff660236 + #x8440a64 + #x5575fb77 + #x5b777757 + #xff330500 + #xff660236 + #x9440a64 + #x275ff77 + #x5005b77 + #x236ff33 + #xa64ff66 + #x5b770d44 + #xff330500 + #xff660236 + #xd440a64 + #x5005b77 + #x232ff33 + #xa24ff22 + #xff770c44 + #x5005b70 + #x232ff33 + #xa24ff22 + #x5c770c44 + #xff330500 + #xff220232 + #xc440a24 + #x5005c77 + #x232ff33 + #xa24ff22 + #xff660644 + #xff770367 + #xff660476 + #x5005660 + #x232ff33 + #xa24ff22 + #x6566fd44 + #xfd660556 + #x5674644 + #x5660ff66 + #xff330500 + #xff220232 + #xfd440a24 + #x5566566 + #x4644fe66 + #x60ff6606 + #x33050056 + #x220232ff + #x440a24ff + #x44fe6608 + #xff660646 + #x5005660 + #x232ff33 + #xa24ff22 + #xfe660844 + #x66064644 + #x5660ff + #x32ff3305 + #x24ff2202 + #x6608440a + #x64644fe + #x5660ff66 + #xff770900 + #x8440a74 + #x4644fe66 + #x60ff6606 + #x77090056 + #x440a74ff + #x44fe6608 + #xff660646 + #x15005660 + #xfe660844 + #x66064644 + #x5660ff + #x66084415 + #x64644fe + #x5660ff66 + #x8441500 + #x4644fe66 + #x60ff6606 + #x66090056 + #x440a64ff + #x44fe6608 + #xfc660346 + #x50557577 + #x66090056 + #x440a64ff + #x64fd6602 + #x77042246 + #x660276ff + #x557577fc + #x9005650 + #xa64ff66 + #xfd660244 + #x4224664 + #x273ff77 + #x7577fc33 + #x565055 + #x64ff6609 + #x6602440a + #x361361fd + #x73ff7704 + #x77fc3302 + #x56505575 + #x2660900 + #x777ff33 + #xfd660244 + #x4361361 + #x273ff77 + #x7577fc33 + #x565055 + #x33026609 + #x440777ff + #x77096605 + #x505575fd + #x66090056 + #x77ff3302 + #x66054407 + #x75ff7707 + #x50ff5502 + #x66090056 + #x77ff3302 + #x66054407 + #x55037707 + #x5650ff + #x33026609 + #x440777ff + #x77076605 + #x50ff5503 + #x66090056 + #x77023302 + #x66054405 + #x55037707 + #x5650ff + #x33026609 + #x550e7702 + #x770357ff + #x50ff5503 + #x66090056 + #x77023302 + #x57ff550e + #x75ff7703 + #x50ff5502 + #x66090056 + #x77023302 + #x57ff550e + #x75fc7704 + #x56505555 + #x2660900 + #xe770233 + #x457ff55 + #x5544fc77 + #x565055 + #x33026609 + #x550e7702 + #x770357ff + #x404474fd + #x660c0058 + #x454464fd + #x57ff550e + #x74fe7703 + #xc005944 + #x4464fd66 + #xff550e45 + #xfe770357 + #x594044 + #x64fd660c + #x550e4544 + #x770257ff + #x5a4474fe + #x11660c00 + #x357ff55 + #x5a40ff77 + #x11660c00 + #x7757f955 + #x77677677 + #xc005977 + #xf9551166 + #x66667657 + #x59777767 + #x11660c00 + #x7657fc55 + #x77026666 + #x660c0059 + #x57fc5511 + #x2676676 + #x4006677 + #x457ff55 + #x575ff77 + #x557ff55 + #x2006677 + #x66771555 + #x66771800 + #xfd770e00 + #x6444774 + #xe006677 + #x4774fd77 + #x66770644 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #xfd771100 + #x3474474 + #x11006677 + #x4474fd77 + #x78770347 + #x4404fd00 + #x78770347 + #x4404fd00 + #x78770347 + #x4404fd00 + #xfd007c40 + #x7f404404 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2900 + ) + :layer1 (new 'static 'array uint32 1276 + #x452301f8 + #xcdab8967 + #x3cd17ef + #x3cd0300 + #x1ccd0400 + #x6cd0300 + #xffcd0300 + #x1ccd0400 + #x1cd2100 + #x3cd0300 + #x1bcd0400 + #x6cd0400 + #x1cd0300 + #x1ccd0300 + #x3cd2700 + #x1acd0500 + #x6cd0400 + #xffcd0400 + #x1bcd0400 + #x3cd2700 + #x18cd0600 + #x6cd0500 + #x1bcd0a00 + #x4cd2700 + #x18cd0500 + #x7cd0400 + #x1acd0b00 + #x7cd0b00 + #x4cd1400 + #x16cd0500 + #x8cd0500 + #x1acd0a00 + #x10cd0800 + #x2cd1000 + #x15cd0600 + #x9cd0400 + #x1acd0a00 + #x14cd0700 + #x2cd0e00 + #x14cd0500 + #xacd0500 + #x1dcd0a00 + #x17cd0300 + #x1cd0c00 + #x13cd0600 + #xbcd0400 + #x1ccd0a00 + #x18cd0400 + #xffcd0d00 + #x12cd0500 + #xccd0500 + #x1bcd0a00 + #x18cd0400 + #x11cd1500 + #xdcd0400 + #x1bcd0a00 + #x18cd0300 + #xfcd1700 + #xdcd0500 + #x1bcd0a00 + #x18cd0300 + #x1cd0400 + #xfcd1000 + #xfcd0400 + #x1acd0a00 + #x18cd0300 + #x4cd0300 + #xdcd0f00 + #xfcd0500 + #x19cd0a00 + #x17cd0400 + #x5cd0400 + #xdcd0e00 + #x11cd0400 + #x18cd0a00 + #x18cd0300 + #x6cd0400 + #xbcd0e00 + #x11cd0500 + #x18cd0a00 + #x18cd0300 + #x8cd0300 + #xbcd0d00 + #x13cd0400 + #x18cd0900 + #x17cd0300 + #xacd0400 + #x9cd0c00 + #x13cd0500 + #x16cd0a00 + #x17cd0400 + #xbcd0400 + #x8cd0c00 + #x14cd0400 + #x14cd0a00 + #xcdfe00 + #x17cd04 + #xdcd03 + #x7cd0b + #x15cd05 + #x12cd0a + #xffcd01 + #x17cd03 + #xecd04 + #x6cd0b + #x16cd04 + #x11cd0a + #xffcd02 + #x17cd03 + #xfcd04 + #x5cd0a + #x17cd05 + #x10cd09 + #x17cd08 + #x11cd03 + #x4cd0a + #x18cd04 + #xfcd0a + #x16cd08 + #x12cd04 + #x3cd09 + #x19cd05 + #xecd09 + #x17cd08 + #x13cd04 + #x2cd09 + #x1acd04 + #xccd0a + #x2cd09 + #x11cd02 + #x14cd03 + #x1cd09 + #x1acd05 + #xbcd0a + #xffcd0a + #xecd06 + #x15cd04 + #xffcd09 + #x1ccd04 + #xbcd09 + #xdcd13 + #x16cd04 + #x1ccd0e + #x9cd0a + #xffcd06 + #xffcd02 + #xbcd09 + #x18cd04 + #x1ecd0c + #x8cd09 + #x1cd06 + #xffcd02 + #xbcd09 + #x19cd04 + #x1ecd0b + #x8cd09 + #x2cd05 + #xffcd02 + #xbcd09 + #x19cd04 + #x1fcd0a + #x6cd0a + #x2cd06 + #xffcd02 + #xacd09 + #x1bcd04 + #x20cd09 + #x5cd09 + #x3cd06 + #x1cd01 + #xacd09 + #x1ccd04 + #x21cd07 + #x4cd09 + #x4cd06 + #xffcd01 + #xacd0a + #x1dcd03 + #x21cd07 + #x3cd0a + #x4cd06 + #xffcd01 + #x9cd0a + #x1ecd04 + #x21cd07 + #x2cd09 + #x5cd06 + #xcdfd + #x9cd0a + #x1ecd04 + #x21cd07 + #xffcd0a + #xacd06 + #x9cd09 + #x1fcd03 + #x21cd08 + #xbcd10 + #x9cd08 + #x1ecd04 + #x21cd09 + #xbcd10 + #xbcd06 + #x1ecd04 + #x20cd0a + #xccd0f + #xbcd06 + #x1ecd03 + #x21cd0b + #xdcd0d + #xacd06 + #x1ecd04 + #x20cd0c + #xdcd0c + #x9cd08 + #x1dcd04 + #xffcd05 + #x20cd06 + #xdcd0c + #x8cd09 + #x1ecd03 + #x2cd04 + #x20cd06 + #xecd0a + #x7cd09 + #x1dcd04 + #x2cd05 + #x20cd06 + #xecd0a + #x6cd0a + #x1dcd04 + #x4cd04 + #x20cd05 + #xecd0a + #x6cd0a + #x1dcd03 + #x4cd05 + #x20cd06 + #xecd09 + #x5cd0a + #x1dcd04 + #x6cd04 + #x20cd05 + #xecd09 + #x5cd0a + #x1ccd04 + #x6cd05 + #x1ecd06 + #xdcd0b + #x5cd0a + #x1dcd03 + #x8cd04 + #x1ecd05 + #xdcd0b + #x4cd0a + #x1ccd04 + #x8cd05 + #x1ccd06 + #xdcd0c + #x4cd0a + #x1ccd04 + #xacd04 + #x1bcd05 + #xccd0e + #x3cd0a + #x1ccd04 + #xacd05 + #x1acd05 + #xccd0f + #x3cd0a + #x1ccd04 + #xccd04 + #x19cd05 + #xccd0f + #x3cd0a + #x1bcd04 + #xccd05 + #x2cd05 + #x441504ff + #xbcd10 + #x2cd0a + #x1ccd04 + #xecd04 + #x1cd05 + #x441504ff + #x1cd04 + #xbcd09 + #x2cd0a + #x1bcd04 + #xecd05 + #x1cd05 + #x441504ff + #x2cd03 + #xbcd09 + #x2cd0a + #x1bcd04 + #xfcd04 + #x1cd05 + #x441504ff + #x3cd03 + #xbcd08 + #x1cd0a + #x1bcd04 + #x10cd05 + #xfecd05 + #x2441504 + #x90004cd + #x10007cd + #x900ffcd + #x40002cd + #x4001bcd + #x50011cd + #x400fecd + #xcd014415 + #xcd090005 + #xcd020007 + #xcd0800ff + #xcd030002 + #xcd05001b + #xcd050012 + #x441504ff + #x5cd01 + #x7cd09 + #x1cd0c + #x1bcd04 + #x13cd04 + #x4ffcd05 + #xcdff4415 + #xcd090007 + #xcd0c0006 + #xcd040001 + #xcd05001a + #xcd050013 + #x441504ff + #xcd090008 + #xcd0d0006 + #xcd0300ff + #xcd04001b + #xcd050015 + #x64ff4407 + #x8440c + #x6cd09 + #x1acd12 + #x15cd05 + #x4406cd05 + #xc6646fe + #x9000944 + #x120005cd + #x4001acd + #x50016cd + #x14406cd + #xb64ff66 + #x9000944 + #x110005cd + #x5001acd + #x40017cd + #xff4405cd + #xb660246 + #x9000944 + #x100006cd + #x3001acd + #x1ccfffcd + #x574ff77 + #xff660344 + #xa440a64 + #x7cd0800 + #x19cd0f00 + #xffcd0400 + #xff771ccf + #xff440474 + #xa660446 + #x9000a44 + #xe0006cd + #x4001acd + #x1c07ffcd + #x474ff77 + #xff660544 + #xa440964 + #x6cd0900 + #x19cd0e00 + #xffcd0500 + #xff771c07 + #xff440374 + #x9660646 + #x8000b44 + #xe0006cd + #x40019cd + #x700fecd + #x73ff771c + #x66073303 + #x440864ff + #xcd09000b + #xcd0e0004 + #xcd050019 + #x1c0700fe + #x273ff77 + #x836ff33 + #xb440866 + #x4cd0900 + #x19cd0e00 + #x1cd0400 + #x1c07ff00 + #x373ff77 + #xff660733 + #xb440864 + #x4cd0900 + #x18cd0e00 + #x1cd0500 + #x1c07ff00 + #x373ff77 + #x636ff33 + #xc440966 + #x4cd0800 + #x18cd0e00 + #x6cdff00 + #x1c47ff44 + #x473ff77 + #xff660533 + #xc440964 + #x3cd0900 + #x17cd0e00 + #x6cd0100 + #x1c47ff44 + #x473ff77 + #x436ff33 + #xc440a66 + #x3cd0900 + #x8cd0b00 + #xfb770eaa + #xcd000070 + #xff4406cd + #xff771c47 + #x3330573 + #xa64ff66 + #x8000d44 + #xb0003cd + #xeaa08cd + #x70fe77 + #x4406cd02 + #x771c47ff + #x330573ff + #x660236ff + #xd440b + #x3cd08 + #xaa08cd0b + #x70fe770e + #x6cd0200 + #x1c47ff44 + #x673ff77 + #xff660133 + #xd440b64 + #x2cd0900 + #x8cd0b00 + #xff770eaa + #x6cd0370 + #x1c47ff44 + #x673ff77 + #x6636fd33 + #xd440b34 + #x3cd0900 + #x8cd0a00 + #xff770eaa + #x6cd0370 + #x1c47ff44 + #x773ff77 + #x3463fe33 + #xe440b + #x3cd08 + #xaa08cd0a + #x70ff770e + #x4406cd03 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000e + #xcd090002 + #xaa0800ff + #x70ff770e + #x4406cd03 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000e + #xcd090002 + #xaa0800ff + #x70ff770e + #x4406cd03 + #x73ff771d + #x34ff3308 + #xf440b + #x2cd08 + #xffcd09 + #x770eaa08 + #x330373ff + #x771d4406 + #x330873ff + #x440b34ff + #xcd08000f + #xcd080002 + #xaa080001 + #x73ff770e + #x44063303 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000f + #xcd080001 + #xaa080001 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd09001b + #xcd080001 + #xaa080001 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd08001c + #xcd0800ff + #xaa080002 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd08001c + #xcd070001 + #xaa080002 + #x73ff770e + #x44063303 + #x70ff7723 + #x1dcd02 + #x1cd08 + #x2cd07 + #x770eaa08 + #x330373ff + #x77234406 + #xcd0370ff + #xcd08001c + #xcd060001 + #xaa080003 + #x22fe770e + #x6330223 + #xff772344 + #x1dcd0370 + #x1cd0700 + #x3cd0600 + #xeaa0800 + #xfd220177 + #x6333323 + #xff772344 + #x1dcd0370 + #x1cd0700 + #xbcd0600 + #xdcdff00 + #x472ff77 + #xff440622 + #xff772247 + #x1dcd0370 + #x1cd0700 + #xccd0500 + #xdcdff00 + #x472ff77 + #xff440622 + #xff772247 + #x1ccd0470 + #x1cd0700 + #xffcd0500 + #x9cd0200 + #x5770d00 + #xff440622 + #xff772247 + #x1dcd0470 + #x1cd0600 + #x8cd0a00 + #x5770d00 + #xff440622 + #xff772247 + #x1dcd0470 + #x1cd0600 + #x7cd0b00 + #xff770c00 + #x6220572 + #x2247ff44 + #x570ff77 + #x6001ccd + #xb0001cd + #xc0007cd + #x572ff77 + #xff440622 + #xff772247 + #x1ccd0570 + #x1cd0600 + #x7cd0b00 + #x6770c00 + #xff440622 + #xff772245 + #x1dcd0570 + #x2cd0300 + #x6cd0d00 + #x6770c00 + #xff440622 + #xff772245 + #x1ccd0670 + #x2cd0300 + #x9cd0d00 + #x1cd0700 + #x6220600 + #x2245ff44 + #x670ff77 + #x4001ccd + #xd0001cd + #x5000acd + #x60002cd + #xfe440622 + #x77215755 + #xcd0670ff + #xcd04001c + #xcd0e00ff + #xcd05000a + #x22050002 + #x440624ff + #x215755fe + #xcd70fc77 + #xcd0300cd + #xcd03001d + #xcd0e00ff + #xcd05000a + #x22050002 + #x440624ff + #x77215501 + #xcdcd70fc + #x1ccd0400 + #x9cd1300 + #x1cd0700 + #x6220500 + #x5545fd44 + #xfc772155 + #xcdcd70 + #x1ccd04 + #x9cd13 + #x1cd07 + #x24ff2204 + #x45fc4406 + #x20575555 + #xcd70fb77 + #x30000cd + #x13001ccd + #x90008cd + #x400ffcd + #x2440722 + #x2057ff55 + #xcd70fb77 + #x40000cd + #x13001bcd + #x90008cd + #x300ffcd + #x3440822 + #xfb772055 + #xcdcd70 + #x1acd0400 + #x7cd1400 + #x3cd0b00 + #x3440822 + #xfb772055 + #xcdcd70 + #x19cd0400 + #x8cd1400 + #x1cd0400 + #x3cd0400 + #xff440722 + #x20550345 + #x270ff77 + #x30001cd + #x150018cd + #x50007cd + #x50001cd + #x70002cd + #x345ff44 + #x1f57ff55 + #x270ff77 + #x40001cd + #x150016cd + #x40008cd + #x40003cd + #x70002cd + #xff550444 + #xff771f57 + #x1cd0270 + #x15cd0400 + #xffcd0a00 + #x7cd0a00 + #x3cd0500 + #x2cd0400 + #x4440700 + #x1f57ff55 + #x270ff77 + #x30002cd + #xa0014cd + #xa00ffcd + #x40008cd + #x40005cd + #x70001cd + #xff550444 + #xff771f57 + #x2cd0270 + #x13cd0300 + #xffcd0b00 + #x7cd0a00 + #x5cd0500 + #x1cd0400 + #xff440600 + #xff550445 + #xff771f57 + #x2cd0270 + #x11cd0400 + #xffcd0800 + #xffcd0200 + #x6cd0b00 + #x6cd0400 + #xffcd0500 + #x5440600 + #x1f57ff55 + #x270ff77 + #x40002cd + #x80010cd + #x10002cd + #xc00ffcd + #x50004cd + #x40007cd + #x500ffcd + #x545ff44 + #x1f57ff55 + #x270ff77 + #x30003cd + #x9000ecd + #x10003cd + #xd00ffcd + #x40003cd + #x50008cd + #x64405cd + #x1f57ff55 + #x270ff77 + #x30003cd + #x9000dcd + #x10004cd + #xd00ffcd + #x50002cd + #x40009cd + #xff4404cd + #xff550645 + #xff771f57 + #x3cd0270 + #xbcd0400 + #x5cd0900 + #x1cd0100 + #x2cd0c00 + #xacd0400 + #x4cd0400 + #x645ff44 + #x1f57ff55 + #x270ff77 + #x40003cd + #x9000acd + #xfd0007cd + #xd0000cd + #x500ffcd + #x3000bcd + #xff4404cd + #xff550645 + #xff771f57 + #x4cd0270 + #x9cd0300 + #xbcd0900 + #xffcd0d00 + #xccd0400 + #x4cd0300 + #x645ff44 + #x1f57ff55 + #x370ff77 + #x30003cd + #x80008cd + #xc000dcd + #x500ffcd + #x3000ccd + #xff4404cd + #xff550645 + #xff771f57 + #x3cd0370 + #x6cd0400 + #xfcd0800 + #xecd1100 + #x7cd0400 + #xffcd0200 + #xff771fcf + #x3cd0370 + #x5cd0400 + #x10cd0800 + #xecd1100 + #x6cd0400 + #xffcd0300 + #xff771fcf + #x4cd0370 + #x3cd0300 + #x11cd0900 + #x10cd1000 + #x5cd0400 + #xffcd0300 + #xff771fcf + #x4cd0370 + #x2cd0300 + #x12cd0900 + #x10cd1000 + #x4cd0400 + #xffcd0400 + #xff771fcf + #x4cd0370 + #xffcd0400 + #x13cd0900 + #x11cd0f00 + #x3cd0400 + #xffcd0500 + #xff771fcf + #x4cd0370 + #x13cd0e00 + #x12cd1000 + #x1cd0400 + #xffcd0600 + #xff771f07 + #x5cd0370 + #x14cd0c00 + #x13cd0f00 + #x1cd0400 + #xffcd0600 + #xff771f07 + #x5cd0370 + #x15cd0b00 + #x14cd0f00 + #xfecd0b00 + #x771f0700 + #xcd0370ff + #xcd090005 + #xcd0e0017 + #xcd0a0015 + #x7ff0001 + #x70ff771f + #x5cd03 + #x18cd08 + #x15cd0e + #x2cd09 + #x771f07ff + #xcd0370ff + #xcd080004 + #xcd0d0019 + #xcd080017 + #x7ff0002 + #x70ff771f + #x2cd03 + #x1acd09 + #x16cd0e + #x3cd07 + #x771f07ff + #xcd0370ff + #xcd090001 + #xcd0e001b + #xcd060016 + #x7ff0004 + #x70fe772e + #xe001bcd + #x60016cd + #xff0004cd + #xfe772e07 + #x1bcd70 + #xffcd03 + #x15cd09 + #x5cd06 + #x772e07ff + #x1ccd70fe + #x14cd0d00 + #x5cd0700 + #x2e07ff00 + #xcd70fe77 + #xcd0b001e + #xcd080013 + #x7ff0005 + #x70fe772e + #xb001dcd + #x90014cd + #xff0004cd + #xfd772e07 + #x1ccdcd70 + #x13cd0b00 + #x4cd0a00 + #x2e07ff00 + #x5575fe77 + #x43ff4402 + #x30ff330f + #xcd0c0007 + #xcd0b0012 + #x7ff0004 + #x75fe772e + #xff440255 + #xff330f43 + #xd000730 + #x60010cd + #x40001cd + #xff0003cd + #xfe772e07 + #x44025575 + #x330f43ff + #x730ff + #xfcd0e + #x1cd06 + #x3cd04 + #x772e07ff + #x545575fa + #xf434444 + #x730ff33 + #xecd0e00 + #x3cd0600 + #x3cd0300 + #x2e07ff00 + #x5575fb77 + #x10444454 + #x730ff33 + #xdcd0e00 + #x4cd0600 + #x2cd0400 + #x2e07ff00 + #x5575fb77 + #x10444454 + #x730ff33 + #xccd0e00 + #x5cd0600 + #x2cd0400 + #x2e07ff00 + #xfd550177 + #x10444454 + #x730ff33 + #xbcd0f00 + #x6cd0600 + #x2cd0300 + #x2e07ff00 + #xfd550177 + #x10424454 + #x730ff33 + #xacd0f00 + #x7cd0600 + #x1cd0400 + #x2e07ff00 + #xfe550277 + #x33102244 + #x630ff + #x9cd10 + #x8cd06 + #x1cd04 + #x772e07ff + #x42fe5502 + #xff331022 + #xf000630 + #x6000acd + #x40008cd + #xff0001cd + #x2772e07 + #x10220155 + #x530ff33 + #x9cd1000 + #xacd0600 + #x1cd0300 + #x2e07ff00 + #xfd550177 + #x10222252 + #x530ff33 + #x8cd1000 + #xbcd0600 + #xfecd0400 + #x772e0700 + #x52fd5501 + #x33102222 + #x430ff + #xccd0c + #xccd06 + #xfecd04 + #x1772e07 + #x2252fd55 + #xff331022 + #xe000430 + #x6000acd + #x3000dcd + #x700fecd + #x75fb772e + #x22225255 + #x30ff3310 + #xcd0e0004 + #xcd060009 + #xcd03000e + #x2f0700fe + #x5255fc77 + #x33102322 + #x430ff + #x8cd0e + #xfcd06 + #xecd04 + #x8cd08 + #x2cd03 + #x770707ff + #x225255fc + #xff331023 + #xe000430 + #x60007cd + #x40010cd + #x8000dcd + #x30009cd + #xff0002cd + #xfc770707 + #x23225255 + #x30ff3310 + #xcd020004 + #xcd0b00ff + #xcd060006 + #xcd030011 + #xcd08000c + #xcd03000a + #xcd01000c + #x3310cfff + #x430ff + #x6cd0e + #x12cd06 + #xacd03 + #xbcd09 + #xccd03 + #xcfffcd01 + #x30ff3310 + #xcd010004 + #xcd0b00ff + #xcd060005 + #xcd040013 + #xcd090008 + #xcd04000b + #xcd01000c + #x3310cfff + #x430ff + #xcdfd + #x4cd0c + #x15cd05 + #x7cd03 + #xccd09 + #xdcd03 + #xcfffcd01 + #x30ff3310 + #xcd0d0007 + #xcd060002 + #xcd030015 + #xcd090006 + #xcd03000d + #xcdfe000e + #xff3310cf + #xe000730 + #x600ffcd + #x30016cd + #x90005cd + #x3000ecd + #xfe000ecd + #x3310cfcd + #x830ff + #x17cd14 + #x3cd04 + #x10cd08 + #xecd03 + #x18cd03 + #x18cd14 + #x2cd03 + #x11cd08 + #xecd03 + #x18cd03 + #x19cd13 + #x1cd03 + #x12cd08 + #xecd03 + #x17cd04 + #x1acd12 + #x13cd0d + #xecd03 + #x17cd04 + #x1bcd11 + #x13cd0c + #xfcd04 + #x17cd03 + #x1bcd11 + #x14cd0b + #x10cd03 + #x17cd03 + #x1dcd10 + #x15cd09 + #x10cd03 + #x17cd03 + #x1dcd0f + #x16cd09 + #x10cd03 + #x17cd03 + #x1ccd0f + #x17cd09 + #x10cd03 + #x17cd03 + #x1bcd0f + #x19cd08 + #x10cd03 + #x10cd04 + #x4cd01 + #x1acd0e + #x18cd09 + #x11cd04 + #xecd03 + #x4cd03 + #x19cd0e + #x19cd09 + #x11cd04 + #xccd03 + #x4cd05 + #x18cd0e + #x19cd0a + #x12cd03 + #xacd03 + #x4cd07 + #x17cd0d + #x18cd0d + #x12cd03 + #x8cd03 + #x5cd09 + #x16cd0c + #x18cd0e + #x12cd03 + #x6cd03 + #x5cd0b + #x19cd08 + #x1cd09 + #x18cd03 + #x12cd03 + #x4cd03 + #x5cd0d + #x18cd08 + #x2cd09 + #x17cd03 + #x12cd04 + #x1cd04 + #x5cd0f + #x17cd08 + #x3cd09 + #x17cd03 + #x14cd03 + #x6cd13 + #x15cd0a + #x5cd08 + #x16cd04 + #x14cd03 + #x7cd11 + #xfcd10 + #x7cd08 + #x16cd03 + #x14cd03 + #x9cd0f + #xdcd11 + #x8cd08 + #x16cd03 + #x12cd03 + #xacd0f + #xccd12 + #x9cd08 + #x15cd03 + #x10cd04 + #xbcd0f + #xacd13 + #xacd09 + #x15cd03 + #xfcd03 + #xccd0f + #x9cd14 + #xbcd09 + #x14cd04 + #xdcd03 + #xdcd10 + #x8cd14 + #xdcd09 + #x14cd03 + #xbcd03 + #xecd10 + #x7cd15 + #xecd09 + #x13cd03 + #x9cd04 + #x10cd10 + #x6cd15 + #xfcd09 + #x13cd03 + #x7cd04 + #x10cd12 + #x5cd15 + #x11cd08 + #x13cd03 + #x6cd03 + #x10cd14 + #xffcd04 + #x4cd0f + #x12cd08 + #x13cd03 + #x5cd03 + #x1cd0f + #x10cd03 + #x2cd03 + #x4cd0d + #x13cd08 + #x11cd04 + #x3cd04 + #x3cd0f + #x10cd03 + #x4cd02 + #x4cd0b + #x15cd08 + #x11cd03 + #x1cd04 + #x5cd0f + #x10cd03 + #x5cd02 + #x3cd09 + #x16cd09 + #x11cd03 + #x7cd14 + #x10cd03 + #x6cd01 + #x2cd09 + #x17cd09 + #x10cd03 + #x9cd13 + #x18cd04 + #x1cd09 + #x18cd09 + #x10cd03 + #xccd11 + #x18cd03 + #xffcd09 + #x19cd09 + #xfcd03 + #xecd10 + #x18cd03 + #x1acd13 + #xdcd04 + #x10cd0f + #x18cd03 + #x1dcd11 + #xbcd03 + #x12cd0f + #x19cd03 + #x1ecd0f + #x9cd03 + #x14cd0f + #x19cd03 + #x1fcd0e + #x8cd03 + #x16cd0e + #x1bcd03 + #x20cd0b + #x7cd03 + #x18cd0d + #x1dcd03 + #x21cd08 + #x7cd03 + #x1acd0b + #x1fcd03 + #x22cd05 + #x7cd03 + #x1bcd0a + #xfcd03 + #x0 + #x0 + #x0 + #x0 + ) + :layer2 (new 'static 'array uint32 736 + #x452301f8 + #xcdab8967 + #xff0077ef + #x7f007fcd + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7007f00 + #x20aa0d00 + #x4f60ff66 + #x20aa0d00 + #x4f60ff66 + #x20aa0d00 + #x60fc66 + #x77120700 + #xcd240001 + #xaa0d0012 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x6620aa0d + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x20aa0d00 + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xaa0d0011 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x6620aa0d + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x20aa0d00 + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xaa0d0011 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #xaa02bb05 + #x6666a6fb + #x6620cdcd + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x2bb0500 + #x24a6ffaa + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x12070000 + #xff441277 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #x4440974 + #xff441277 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x77044409 + #x43ff4412 + #x30ff3312 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #x1243ff44 + #x1130ff33 + #x1bb0600 + #x2406ff00 + #x60fc66 + #x77020700 + #x442174ff + #x331243ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #xff442174 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220a + #x30ff3306 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xa42ff44 + #x623ff22 + #x1130ff33 + #x1bb0600 + #x2406ff00 + #x60fc66 + #x77020700 + #x442174ff + #x220a42ff + #x330623ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #xff442174 + #xff220a42 + #xff330623 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220a + #x30ff3306 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xb42ff44 + #xff330622 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220b + #x30ff3305 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xc42ff44 + #xff330522 + #xff000d30 + #x4330303 + #xfe3301bb + #x66270630 + #x770207ff + #x442174ff + #x220c42ff + #x330423ff + #xd30ff + #x330303ff + #x3301bb04 + #x1c0630fe + #x9cfff66 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x60ff661b + #x7ff660a + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661b06 + #xff660acf + #xff770207 + #xff441f74 + #xff220f42 + #xff001220 + #x4330303 + #xfe3301bb + #x66270630 + #x770207ff + #x441f74ff + #x220f42ff + #x1220ff + #x330303ff + #x3301bb04 + #x270630fe + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1104 + #x7ff660b + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #xb110561 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1105 + #x7ff660a + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #xa110661 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1106 + #x7ff6609 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #x9110761 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1107 + #x7ff6608 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #x13660a06 + #x7cfff11 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x1114660a + #x7ff6607 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x2b111600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x2b221600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x2b221600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x54fe5514 + #xf660444 + #xf02ff00 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfe551422 + #x66044454 + #x2ff000f + #x20ff220f + #x3ff0012 + #x33312 + #x55142216 + #x44454fe + #xff000f66 + #xff220f02 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x54fe5514 + #xf660444 + #xf02ff00 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfe551422 + #x66044454 + #x2ff000f + #x20ff220f + #x3ff0012 + #x33312 + #x55142216 + #x44454fe + #xff000f66 + #xff220f02 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x44182216 + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221c0003 + #x441124ff + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221c0003 + #x441124ff + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #xf660e + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x24ff221e + #x660e4403 + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #xf660e + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x24ff221e + #x660e4403 + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #x14660e + #x81116 + #x331203ff + #x221c0003 + #x441424ff + #x11160014 + #x3ff0008 + #x33312 + #x24ff221c + #x144414 + #x81116 + #x331203ff + #x221c0003 + #x441424ff + #x11160014 + #x3ff0008 + #x33312 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x3d1116 + #x441404ff + #x11160014 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x3 + #x0 + ) + :layer3 (new 'static 'array uint32 1004 + #x452301f7 + #xcdab8967 + #x663300ef + #x134437 + #x44376633 + #x66330013 + #x134437 + #x44376633 + #x66330013 + #x134437 + #x77056633 + #x443074ff + #x66330013 + #x74ff7705 + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x4430770f + #x66260013 + #x444464fc + #xff770f47 + #x13442f74 + #x3662600 + #x2f771044 + #x25001344 + #x364ff66 + #x347ff44 + #x4440677 + #x2e74ff77 + #x24001344 + #x464ff66 + #x347ff44 + #xff440677 + #x2e770447 + #x24001344 + #x464ff66 + #x347ff44 + #x4440777 + #x2d74ff77 + #x24001344 + #xff440566 + #x7770347 + #x447ff44 + #x13442d77 + #x3662400 + #xff110144 + #xff770317 + #x4110271 + #xff770444 + #x13442c74 + #xff662300 + #xfc440264 + #x17111141 + #x11027704 + #x440314ff + #x770447ff + #x13442c + #x64ff6623 + #x11024402 + #x770417ff + #x110271ff + #x47ff4403 + #x442c7704 + #x66230013 + #x41ff4402 + #x77061102 + #x14ff1102 + #x47ff4402 + #x442c7704 + #x66230013 + #x41fc4402 + #x13171111 + #x5440477 + #x13442177 + #xff662200 + #xfd440264 + #x14111141 + #x5440477 + #x13442177 + #xff662200 + #xfd440264 + #x1f171141 + #x13442177 + #x1662200 + #x2347ff44 + #x13442177 + #x1662200 + #x21772444 + #x21001344 + #x4464fd66 + #x22772347 + #x21001344 + #x4464fd66 + #x22772347 + #x21001344 + #xff440166 + #x6771947 + #x22770244 + #x20001344 + #x4464fc66 + #x77124744 + #x440c74ff + #x777747fd + #x134422 + #x44026620 + #x771247ff + #x47fd440d + #x44227777 + #x661f0013 + #x440264ff + #x74ff7712 + #x47fd440d + #x44227777 + #x661f0013 + #x77134402 + #x47fd440e + #x44227777 + #x661e0013 + #x444464f9 + #x47447777 + #x440d7711 + #x777747fd + #x134422 + #x4401661e + #x44027701 + #x44fd770f + #x440c7777 + #x777747fd + #x134422 + #x64fc661d + #x3777744 + #xc47ff44 + #xfe440377 + #x440b7477 + #x777747fd + #x134422 + #x44fd661d + #x44057747 + #x74ff770b + #x47fd4403 + #x440a7477 + #x777747fd + #x134422 + #x47fd661d + #x44047477 + #x770b47ff + #x47fe4405 + #xfd440a77 + #x22777747 + #x1c001344 + #x7764fd66 + #xff440574 + #xfe440677 + #x44097447 + #x97477fe + #x7747fd44 + #x13442277 + #xfe661c00 + #x44057747 + #x67477fe + #x7447fe44 + #x77fe440a + #xfd440874 + #x22777747 + #x18001344 + #x264ff66 + #x4770144 + #x7747fe44 + #x47fe4407 + #xfe440a74 + #x44087747 + #x777747fd + #x134422 + #x64ff6615 + #x47fd4404 + #x44044774 + #x440877ff + #xb7447fe + #x7477fe44 + #x47fd4407 + #x44227777 + #x66120013 + #x77fd4408 + #x44037444 + #x87447fe + #x7447fe44 + #x47fe440b + #xfd440777 + #x22777747 + #x10001344 + #xfc440966 + #x74447447 + #x47fe4402 + #xfe440977 + #x440c7447 + #x67477fe + #x7747fd44 + #x13442277 + #xb660e00 + #x4477fd44 + #xff440347 + #xfe440a77 + #x440c7447 + #x67747fe + #x7747fd44 + #x13442277 + #xff660d00 + #xfc440a64 + #x74447747 + #x47fe4402 + #xfe440a74 + #x440d7447 + #x440677ff + #x777747fd + #x134422 + #x440b660d + #x447477f8 + #x47444474 + #xfe440b77 + #x440d7447 + #x57447fe + #x7747fd44 + #x13442277 + #xff660c00 + #xfd440b64 + #x2474477 + #x7477fe44 + #x47fe440b + #xfe440d74 + #x44057747 + #x777747fd + #x47fc4414 + #x9747777 + #xc001344 + #xa64ff66 + #x7447f844 + #x44444744 + #x440c7447 + #xe7447fe + #x577ff44 + #x7747fd44 + #xff441477 + #x9770247 + #xc001344 + #xf9440b66 + #x74447477 + #xd774444 + #x7447fe44 + #x47fe440e + #xff440374 + #x12770447 + #x247ff44 + #x874ff77 + #xc001344 + #xf9440b66 + #x44474477 + #x8747744 + #xd41ff44 + #xff440711 + #x5440377 + #x674ff77 + #xff770544 + #xff440374 + #x8770347 + #xc001344 + #x1440a66 + #x1711fb77 + #x9774744 + #xff110e44 + #xff440614 + #xff440277 + #xff770547 + #xff440474 + #xff770747 + #xff440274 + #xff770347 + #x13440774 + #xff660b00 + #xf9440964 + #x11717741 + #x9774411 + #xf41ff44 + #xfc440611 + #x44447447 + #x74ff7706 + #x47fd4403 + #x44057777 + #x27747fe + #x447ff44 + #x13440777 + #xff660b00 + #xfe440964 + #x11027711 + #x97417fe + #xff111044 + #xfc440514 + #x47447447 + #x74ff770c + #x77fb4407 + #x47444474 + #x74ff7704 + #x134406 + #x64ff660b + #x41fd4408 + #x11037711 + #x41ff4409 + #x44061111 + #xc4477fe + #x874ff77 + #x7747fb44 + #x5474444 + #x13440677 + #xff660b00 + #xfd440864 + #x3711711 + #x814ff11 + #xff111244 + #xfe440514 + #x77074777 + #x440e74ff + #x447477fc + #x6770547 + #xb001344 + #x764ff66 + #x1141fc44 + #x11037117 + #x440714ff + #x111341ff + #x47ff4405 + #x74ff7708 + #x47ff440e + #x44067708 + #x660b0013 + #x440764ff + #x77ff1101 + #x14ff1104 + #x11144407 + #x440414ff + #x770847ff + #x440f74ff + #x44067708 + #x660b0013 + #x440664ff + #x111141fc + #xff110477 + #xff440614 + #x5111541 + #xff770844 + #xff441174 + #x6770547 + #xb001344 + #x664ff66 + #xff110244 + #x7110471 + #xff111644 + #x8440414 + #x1174ff77 + #x547ff44 + #x13440677 + #x5660c00 + #x1141fb44 + #x3711711 + #x714ff11 + #x4111744 + #xff770844 + #xff441174 + #x6770547 + #xc001344 + #x2440566 + #x7117fe11 + #x44081103 + #x14ff1117 + #x77084403 + #x441274ff + #x44067705 + #x660c0013 + #x41ff4404 + #x17ff1102 + #x14fc1103 + #x5144444 + #xfd111944 + #x8444414 + #xff441377 + #x6770447 + #xc001344 + #x3440466 + #x377ff11 + #x4414fc11 + #x44051441 + #x14ff1104 + #x41ff440d + #x14fd1104 + #x77074444 + #x441474ff + #x44067704 + #x660b0013 + #x440364ff + #x110341ff + #x110377ff + #x414414fd + #x11044406 + #x41ff440e + #x14fd1104 + #x77074444 + #x47ff4415 + #x74ff7702 + #x134406 + #x4403660b + #x71fe7704 + #xfd110377 + #x5144414 + #x341ff44 + #xf14ff11 + #xfd110444 + #x6444414 + #x1674ff77 + #x7770244 + #xb001344 + #xff440266 + #x3770647 + #x4114fd11 + #xfe440514 + #x11024111 + #x41ff4410 + #x14fd1103 + #x77064444 + #x47fd4417 + #x44077477 + #x660b0013 + #x77074402 + #x14fe1103 + #xfa440541 + #x11441441 + #x44111411 + #x14fd1103 + #x77054444 + #x442274ff + #x660b0013 + #x47ff4401 + #x11037707 + #x44051401 + #x441611ff + #x14fd1103 + #x77054444 + #x134423 + #x4401660b + #x11047708 + #x41fe4405 + #x3441614 + #x4414fd11 + #xff770444 + #x13442374 + #xfe660b00 + #x77084744 + #x44051104 + #x441711ff + #x14fd1103 + #x77044444 + #x134424 + #x67ff6607 + #x1103770d + #x440414ff + #x171441fe + #xfd110344 + #x4444414 + #x13442477 + #xff660700 + #x3770d67 + #x414ff11 + #x1811ff44 + #xfd110344 + #x4444414 + #x13442477 + #xff660700 + #x3770d67 + #x314ff11 + #x1441fe44 + #x11034418 + #x444414fd + #x44247704 + #x66070013 + #x770d67ff + #x14ff1103 + #x11ff4403 + #x41ff4418 + #x14fd1103 + #x77044444 + #x134424 + #x67ff6607 + #x1105770d + #x41fe4401 + #x4441814 + #x4414fd11 + #x24770444 + #x7001344 + #xd67ff66 + #xfd110577 + #x18114414 + #x441ff44 + #x4414fd11 + #x24770444 + #xb001344 + #x8440166 + #xfe110677 + #x44181441 + #x14fd1105 + #x77044444 + #x134424 + #x4401660b + #x770747ff + #x44191107 + #x14fd1105 + #x77044444 + #x134424 + #x64ff660a + #x77024402 + #x111171fb + #x11077117 + #x11054419 + #x444414fd + #x74ff7704 + #x134423 + #x64ff660a + #x47fd4402 + #x11037777 + #x110771ff + #x441814ff + #x14fd1105 + #x77054744 + #x134423 + #x64ff660a + #x77014403 + #x71ff1103 + #x14ff1107 + #x11064418 + #x770644ff + #x442274ff + #x660a0013 + #x440564ff + #x71ff1103 + #x14fd1107 + #x44163333 + #x14ff1106 + #x74ff7706 + #x134422 + #x64ff660a + #x11034405 + #x110777ff + #x333314fd + #x11074416 + #x74ff7706 + #x134422 + #x64ff660a + #x41ff4405 + #x77ff1102 + #x14fd1107 + #x44163333 + #x77061107 + #x442274ff + #x660a0013 + #x11024407 + #x110777ff + #x333314fd + #x11074416 + #x74ff7706 + #x134422 + #x4407660a + #x111141fc + #xfd110717 + #x16333344 + #xff110744 + #xff770517 + #x13442274 + #xff660900 + #xfb440764 + #x17111141 + #xfc110571 + #x33334414 + #x11084416 + #x74ff7705 + #x134422 + #x64ff6609 + #x41fb4407 + #x71171111 + #x44011105 + #x44163301 + #x77051108 + #x442274ff + #x66090013 + #x440764ff + #x111141fb + #x11047117 + #x444414fb + #x44163333 + #x77051108 + #x442274ff + #x66090013 + #x41ff4408 + #x77ff1102 + #x44011104 + #x333343fc + #x8441534 + #xff770511 + #x13442274 + #x8660900 + #x241ff44 + #x377ff11 + #x4414f911 + #x33334344 + #x8441534 + #x4774fe11 + #x74ff7703 + #x134422 + #x44086609 + #x110241ff + #x110377ff + #x43fc4402 + #x15343333 + #x641ff44 + #x7417fd11 + #x23770344 + #x8001344 + #x864ff66 + #x241ff44 + #x7117fb11 + #x2141111 + #x3343fc44 + #x44163433 + #x17f91106 + #x77474474 + #x44237477 + #x66080013 + #x440864ff + #x110241ff + #x117117fc + #xfc440311 + #x34333343 + #x41ff4416 + #x77ff1105 + #x134429 + #x64ff6608 + #x41ff4408 + #x77fd1103 + #x44031411 + #x333343fc + #x5441734 + #x2977ff11 + #x8001344 + #x3440a66 + #x1177fe11 + #x43fc4404 + #x17343333 + #x341ff44 + #x7417fe11 + #x134429 + #x44096608 + #x21441fe + #x7417fe11 + #x43ff4404 + #x44183302 + #x17fe1103 + #xff442a74 + #x7001140 + #x964ff66 + #x4441fe44 + #x17fe1102 + #xff440477 + #xff330243 + #x3441734 + #x2b77ff11 + #x1140ff44 + #xff660700 + #xff440964 + #xfd440211 + #x4777747 + #x343ff44 + #xfe441633 + #x11021441 + #x442b74ff + #x1140ff + #x64ff6607 + #x41fe4408 + #x1440314 + #x474ff77 + #xff330344 + #xff441534 + #xfe440211 + #x442b7447 + #x1140ff + #x44096607 + #x31441fe + #x7747fd44 + #xff440477 + #x14330343 + #x1141fe44 + #x77fe4402 + #xff442b74 + #x7001140 + #xff440966 + #xfd440411 + #x5777747 + #xff330344 + #xfa441334 + #x44441411 + #x442c7747 + #x1140ff + #x44096607 + #x440511ff + #x74ff7701 + #x43ff4404 + #x44133303 + #x440211ff + #x2c7477fe + #x1140ff44 + #xff660600 + #xfe440864 + #x44051441 + #x777747fd + #x33034405 + #x441134ff + #x21441fe + #x2d77ff44 + #x1140ff44 + #x9660600 + #x741ff44 + #xff770144 + #xff440474 + #x6330343 + #xff440a11 + #xfe440211 + #x442d7447 + #x1140ff + #x440a6605 + #x440711ff + #x777747fd + #x33034405 + #x14ff1106 + #x41fe4408 + #xff440214 + #xff442e77 + #x4001140 + #xa64ff66 + #x714ff44 + #x7747fc44 + #x44047477 + #x333343fc + #x8110731 + #x1411fa44 + #x74474444 + #x94437 + #x440a6604 + #x81441fe + #x5770244 + #x8330144 + #x614ff11 + #x1141fe44 + #x77ff4402 + #xc4438 + #x41ff440c + #x47fc4409 + #x4747777 + #x3143fe44 + #x14f9110f + #x44441441 + #x44387477 + #x440c000c + #x440a11ff + #x774477fd + #x41ff4404 + #x44011112 + #x397747fe + #x18000c44 + #x4447fc44 + #x44037747 + #x111141ff + #x444414fb + #x44397477 + #x4419000c + #x774474fc + #xff440274 + #xf7110c41 + #x71777717 + #x77441111 + #xc443a77 + #xf8441900 + #x77444477 + #x41444474 + #x7703110c + #x47fe1101 + #xc443b77 + #xfb441c00 + #x44747747 + #xff110541 + #xfc770917 + #x74771771 + #xc443b + #x47fc441d + #x5417477 + #x3c770d11 + #x1e000c44 + #x7747fd44 + #xff110477 + #xfe770b17 + #x443c1471 + #x441f000c + #x777747fd + #x770b1103 + #x141171fd + #xc443c + #x47fa4420 + #x11717777 + #xfd770b11 + #x3c141171 + #x21000c44 + #xf11ff44 + #x1171fd77 + #xc443c14 + #xfc442100 + #x17111141 + #x71fd770c + #x443c1411 + #x4422000c + #x770b1103 + #x3d1171fe + #x22000c44 + #x241ff44 + #xfe770b11 + #x443d1471 + #x4423000c + #x770b1102 + #x443e71ff + #x4423000c + #x111141fd + #x74ff770b + #xc443e + #x11014424 + #x770a17ff + #xc443f + #x41fd4424 + #x77091111 + #x443f74ff + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x41fd440a + #x701111 + #x440a04ff + #x701102 + #x440a04ff + #x701102 + #x440a04ff + #x701102 + #x440904ff + #x110241ff + #x4ff0070 + #x11034409 + #x4ff0070 + #x11034409 + #x2ff0049 + #x6221e + #x440804ff + #x110341ff + #x2ff0049 + #x6221e + #x440804ff + #x491104 + #x221e02ff + #x14ff1107 + #x11044407 + #x2ff0049 + #x1107221e + #x440614ff + #x110441ff + #x2ff0049 + #x110a221e + #x440214ff + #x110541ff + #x2ff0049 + #x110b221e + #x74144fe + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x14221f02 + #xff004911 + #xff221f02 + #x49111321 + #x2002ff00 + #x49111322 + #x2002ff00 + #x49111322 + #x2002ff00 + #x1221ff22 + #xff004911 + #xff222002 + #x49111221 + #x2102ff00 + #x49111222 + #x2102ff00 + #x1121ff22 + #xff004911 + #xff222102 + #x49111121 + #x2102ff00 + #x1121ff22 + #xff004911 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #x1120 + ) + :layer4 (new 'static 'array uint32 860 + #x450300f7 + #xcdab8967 + #x7fcdef + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x40007f + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x10660d + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x10660d + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #xa660d + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #xa660d + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x777707fd + #x1cd03 + #x330b03ff + #xcc083cff + #x47c0ff + #x660d06ff + #x30fc3306 + #x3777707 + #xff0001cd + #xb330903 + #x47c0ffcc + #xd06ff00 + #xfb330666 + #x77774434 + #x1cd0270 + #x803ff00 + #xb3cff33 + #x47c0ffcc + #xd06ff00 + #xfe330666 + #x77024434 + #x1cd02 + #x330803ff + #xc0ffcc0c + #x6ff0047 + #x3306660d + #x474434fb + #xcd027777 + #x3ff0005 + #x3cff3303 + #xc0ffcc0c + #x6ff0047 + #x3306660d + #x47ff4402 + #xfcfcff06 + #x3c3cccc + #xc3cff33 + #x47c0ffcc + #xd06ff00 + #x2330666 + #xfcff0744 + #xc3ccccfc + #x3cff3303 + #xc0ffcc0c + #x6ff0047 + #x3306660d + #xff074402 + #xc3ffcc02 + #x3cff3303 + #xc0ffcc0c + #x6fd0047 + #x44026666 + #x33066608 + #x4fff4401 + #xfcffff06 + #xc3ffcc02 + #x3cff3303 + #xc0ffcc0c + #x6fd0047 + #x44026666 + #x660746ff + #x330463ff + #xf4ff3ffc + #xffff064f + #xffcc02fc + #xff330393 + #xffcc0c3c + #xfd0047c0 + #x3666606 + #xff660744 + #xa330463 + #x7cc03ff + #xffcc0199 + #x49dd06cd + #x206ff00 + #x4464fd66 + #xff660744 + #x9330463 + #xffcc03ff + #x19907c9 + #x49dd07cc + #x206ff00 + #x4464f966 + #x64664644 + #x4660444 + #xfdff0833 + #xaccccfc + #x7cc0199 + #xff0049dd + #xf8660206 + #x46444464 + #x46444464 + #x33046603 + #xcc01ff08 + #x990ac9ff + #x9dffcc01 + #x49dd06 + #x660206ff + #x440564ff + #x660546ff + #xff060003 + #xc9ffcc01 + #xdd06990e + #x6fd0049 + #x44076466 + #x660546ff + #xcfff0003 + #xcc01ff05 + #xdd06990f + #x6fd0049 + #x44036466 + #x440264ff + #x660546ff + #xcd030003 + #x5555f5fc + #x69910cc + #xfd0049dd + #x2646606 + #x6646fe44 + #x46ff4402 + #x36605 + #x5501cd04 + #xdd069911 + #x6f80049 + #x44646666 + #x2666646 + #x3660644 + #x1cd0400 + #x6991155 + #xff0049dd + #x1660606 + #x646ff44 + #x4000366 + #x5955fecd + #x9dff9910 + #x49dd06 + #x660606ff + #x66034401 + #x665665fc + #x5000366 + #x69912cd + #xff0049dd + #xff660606 + #x1660464 + #x3660155 + #x12cd0500 + #x59dff99 + #xff0049dd + #x1660c06 + #x6656fe55 + #x9ff0003 + #x90fe9902 + #xff9912cd + #x49dd059d + #xc06ff00 + #x5565fc66 + #x36655 + #x991709ff + #x49dd06 + #x660c06ff + #x550265ff + #x250ff + #x991609ff + #xdd069dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #x9ff0002 + #x9dff9916 + #x49dd06 + #x660c06ff + #x50ff5503 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660b06ff + #x50ff5504 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660a06ff + #x550465ff + #x250ff + #x991509ff + #xdd079dff + #x6ff0049 + #x65ff660a + #x50ff5504 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660c06ff + #x50ff5503 + #x9ff0002 + #x9dff9914 + #x49dd08 + #x660c06ff + #x550265ff + #x250ff + #x991309ff + #xdd099dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbfd0002 + #x9910b9bb + #xdd0a9dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbff0002 + #x990fbb02 + #xdd0a9dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbff0002 + #xb9ffbb02 + #x9dff990e + #x49dd0a + #x661006ff + #x260ff + #xbb030bff + #x9dff990d + #x49dd0b + #x661006ff + #x260ff + #xbb030bff + #x990cb9ff + #xdd0b9dff + #x6ff0049 + #x60ff6610 + #xbff0002 + #xb9ffbb03 + #x9dff990c + #x49dd0b + #x661006ff + #x260ff + #xbb030bff + #x990cb9ff + #xdd0b9dff + #x6ff0049 + #x60ff6610 + #xbff0002 + #xb9ffbb03 + #x55019906 + #x94fd9903 + #x534444 + #x661006ff + #x260ff + #xbb030bff + #x9906b9ff + #x99ff5501 + #x54fd5502 + #x5a4444 + #x330b03ff + #xbff0001 + #xbffcbb03 + #x3f9ffff + #xff550199 + #xfd550299 + #x5a444454 + #xb03ff00 + #xff000133 + #xfcbb030b + #xf9ffffbf + #x55059903 + #x444454fd + #x30ff3302 + #x3ff0056 + #x1330b + #xbb030bff + #xffffbffc + #x59903f9 + #x4454fd55 + #xff330244 + #xff005630 + #x1330b03 + #x30bff00 + #xffbffbbb + #x255f5ff + #xfd550599 + #x5444454 + #x5330ff33 + #xb03ff00 + #xff000133 + #xf8bb030b + #xf5ffffbf + #x99995955 + #x54fd5505 + #x33054444 + #x5330ff + #x330b03ff + #xbff0001 + #xbff8bb03 + #x55f5ffff + #x5959955 + #x4454fd55 + #x2000244 + #x5370ff77 + #xb03ff00 + #xff000133 + #xfcbb030b + #xf5ffffbf + #x50ff550a + #x77020003 + #x5370ff + #x330b03ff + #xbff0001 + #xbfffbb03 + #x1ff02 + #x550805ff + #x77020003 + #x5c70ff + #x23303 + #xff02bb04 + #x5ff0002 + #x25508 + #x70ff7702 + #x3303005c + #xbff0002 + #xbffdbb03 + #x3ffff + #x550705ff + #x77020002 + #x4a70ff + #x3303cc11 + #xffcc02 + #xffbb0a + #x25507 + #x70ff7702 + #xcc11004a + #xcc023303 + #x90bc0fe + #x700ffbb + #x50fd55 + #xff770200 + #x11004a70 + #x33303cc + #x900ffcc + #x70001bb + #x50fe55 + #x70ff7702 + #xcc10004a + #x3303c3ff + #xc0fecc03 + #x1bb080b + #x705ff00 + #x288ff55 + #x4a70ff77 + #xffcc1000 + #xff3302c3 + #xffcc043c + #x3bb0800 + #xfe550500 + #x77028858 + #x4a70ff + #x3302cc11 + #xcc043cff + #x70bc0fe + #xff0003bb + #x1550405 + #x7787fd88 + #x11004b77 + #xff3302cc + #xfecc053c + #xbb060b00 + #x55030004 + #x880258ff + #x4b7077fe + #xfccc1100 + #x3c3333c3 + #x1cc05 + #x8bb06 + #x80ff8804 + #xcc11004b + #x3333c3fd + #xc4fdcc06 + #xbb050b44 + #x88040008 + #x4b80ff + #x7702cc11 + #xc4fdcc06 + #xbb050044 + #x88040008 + #x4b80ff + #x7702cc11 + #xc4fccc06 + #x40b0044 + #x14406bb + #xff880200 + #x4a660286 + #x2cc1100 + #x2cc0577 + #xff000144 + #x6bb030b + #x2000144 + #x4a660388 + #x2cc1100 + #x44cff44 + #x24402cc + #x7330200 + #x1000144 + #x386ff88 + #xa004a66 + #x66c6f9cc + #x88886866 + #xff440284 + #x2cc044c + #x2000244 + #x1440733 + #x4880100 + #xa004a66 + #xfc6602cc + #x84888868 + #x4cff4402 + #xc4fdcc04 + #x24444 + #x44073302 + #x66040003 + #xcc09004a + #x6602c6ff + #x888868fc + #xff440284 + #xffcc044c + #x24404c4 + #x3440733 + #x4a660400 + #x3cc0900 + #x8868fc66 + #x44028488 + #xcc044cff + #x4404c4ff + #x44073302 + #x66040003 + #xcc09004a + #x68fc6603 + #x2848888 + #x44cff44 + #x4c4ffcc + #x7330244 + #x4000344 + #x9004a66 + #xfc6603cc + #xc4cccc6c + #x4cff4402 + #xc4ffcc04 + #x33024404 + #x34407 + #x4a6604 + #x6603cc09 + #xcc0299ff + #x4444c4fd + #xc4ffcc05 + #x33024404 + #x6604440b + #xcc09004a + #x6666c6fa + #xa9c9969 + #x6c4ffcc + #xc34ff44 + #x5545fc44 + #x4a6666 + #xc6fecc0a + #xa990266 + #x6c4ffcc + #xc34ff44 + #x245ff44 + #xc004a55 + #xff9902cc + #xffcc0995 + #xff4406c4 + #xff440c34 + #x4a550245 + #x1cc0d00 + #x5c55fe99 + #xc4ffcc08 + #x34ff4406 + #x5502440d + #xcc0d004a + #x559599fc + #x7cc085c + #xd34ff44 + #x5545fd44 + #xd004a55 + #x2c9ffcc + #x7cc0855 + #xe34ff44 + #x4a550144 + #x3cc0d00 + #x75cff55 + #xff4407cc + #x1440e34 + #x7004a55 + #x35501cc + #xff5503cc + #xffcc075c + #xff4406c4 + #x1440e34 + #x6004a55 + #x55c5fccc + #xcc025c55 + #x5cff5503 + #xc4ffcc07 + #x34ff4406 + #x4c440e + #xc5ffcc06 + #x5cff5509 + #xc4ffcc07 + #x34ff4406 + #x4c440e + #xc5ffcc06 + #xcc085509 + #x4406c4ff + #x440e34ff + #xcc06004c + #x5502c5ff + #xc5fccc02 + #x85c5555 + #x6c4ffcc + #xe34ff44 + #x6004c44 + #x2c5ffcc + #xfdcc0255 + #x95555c5 + #x6c4ffcc + #xe34ff44 + #x6004c44 + #x55c5fdcc + #x6cc1055 + #x3343fe44 + #x4c440e + #xc5fdcc06 + #xcc105c55 + #x33014406 + #x4c440e + #xc4ffcc19 + #x33014406 + #x440d34ff + #xcc18004c + #x4406c4ff + #x333343fc + #x4c440d34 + #xfdcc0600 + #xe7c77c7 + #x6c4ffcc + #xd330344 + #x6004c44 + #x77c7fdcc + #x7cc0e7c + #xd330344 + #x6004c44 + #x77c7fccc + #xcc0d7c77 + #x33074407 + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #x4407cc0c + #x330643ff + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #xc4ffcc0b + #x33064408 + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #xc4ffcc0b + #x43ff4409 + #x44093304 + #xcc05004c + #x233c3fe + #xb7cff77 + #xac4ffcc + #x9330444 + #x5004c44 + #x33c3facc + #x7c777737 + #xc4ffcc0b + #x43fd440b + #x440a3333 + #xcc05004c + #x37fc3301 + #xb7c7777 + #xbc4ffcc + #x3343fd44 + #x4c440a33 + #xffcc0400 + #xfe3302c3 + #xcc0c7737 + #x440bc4ff + #x330243ff + #x4c4409 + #x66fecc02 + #xff3304cc + #xffcc0c3c + #xff440bc4 + #xff330243 + #x4000330 + #x2004c44 + #x6c66fecc + #x3cff3304 + #x440dcc0c + #x36ff3302 + #x44046603 + #xcc01004c + #x6c66c6fd + #x3cff3304 + #x440dcc0c + #x333343fc + #x4660336 + #x1004c44 + #x46602cc + #xb3cff33 + #xec4ffcc + #xa330244 + #x4960ff66 + #xc6ccfe00 + #xccfb6602 + #x666636c3 + #xc4ffcc0c + #x3302440e + #x660936ff + #x4960ff + #x6603ccff + #x6601cc02 + #xc4ffcc0c + #x66fd440e + #x660a3633 + #x4960ff + #x6602ccff + #xcc026cff + #xcc0d6601 + #x66fe440e + #xff660b36 + #xff004960 + #xff6602cc + #x1cc026c + #xecc0d66 + #xff660d44 + #xff004960 + #xff6602cc + #x1cc026c + #xffcc0d66 + #x94403c4 + #xff660d00 + #xfe004960 + #x6602c6cc + #xcccc6cfb + #xcc0e6666 + #x94403 + #x60ff660d + #xcc020049 + #xcc016602 + #xcc0e6601 + #x4402c4ff + #x660d0009 + #x4960ff + #xc6ffcc02 + #xcc0e6605 + #x4402c4ff + #x660d0009 + #x4960ff + #x6605cc03 + #x4401cc0f + #x940ff + #x60ff660d + #xcc030049 + #x6604c6ff + #x4401cc0f + #x1040ff + #x660506ff + #x4960ff + #xc6ffcc03 + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #x6ff004d + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #x6ff004d + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #xcff0051 + #x13cc10 + #x660506ff + #x5160ff + #xcc100cff + #x6ff0013 + #x60ff6605 + #xcc08005a + #x6ff0013 + #x60ff6605 + #xcc08005a + #x6ff0013 + #x60ff6605 + #x6ff0077 + #x60ff6605 + #x6ff0077 + #x60ff6605 + #x6ff0077 + #x88fe6604 + #xff007780 + #xfe660406 + #x778088 + #x660306ff + #x808868fd + #x7ff0064 + #x3770d + #x660306ff + #x80ff8801 + #x7ff0064 + #x8804770d + #x88016603 + #x6480ff + #x770d07ff + #x86fe8805 + #xff880266 + #xff006480 + #xa770d07 + #x6480ff88 + #xd07ff00 + #xff880a77 + #xff006480 + #x9770e07 + #x6480ff88 + #x307ff00 + #x5755fe77 + #x78ff7708 + #x80ff8808 + #x7ff0064 + #x55017703 + #x88087709 + #x6480ff + #x770207ff + #x555575fc + #x8770857 + #x6480ff88 + #x207ff00 + #x8550377 + #x778ff77 + #x6480ff88 + #x7707fc00 + #x55037577 + #x770757ff + #x6d70ff + #x777707fd + #x77075505 + #x6d70ff + #x757707fd + #x57ff5505 + #x70ff7706 + #x7fd006d + #x55067577 + #x70ff7706 + #x7fd006d + #x55067777 + #x70ff7706 + #x7fc006d + #x5757777 + #xff770655 + #xfc006d70 + #x75777707 + #x57ff5504 + #x70ff7706 + #x7ff006d + #x55047702 + #x70ff7707 + #x7ff006d + #x75ff7702 + #x77085502 + #x6d70ff + #x770307ff + #x57ff5501 + #x70ff7708 + #x7ff006d + #x75fe7703 + #xff770955 + #xff006d70 + #xff770407 + #xff770957 + #xff006d70 + #xff770f07 + #xff006d70 + #xff770f07 + #x7f007f70 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2a00 + #x0 + #x0 + ) + :layer5 (new 'static 'array uint32 932 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x15007f00 + #x6770600 + #x3323ff22 + #xb30ff33 + #x406ff00 + #x2860ff66 + #x6770600 + #x3323ff22 + #xb30ff33 + #x406ff00 + #x2860ff66 + #x6770600 + #x4023ff22 + #x436ff33 + #x2860ff66 + #x6770600 + #x2423ff22 + #x13550733 + #x436ff33 + #x2860ff66 + #x6770600 + #x2223ff22 + #x935ff33 + #x1253ff55 + #xff660433 + #x6002860 + #xff220677 + #xff332023 + #x11550d35 + #x336ff33 + #x2860ff66 + #x6770600 + #x1e23ff22 + #x1035ff33 + #x3331155 + #x2860ff66 + #x6770600 + #x1d23ff22 + #x1235ff33 + #xf53ff55 + #x236ff33 + #x2860ff66 + #x6770600 + #x1c23ff22 + #x4551733 + #x335ff33 + #x2330455 + #x2860ff66 + #x46770600 + #xfc330455 + #x60666636 + #x77060028 + #x33055546 + #x60ff6601 + #x77060028 + #x33055546 + #x606636fd + #x77060028 + #x33065546 + #x286066fe + #x46770600 + #xff330655 + #x6002930 + #x6554677 + #x2a30ff33 + #x46660500 + #xff330655 + #x5002a30 + #x6554666 + #x2a30ff33 + #x3660500 + #xa54afb44 + #x38aa5a55 + #x305ff00 + #xff330655 + #x5002a30 + #xfb440366 + #x5a55a54a + #xff0038aa + #x6550305 + #x2a30ff33 + #x6660200 + #xa54afb44 + #x3baa5a55 + #xff330800 + #x2002a30 + #xff440666 + #x28aa034a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x6660200 + #x34aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x2002a30 + #xff440666 + #x28aa034a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x1660500 + #x54aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x5002a30 + #xff440166 + #x28aa054a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x1660500 + #x54aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x5002a30 + #x3040ff66 + #xe01ff00 + #x8000211 + #x2a30ff33 + #xff660500 + #xff003040 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xfc110701 + #x64666616 + #x33084405 + #x6230ff + #x110701ff + #x666616fc + #x8440564 + #x6230ff33 + #x701ff00 + #x6616fc11 + #x44056466 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x4ff006d + #x33084406 + #x6d30ff + #x440604ff + #x30ff3308 + #x4ff006d + #x33084406 + #x6d30ff + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x582217 + #x110301ff + #x32ff3308 + #x582217 + #x110301ff + #x330713ff + #x220732ff + #x440624ff + #x582207 + #x110401ff + #x32ff3307 + #x24ff2207 + #x77044406 + #x5a70ff + #x110401ff + #x32ff3307 + #x27ff2207 + #x70ff770b + #x1ff005a + #x33071104 + #x220732ff + #x770b27ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x440b14ff + #x240ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x40ff440c + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x440c1104 + #x240ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x40ff440c + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x5503440b + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440b04ff + #x550245ff + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440b04ff + #x550245ff + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440a04ff + #x550354ff + #x770b57ff + #x2e70ff + #x76613 + #x13770d + #x57ff5504 + #x70ff770b + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x13770d + #x55506 + #xa0ffaa04 + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x13770d + #x55506 + #xa0ffaa04 + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x7aff7707 + #xa0ffaa03 + #x55060013 + #x66010003 + #xa6fdaa04 + #x2c6066 + #xc6613 + #x444404fc + #xffaa034a + #x60013a0 + #x2000355 + #xfcaa0266 + #x606666a6 + #x6613002c + #x4fc000c + #x34a4444 + #x13a0ffaa + #x3550600 + #xff660800 + #x13002c60 + #xfc000c66 + #x4a444404 + #xa0ffaa03 + #x55060013 + #x66080003 + #x2c60ff + #xc5513 + #x444404fc + #xffaa034a + #x60013a0 + #x8000355 + #x2c60ff66 + #xc551300 + #x4404fc00 + #xaa034a44 + #x13a0ff + #x35506 + #x60ff6608 + #x5513002c + #x4fc000c + #x34a4444 + #x13a0ffaa + #x3550600 + #xff660800 + #xfd002c60 + #x10757755 + #xfc000c55 + #x4a444404 + #xa0ffaa03 + #x55060013 + #x66080003 + #x2c60ff + #x757755fd + #xc5510 + #x444404fc + #xffaa034a + #x60013a0 + #x8000355 + #x2c60ff66 + #x7757fd00 + #xc551075 + #x4404fc00 + #xaa034a44 + #x13a0ff + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107777 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107757 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fc002e + #xf757757 + #xff000c55 + #x13440704 + #x5550600 + #xff330400 + #x1002e30 + #xf770155 + #xff000c55 + #xff440304 + #x12330343 + #x5550600 + #xff330400 + #x1002e30 + #x7757fe55 + #xc550f + #x440304ff + #x330343ff + #x6604000d + #x55506 + #x30ff3304 + #x5502002e + #x550f75ff + #x4ff000c + #x43ff4403 + #xd3303 + #x55066604 + #xdfe0003 + #xff3304dd + #x13002e30 + #xff000c55 + #xff440304 + #xd330343 + #x6660400 + #xfd000355 + #x2dddd0d + #xdd3dfd33 + #x13002ddd + #xfa000c55 + #x55454404 + #x33034344 + #x6604000d + #x35506 + #xdd070dff + #x5513002d + #x4fa000c + #x44544544 + #xd330343 + #x6660400 + #xff000355 + #x2ddd070d + #xfe550a00 + #x5506aa5a + #x4fa000c + #x44545544 + #xb330343 + #xffaa0100 + #x66603a6 + #xff000355 + #x2ddd070d + #xff550800 + #xffaa045a + #xfa0010a0 + #x54554404 + #x33034344 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5508002d + #xaa045aff + #x10a0ff + #x556606fd + #x33036602 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5507002d + #xaa055aff + #x10a0ff + #x660406ff + #xb3303 + #xa6ffaa01 + #x55066603 + #xdff0003 + #x2ddd07 + #x5aff5507 + #xa0ffaa05 + #x6ff0010 + #x33036604 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5507002d + #xaa055aff + #x10a0ff + #x660406ff + #x330263ff + #xaa01000b + #xea0ff + #xaa050aff + #x2ea0ff + #x5aff5507 + #xa0ffaa05 + #x6ff0010 + #x63ff6604 + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #x5507002e + #xaa055aff + #x10a0ff + #x660506ff + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #xaff0036 + #xa0ffaa05 + #x6ff0010 + #x33026605 + #xaa01000b + #xea0ff + #xaa050aff + #x36a0ff + #xaa050aff + #x10a0ff + #x660506ff + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #x1103002e + #x210ff + #xaa050aff + #x10a0ff + #x660406ff + #x330263ff + #xaa01000b + #xea0ff + #xaa050aff + #x2ea0ff + #x10fd1103 + #x44020000 + #xaa034aff + #x10a0ff + #x660406ff + #x333363fc + #xffaa0d3a + #xff000ea0 + #xffaa050a + #x3002ea0 + #x10fd11 + #x12440600 + #x406ff00 + #xff330266 + #xffaa0d3a + #xff000ea0 + #xffaa050a + #x3002ea0 + #x10fd11 + #x12440600 + #x306ff00 + #x263ff66 + #xd3aff33 + #xa0fdaa + #xff220c00 + #xffaa052a + #x3002ea0 + #x10fd11 + #x12440600 + #x306ff00 + #x263ff66 + #x1030ff33 + #xfe220d00 + #xaa03ee2e + #x2ea0ff + #x10fd1103 + #x44060000 + #x2ff002c + #x2efd220d + #x32e0ee + #x16fd1103 + #x44066666 + #xff0b0020 + #x220df2ff + #xe0ee2efd + #x11030032 + #x660616ff + #x204401 + #x5502f5ff + #x12ff1107 + #x2efd220d + #x32e0ee + #x16ff1103 + #x44016606 + #xf5ff0020 + #x11075502 + #x220d12ff + #xe0ee2efd + #x11030032 + #x660616ff + #x204401 + #x5502f5ff + #x1ffa1102 + #x11f1ffff + #xfc220c12 + #x2022dd2d + #x11030032 + #x77033302 + #x2270ff + #x5502f5ff + #x1ffa1102 + #x11b1bbff + #xfc220c12 + #x2022dd2d + #x11030032 + #x77033302 + #x2270ff + #xbbfcff08 + #xc1211b1 + #xdd2dfc22 + #x322022 + #x33021103 + #x70ff7703 + #xff080022 + #xffbfbbfc + #xff220ff2 + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x220cf2ff + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x2222f2fb + #x22083323 + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x2222f2fb + #x22083323 + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfbff0b00 + #x232222f2 + #x2220833 + #x3920ffaa + #xff220300 + #x2002220 + #xddfdfeff + #xf2fcff06 + #x9424422 + #xffaa0222 + #x3003920 + #x1820ff22 + #x804ff00 + #xfeff0244 + #xff06ddfd + #x4422f2fc + #x2220942 + #x3920ffaa + #xff220300 + #xff001820 + #x2440804 + #xddfdfeff + #xf2fcff06 + #x9424422 + #xffaa0222 + #x3003920 + #x320ff22 + #x7550c00 + #x804ff00 + #xffff0b44 + #x2220cf2 + #x3920ffaa + #xff220300 + #xc000320 + #x700fe55 + #x17703 + #x440804ff + #xf2feff0b + #xff770627 + #x2220372 + #x3920ffaa + #xff220300 + #xc000320 + #x700fe55 + #xaa017703 + #x4408a4ff + #xf2feff0b + #xff770627 + #xff220672 + #x3003920 + #x320ff22 + #xff550d00 + #xfd770357 + #x8a4aa7a + #xfeff0b44 + #x770a27f2 + #x20ff2203 + #x22030039 + #x320ff + #x57ff550d + #x7afd7703 + #x4408a4aa + #xf2feff0b + #x3770a27 + #x3920ff22 + #xff220300 + #xd000320 + #x357ff55 + #xaa7afd77 + #xb4408a4 + #x27f2feff + #x2203770a + #x3820ff + #x551605ff + #x770357ff + #xa4aa7afd + #xff0b4408 + #xa27f2fe + #xff220377 + #xff003820 + #xff551605 + #xfd770357 + #x8040070 + #x55f0ff44 + #x1605ff00 + #x357ff55 + #x70fd77 + #xff440804 + #xff0055f0 + #xff551605 + #xfd770357 + #x8040070 + #x66f0ff44 + #x505ff00 + #x357ff55 + #x7f70ff77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x3c007f00 + #x0 + #x0 + #x0 + #x0 + ) + :layer6 (new 'static 'array uint32 1072 + #x452301f8 + #xcdab8967 + #xf0035ef + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x5620ff22 + #x1004ff00 + #xf330544 + #x5620ff22 + #x1004ff00 + #xf330544 + #x5620ff22 + #x1004ff00 + #xff330544 + #xff220e32 + #xff005620 + #x6441004 + #xff220e33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #xff441004 + #xff330643 + #xfc220b32 + #x30333323 + #x4ff0054 + #x33064411 + #x220b32ff + #x30ff3302 + #x4ff0054 + #x43ff4411 + #x220a3306 + #x30ff3303 + #x44120011 + #x2e40ff + #x441104ff + #x330643ff + #x33042209 + #x1130ff + #x40ff4412 + #x4ff002e + #x33064412 + #x33052208 + #x1130ff + #x40ff4412 + #x4ff002e + #x33064413 + #x33062206 + #x30fd + #x4412770f + #x2e40ff + #x441604ff + #x22043304 + #x30fd3307 + #x770f0000 + #x40ff4412 + #x4ff002e + #x43ff4416 + #x30fd3310 + #x770f0000 + #x40ff4412 + #x4ff002e + #x43ff4416 + #x4406330c + #x4412770f + #x2e40ff + #x441604ff + #x4406330d + #x4412770f + #x2e40ff + #x441604ff + #x34fe330b + #xf440633 + #xff441277 + #xff002e40 + #xb441604 + #xf440833 + #xff441277 + #x4002b40 + #xa441577 + #x834ff33 + #x12770f44 + #x2b40ff44 + #x15770400 + #x943ff44 + #x834ff33 + #x12770f44 + #x2b40ff44 + #x16770400 + #xfd330744 + #x8344344 + #x12770f44 + #x2b40ff44 + #x16770400 + #x443ff44 + #xc34ff33 + #x12770f44 + #x2b40ff44 + #xff770400 + #x1441774 + #xa34ff33 + #x12771344 + #x2b40ff44 + #xfc770500 + #x77474474 + #x77024407 + #x43fd4408 + #x44093433 + #x771247ff + #x441274ff + #x2b40ff + #x4403770b + #x770347ff + #x440874ff + #x440a34ff + #x44137713 + #x2b40ff + #x74ff770c + #x44137707 + #x74ff7713 + #x40ff4413 + #x7715002b + #x441174ff + #x771347ff + #x40ff4414 + #x7716002b + #x77134411 + #x441474ff + #x2b40ff + #x74ff7716 + #x47ff440f + #x44157713 + #x2b40ff + #x440f7717 + #x770247ff + #x550275ff + #x74ff770b + #x74ff4403 + #x40ff4410 + #x7712002b + #x555575fb + #x440f7757 + #x770247ff + #x770b5503 + #x47fe4403 + #xff441077 + #x8002b40 + #x537ff33 + #x475ff77 + #x7757fd55 + #xfd440e74 + #x5777747 + #x450ff55 + #x704ff00 + #x10770144 + #x2b40ff44 + #x1330a00 + #xfd550877 + #xe747757 + #xff770144 + #xff550575 + #xff000450 + #xfc440604 + #x74777747 + #x40ff440f + #x330c002b + #x57fd5508 + #x440d7477 + #x777747fd + #x50ff5506 + #x4ff0004 + #x77024406 + #x440f74ff + #x2b40ff + #x5508330c + #x747757fd + #x47ff440c + #x55067702 + #x450ff + #x440504ff + #x770247ff + #x440f74ff + #x2b40ff + #x5508330c + #x747757fd + #x7702440c + #x50ff5507 + #x4ff0004 + #x77034405 + #x440f74ff + #x2b40ff + #x5509330c + #xb7477fe + #x247ff44 + #xff550777 + #xff000450 + #xff440404 + #x10770347 + #x2b40ff44 + #x9330c00 + #x7477fe55 + #x7702440b + #x550775ff + #x450ff + #x440404ff + #x770247ff + #x441074ff + #x2b40ff + #x35ff330a + #x7701550a + #x440947ff + #x770247ff + #x550775ff + #x450ff + #x440404ff + #x770247ff + #x40ff4411 + #x3309002b + #x550b35ff + #x44087703 + #x55087703 + #x450ff + #x440404ff + #x44117703 + #x2b40ff + #x550c3309 + #x74ff7703 + #x47ff4406 + #x75ff7702 + #x50ff5508 + #x4ff0004 + #x77034404 + #x40ff4411 + #x3309002b + #x7704550c + #x47ff4405 + #x55097703 + #x450ff + #x440304ff + #x770347ff + #x40ff4411 + #x3309002b + #x57ff550c + #x74ff7703 + #x77044403 + #x550975ff + #x450ff + #x440304ff + #x44117704 + #x2b40ff + #x550c3309 + #x770457ff + #x47ff4402 + #x550a7704 + #x450ff + #x440304ff + #x44117704 + #x2b40ff + #x550c3309 + #x770457ff + #x444474fd + #x550a7705 + #x450ff + #x440304ff + #x74ff7704 + #x40ff4410 + #x3309002b + #x57ff550c + #x75ff770c + #x50ff550a + #x4ff0004 + #x77044403 + #x441074ff + #x2b40ff + #x550c3309 + #x770b57ff + #x550b75ff + #x450ff + #x440204ff + #x770447ff + #x441074ff + #x2b40ff + #x550c3309 + #x770b57ff + #x50ff550c + #x4ff0004 + #x47ff4402 + #x44087705 + #x777747fd + #x40ff4404 + #x3309002b + #x770a550d + #x50ff550d + #x4ff0004 + #x47ff4402 + #x74ff7705 + #x47ff4406 + #x44037703 + #x2b40ff + #x550d3309 + #x550e7709 + #x450ff + #x440204ff + #x44057707 + #x770447ff + #x440274ff + #x2b40ff + #x550d3309 + #x770757ff + #x50ff550f + #x4ff0004 + #x77074402 + #x440374ff + #x74fc7707 + #x2b404444 + #xe330900 + #xff770655 + #xff550f75 + #xfc000450 + #x47444404 + #x74fd7708 + #x770b4744 + #x2b70ff + #x55113309 + #x777757fc + #xff551075 + #xfc000450 + #x47444404 + #x73fd770f + #x77043333 + #x2b70ff + #x55263309 + #x450ff + #x444404fd + #x33027710 + #x770337ff + #x2b70ff + #x55263309 + #x450ff + #x474404fd + #x3304770f + #x70ff7703 + #x3309002b + #x50ff5526 + #x7ff0004 + #x73ff7710 + #x77033304 + #x2b70ff + #x34ff3308 + #x55234402 + #x450ff + #x771007ff + #x77033305 + #x2b70ff + #x34fd3301 + #x44073443 + #x552245ff + #x450ff + #x770f07ff + #x330573ff + #x70ff7703 + #x44120026 + #x59ff5518 + #x50ff5508 + #x3fe0004 + #x6770e33 + #xff770333 + #x12002670 + #xff551044 + #xff550659 + #xff550899 + #xfd000450 + #xc333303 + #x673ff77 + #xff770333 + #x12002670 + #xff551044 + #x1990359 + #x9959fd55 + #xff550799 + #xfc000450 + #x37333303 + #x73ff770b + #x77033306 + #x2670ff + #x55104412 + #x95ff990a + #x50ff5505 + #x3ff0004 + #x770b3302 + #x77033307 + #x2670ff + #x550f4412 + #x990b59ff + #xa90ff + #x330203ff + #x3307770b + #x70ff7703 + #x44130026 + #x55080005 + #x90ff990c + #x3ff000a + #x770b3302 + #x37ff3306 + #x70ff7703 + #x44170026 + #x9ff0001 + #x59ff9904 + #x90ff990e + #x3fc000a + #xb373333 + #xff330677 + #xff770337 + #x17002670 + #xff000144 + #xff991409 + #xfd000a90 + #xc333303 + #x4330677 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #x3303fd00 + #x5770c33 + #x437ff33 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #x3303fe00 + #x13ff770d + #x77053304 + #x2670ff + #x14417 + #x991409ff + #xa90ff + #xd3703fe + #x311ff77 + #x537ff33 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #xe07ff00 + #x311ff77 + #xff770633 + #x17002670 + #xff000144 + #xff991409 + #xff000a90 + #xfc770e07 + #x33737711 + #x70ff7707 + #x44170026 + #x9ff0001 + #x90ff9914 + #x6ff000a + #x67ff6602 + #x11ff770a + #x70ff770a + #x44170026 + #x9ff0001 + #x90ff9914 + #x6ff000a + #x67ff6603 + #x11ff7709 + #x70ff770a + #x441a0026 + #x90ff9914 + #x6ff000a + #x77096604 + #x770a11ff + #x2670ff + #x9914441a + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x49ff441a + #x90ff9913 + #x6ff000a + #x67ff6604 + #x11ff7708 + #x70ff770a + #x441b0026 + #x90ff9913 + #x6ff000a + #x67ff6604 + #x11ff7708 + #x70ff770a + #x441b0026 + #x991249ff + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x91711fe + #x2670ff77 + #x12441c00 + #xa90ff99 + #x406ff00 + #x867ff66 + #x1711fe77 + #x70ff7709 + #x441c0026 + #x90ff9912 + #x6ff000a + #x67ff6604 + #x11fd7708 + #x77084744 + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x444411fc + #xff770747 + #x1c002670 + #xff991244 + #xff000a90 + #xff660406 + #x3770867 + #x647ff44 + #x2670ff77 + #x12441c00 + #xa90ff99 + #x306ff00 + #x822ff66 + #x474ff77 + #xff770644 + #x1c002670 + #xff991244 + #xff000a90 + #xff660306 + #xff770822 + #x5440574 + #x2670ff77 + #x1e441c00 + #x206ff00 + #x2277fe66 + #x44067708 + #x70ff7705 + #x441c0026 + #x7ff001e + #x22ff7703 + #x44067708 + #x70ff7705 + #x441c0026 + #x7ff001e + #x22ff7703 + #x44067708 + #x770447ff + #x2670ff + #x1e441c + #x770307ff + #x72722fe + #x674ff77 + #xff770444 + #x1c002670 + #xff001e44 + #xfe770307 + #x77072772 + #x440674ff + #x770347ff + #x2670ff + #x1e441c + #x770307ff + #x82772fe + #x3440777 + #x2670ff77 + #x1e441c00 + #x307ff00 + #x2272fe77 + #x74ff7708 + #x77034406 + #x2670ff + #x1e441c + #x770307ff + #x92272fe + #x3440677 + #x2670ff77 + #x1440700 + #x915ff11 + #x951ff55 + #xff001b11 + #xff770407 + #xff770922 + #x3440574 + #x2670ff77 + #x1440700 + #x915ff11 + #x951ff55 + #xff001b11 + #xfe770407 + #x77092722 + #x47ff4404 + #x70ff7703 + #x44060026 + #x15ff1102 + #x51ff5509 + #x1b1109 + #x770407ff + #x92772fe + #x374ff77 + #x347ff44 + #x2670ff77 + #xff440500 + #xff110241 + #xff550915 + #x1b110951 + #x407ff00 + #x2272fe77 + #x74ff770a + #x77044402 + #x2670ff + #x41ff4404 + #x15ff1103 + #x51ff5509 + #x1b1109 + #x770407ff + #x272272fd + #x4402770a + #x70ff7704 + #x11090026 + #x550915ff + #x110951ff + #x7ff001b + #x22fe7705 + #xfe770a27 + #x77059479 + #x2670ff + #x15ff1109 + #x51ff5509 + #x1b1109 + #x770507ff + #x770a2201 + #x59779fe + #x2670ff77 + #xff110900 + #xff550915 + #x1e110951 + #x247ff44 + #x2272fe77 + #x99fe770a + #xff770597 + #x9002670 + #x915ff11 + #x20110a55 + #xfe770244 + #x77092722 + #x59799fe + #x2670ff77 + #x9110900 + #xa51ff55 + #xfb442011 + #x72777747 + #xff770927 + #xff770699 + #x8002670 + #x5155fb11 + #x2515555 + #xb550211 + #x1442111 + #x2272fe77 + #x99ff7709 + #x70ff7706 + #x11070026 + #x65115fe + #x5515fd11 + #x22110b51 + #x7747fd44 + #xfe770822 + #x77069979 + #x2670ff + #x55ff1107 + #x55ff1108 + #x4423110c + #x272277f9 + #x57557577 + #x79fe7703 + #xff770699 + #x6002670 + #x5155fe11 + #x44231116 + #x257247fd + #x57ff5503 + #x79fe7702 + #xff770699 + #x5002670 + #x5515fe11 + #x44231117 + #x550645ff + #x99fe7702 + #xff770697 + #x5002670 + #x1855ff11 + #xff442311 + #x1550745 + #x9799fe77 + #x70ff7706 + #x55030026 + #x511551fd + #x44231118 + #x550945ff + #x69759fe + #x2670ff77 + #x19550500 + #xff442311 + #x6550b45 + #x2670ff77 + #xff550400 + #x5111951 + #x242ff44 + #xc441922 + #x557ff55 + #x2670ff77 + #x19550500 + #x5440411 + #x1724ff22 + #x5550d44 + #x2670ff77 + #xff550500 + #x3111851 + #xff220744 + #xd441624 + #xff770555 + #x5002670 + #x1851ff55 + #x9440211 + #xff441622 + #xff550c45 + #xff770457 + #x6002670 + #x1111855 + #xff220a44 + #xff441524 + #x4550d45 + #x2670ff77 + #x18550600 + #xc14ff11 + #xff441522 + #xff550d45 + #xff770357 + #x6002670 + #xff111855 + #x15220c12 + #xd45ff44 + #x357ff55 + #x2670ff77 + #x17550600 + #x612ff11 + #x4244fe22 + #x24ff2204 + #x45ff4414 + #x7703550e + #x2670ff + #x51ff5505 + #x22051118 + #x42ff4401 + #x24ff2204 + #x550d4415 + #x770357ff + #x2670ff + #x51ff5504 + #x12ff1119 + #x44032203 + #x24ff2204 + #x550d4415 + #x770357ff + #x2670ff + #x12ff111f + #x44042202 + #x24ff2204 + #x550b4415 + #x70ff7706 + #x11200026 + #x44052201 + #x24ff2204 + #x550b4415 + #x70ff7706 + #x11220026 + #x22034406 + #x441524ff + #x550a45ff + #x70ff7706 + #x11220026 + #x440614ff + #x44152203 + #x550a45ff + #x70ff7706 + #x44050026 + #x14ff111c + #x22fd4407 + #x44152224 + #x550a45ff + #x70ff7706 + #x44050026 + #x14ff111c + #x22fe4409 + #xa441524 + #xff770655 + #x5002670 + #xff111c44 + #xfe440914 + #x44152442 + #x77085508 + #x2670ff + #x111d4405 + #x42fe4409 + #xff441522 + #xff550645 + #xff770857 + #x5002670 + #xa111d44 + #x1622ff44 + #x545ff44 + #xff770955 + #x5002670 + #xa111d44 + #x1a22ff44 + #x5545fd44 + #xff770955 + #x23002670 + #xff440a11 + #x9441d22 + #x2670ff77 + #xa112300 + #x2022ff44 + #xff770644 + #x23002670 + #xfd440911 + #x1f222242 + #xff770644 + #x23002670 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #x9112300 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x2d40ff44 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #x4002d40 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xff111c31 + #xfe440914 + #x44202242 + #x2d40ff + #x31ff3304 + #x14ff111c + #x42fe4409 + #xff442024 + #x4002d40 + #x1c31ff33 + #x714ff11 + #x2422fc44 + #x440a2442 + #x333343fc + #xff441134 + #x4002d40 + #x1c31ff33 + #xfc440811 + #x24222422 + #x33044409 + #x441034ff + #x2d40ff + #x111c3305 + #x42ff4407 + #x24ff2202 + #x330c4405 + #x440c34ff + #x2d40ff + #x111b3305 + #x440714ff + #x24ff2203 + #x43ff4403 + #x34ff330d + #x40ff440c + #x3305002d + #x111a31ff + #x22044407 + #x43ff4404 + #x440c330e + #x2d40ff + #x31ff3305 + #x21fe1118 + #xff440611 + #x3220542 + #xe43ff44 + #xb34ff33 + #x2d40ff44 + #x18330600 + #x6220111 + #x542ff44 + #x224ff22 + #xff330e44 + #xff440c34 + #x7002d40 + #xff111633 + #xff220212 + #xff440424 + #xff220542 + #xe440224 + #xc34ff33 + #x2d40ff44 + #x15330800 + #xff220411 + #x6440324 + #x4e20ff22 + #xff330800 + #xff111331 + #x1220612 + #x642ff44 + #x4e20ff22 + #xff330800 + #xff111331 + #xfe220712 + #x22064244 + #x4e20ff + #x31ff3308 + #x22101114 + #x4e20ff + #x31ff3308 + #x44ff1114 + #x20ff220f + #x3309004e + #x14fd1113 + #x220e4444 + #x4e20ff + #x11123309 + #x42ff4404 + #x20ff220c + #x3309004e + #x14ff1110 + #x42ff4406 + #x20ff220b + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x30 + #x0 + ) + :layer7 (new 'static 'array uint32 684 + #x452301f8 + #xcdab8967 + #x210030ef + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #xf002822 + #x21000d44 + #x8000166 + #xc000122 + #xf002522 + #x21000d44 + #x7000166 + #x20fd22 + #x25220c00 + #xd440f00 + #x1662100 + #x2220700 + #x25220c00 + #xd440f00 + #x1662100 + #xff220600 + #xc000220 + #xf002522 + #x21550d44 + #x6000166 + #xc000322 + #xf002522 + #x21550d44 + #x5000266 + #xc000322 + #xf002522 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xe002544 + #x1145ff44 + #x5662055 + #x7000522 + #xe002844 + #x20551244 + #x5220566 + #x28440700 + #xff440d00 + #x20551245 + #x5220566 + #x28440700 + #x13440d00 + #x5662055 + #x7000522 + #xc002844 + #x1345ff44 + #x7660c55 + #x5660b00 + #x7000522 + #xc002844 + #xc551444 + #xb000766 + #x5220566 + #x28440700 + #xff440a00 + #xc551500 + #x7001f66 + #xa002844 + #x1500ff44 + #x1f660c55 + #x28440700 + #xff440a00 + #xc551500 + #xe001f66 + #xa002144 + #x1500ff44 + #x1f660c55 + #x21440e00 + #xff440a00 + #xc551500 + #xe001f66 + #xa002144 + #x1500ff44 + #x1f660c55 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #xa551500 + #xe332100 + #xa002144 + #x1400ff44 + #x21000b55 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #x9551500 + #x2100ff22 + #x7220633 + #xa002144 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002144 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #xf00ff77 + #xfd660355 + #x7005565 + #x21000122 + #xff220633 + #x21660626 + #x10770a00 + #x7660600 + #x21000122 + #xff220633 + #x21660626 + #x2771800 + #x7660600 + #x21000122 + #xfd220633 + #x4000020 + #x18002166 + #x6000277 + #x1220766 + #x6332100 + #x20fd22 + #x21660400 + #x2771800 + #x7660600 + #x21000122 + #xfd220633 + #x4000020 + #x18002166 + #x6000277 + #x1220766 + #x6332100 + #x20fd22 + #x21660400 + #x2771800 + #x7660600 + #x21000122 + #x4000933 + #x18002166 + #xd000277 + #x21000266 + #x4000933 + #x18002166 + #xff000277 + #x2660c06 + #x9332100 + #x21660400 + #x2771800 + #xc06ff00 + #x21000266 + #x4000933 + #x18002166 + #xff000277 + #xff660e06 + #x9332160 + #x21660400 + #x3771800 + #xff660e00 + #x3331560 + #x9330766 + #x21660400 + #xfe771b00 + #x660d0600 + #x331460ff + #x660336ff + #x66040011 + #x771b0021 + #xd0070fe + #x1460ff66 + #x11660433 + #x21660400 + #xfe771c00 + #x660c0600 + #x331360ff + #x661b36ff + #x771c0021 + #xc0070fe + #x1360ff66 + #x1b36ff33 + #x1d002166 + #x600fe77 + #x60ff660b + #x36ff3313 + #x21661b + #x70fe771d + #xff660b00 + #xff331360 + #x21661b36 + #xfe771e00 + #x660a0600 + #x331360ff + #x661b36ff + #x771e0021 + #xa0070fe + #x1360ff66 + #x1b36ff33 + #x1f002166 + #xff000177 + #xff660806 + #xff331360 + #x21661b36 + #xfd771f00 + #x8060070 + #x1360ff66 + #x1b36ff33 + #xe002266 + #xf00ff44 + #x600fe77 + #x60ff6608 + #x36ff3313 + #x22661b + #xfe440e + #xff770f07 + #x13660976 + #x1b36ff33 + #xe002266 + #xff000144 + #xff770e07 + #x13660976 + #x1b36ff33 + #xe002266 + #xff000144 + #xff770e07 + #x13660976 + #x1b36ff33 + #x10002266 + #xe47ff44 + #x976ff77 + #x3330f66 + #x1b06ff00 + #x10002266 + #xe47ff44 + #x976ff77 + #x3330f66 + #xc06ff00 + #xffaa0266 + #x22660aa6 + #xff441000 + #xff770e47 + #xf660976 + #x22aa2033 + #xff441000 + #xff770e47 + #xf660976 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xe660946 + #x203aff33 + #x200022aa + #x646ff44 + #xe000266 + #x22aa2133 + #xff442000 + #x2660646 + #x21330e00 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #xffaa3100 + #xff7728a7 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #xb002270 + #x14000aaa + #xff0005aa + #xff772807 + #xb002270 + #x14000aaa + #xff0005aa + #xff772807 + #x19002270 + #x5aa1155 + #x2807ff00 + #x2270ff77 + #xff551900 + #x5aa105a + #x2807ff00 + #x2270ff77 + #xf551a00 + #xff2206aa + #xff772827 + #x1a002270 + #xd5aff55 + #x6a2ffaa + #x2827ff22 + #x2270ff77 + #xff551a00 + #xff221552 + #xff772827 + #x1b002270 + #xff221555 + #xff772827 + #x1b002270 + #x1452ff55 + #x2827ff22 + #x2270ff77 + #x14551c00 + #x2827ff22 + #x2270ff77 + #xff551c00 + #xff221352 + #xff772827 + #x1d002270 + #xff221355 + #xff772827 + #x1c002270 + #x1352ff55 + #x2827ff22 + #x2270ff77 + #x14551c00 + #x2827ff22 + #x2270ff77 + #xff551b00 + #xff221452 + #xff772827 + #x1b002270 + #x4221655 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #xff661600 + #xff550265 + #x4221652 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x2661700 + #x4221755 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #xfd661700 + #x17525565 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x1855ff66 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x1862ff66 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x4221966 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x4661300 + #x4221977 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x4661300 + #x4221977 + #x4670ff77 + #x4661300 + #x4221977 + #x70fe77 + #x50ff5523 + #x66130020 + #x22197704 + #x70fe7704 + #xff552300 + #x13002050 + #x19770466 + #xfe770422 + #x55230070 + #x2050ff + #x77046613 + #x77042219 + #x230070fe + #x2050ff55 + #x4661300 + #x4221977 + #x70fe77 + #x50ff5523 + #x77180020 + #x77042219 + #x230070fe + #x2050ff55 + #x19771800 + #xfe770422 + #x55230070 + #x2050ff + #x22197718 + #x70fe7704 + #xff552300 + #x18002050 + #x4221977 + #x70fe77 + #x50ff5523 + #x77180020 + #x62219 + #x50ff5523 + #x77180020 + #x440c2213 + #x50ff5523 + #x77180020 + #x440c2213 + #x50ff5523 + #x77120020 + #x22134405 + #x5523440c + #x2050ff + #x44057712 + #x440c2213 + #x50ff5523 + #x770d0020 + #x2213440a + #x5523440c + #x2050ff + #x440a770d + #x440c2213 + #x50ff5523 + #x770d0020 + #x2213440a + #x5523440c + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x4007f + #x0 + #x0 + #x0 + ) + :layer8 (new 'static 'array uint32 960 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x25007f00 + #xa02ff00 + #x520ff22 + #x410ff11 + #x607ff00 + #x774ff77 + #xff005544 + #xff220a02 + #xff110521 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff330413 + #xff770637 + #x55440774 + #xa02ff00 + #x521ff22 + #x413ff11 + #x637ff33 + #x774ff77 + #xff005544 + #xff220a02 + #xff110520 + #xff330413 + #xff770637 + #x55440774 + #xa02ff00 + #x520ff22 + #x413ff11 + #x637ff33 + #x774ff77 + #xff005544 + #xff220a02 + #x5110520 + #x637ff33 + #x774ff77 + #xff005544 + #x6220802 + #x1141fe44 + #x37ff3305 + #x74ff7706 + #x554407 + #x220702ff + #x440620ff + #x61141fe + #xff770633 + #x55440774 + #x602ff00 + #x20fe22 + #x40fe4406 + #xff330613 + #xff770537 + #x55440774 + #x602ff00 + #x6000122 + #x743ff44 + #x537ff33 + #x474ff77 + #x4434fd44 + #xff005544 + #xff220502 + #xff770300 + #x16440474 + #xff005633 + #xfe220402 + #x77030020 + #x440474ff + #x331543ff + #x2ff0056 + #x20fd2203 + #x77040000 + #x33154405 + #x2ff0056 + #x12203 + #x770407ff + #x440474ff + #x331443ff + #x2ff0056 + #x12203 + #x770507ff + #x43ff4404 + #x563314 + #x220302ff + #x77060001 + #x440474ff + #x563314 + #x220302ff + #x60700fe + #x474ff77 + #x56331444 + #x302ff00 + #x720fe22 + #x74ff7706 + #x33144404 + #x2ff0056 + #x66ff2204 + #x74ff7706 + #x33144404 + #x2ff0056 + #x26fe2203 + #xff770666 + #x14440474 + #xff005633 + #x1220302 + #x567ff66 + #x474ff77 + #x1343ff44 + #xff005633 + #x2220302 + #xff770566 + #x13440574 + #xff005633 + #x2220302 + #xff770566 + #x13440574 + #xff005633 + #x2220302 + #x467ff66 + #x13440677 + #xff005633 + #x3220302 + #xff770366 + #x3440674 + #x56330f00 + #x202ff00 + #x326ff22 + #x7770366 + #xf000344 + #xff005633 + #xff220202 + #x3660326 + #x3440777 + #x56330f00 + #x202ff00 + #x326ff22 + #x7000366 + #xff000444 + #x56330d03 + #x202ff00 + #x326ff22 + #x7000366 + #xff110344 + #xb000210 + #xff005633 + #xff550205 + #x3660356 + #xff440300 + #xfe110941 + #x330a0010 + #x5ff0056 + #x56ff5502 + #x36603 + #x41ff4403 + #xff110a + #x56330a + #x550205ff + #x660356ff + #x44030003 + #x110a41ff + #x90310fe + #xff005633 + #xff550205 + #x3660356 + #xff440300 + #xfe110a41 + #x33090310 + #x5ff0056 + #x56ff5502 + #x36603 + #x71ff7703 + #x10fe110a + #x56330903 + #x205ff00 + #x356ff55 + #x3000366 + #xa71ff77 + #x310fe11 + #x563309 + #x550205ff + #x660356ff + #x77030003 + #x110a71ff + #x90310fe + #xff005633 + #xff550205 + #x3660356 + #xff770300 + #xff110a71 + #x56330a00 + #x205ff00 + #x356ff55 + #x4000266 + #x971ff77 + #x10fe11 + #x56330a + #x550205ff + #x660656ff + #xff7707 + #x21104 + #x56330b + #x550205ff + #x660656ff + #xff7707 + #x3ff1104 + #x56330d + #x550205ff + #x660756ff + #x57706 + #x330d03ff + #x5ff0056 + #x56ff5502 + #x67ff6607 + #x57705 + #x330d03ff + #x5ff0056 + #x56ff5502 + #x77056608 + #x110400ff + #x330d13ff + #x5ff0056 + #x56ff5502 + #x67ff6608 + #xff7704 + #x13ff1104 + #x56330d + #x550205ff + #x660856ff + #x770367ff + #x110570ff + #x330d13ff + #x5ff0056 + #x56ff5502 + #x67ff6608 + #x71ff7703 + #x330d1106 + #x5ff0056 + #x66065504 + #x30060fe + #x601ff77 + #xc13ff11 + #xff005633 + #xfe550405 + #x66040600 + #x77030001 + #x13ff1107 + #x56330c + #x550505ff + #x30600fe + #x3000166 + #xff110777 + #x56330c13 + #x505ff00 + #x600fe55 + #x16603 + #x11077703 + #x330c13ff + #x5ff0056 + #x6ff5506 + #x16603 + #x11077703 + #x330c13ff + #x5ff0056 + #x65506 + #x11077703 + #x330c13ff + #x5ff0056 + #x55507 + #x11077703 + #x330c13ff + #x5ff0056 + #x45507 + #x11077704 + #x330c13ff + #x5ff0056 + #x35508 + #x11077704 + #x330c13ff + #x5ff0056 + #x1550a + #x1ff7704 + #x13ff1106 + #x56330c + #x550b05ff + #x770400ff + #x110600ff + #x330c13ff + #x5ff0056 + #xff550b + #xff7704 + #x13ff1106 + #x56330c + #x550b05ff + #x770450ff + #x11050001 + #x330c13ff + #x5ff0056 + #x7704550c + #x1ff0001 + #x13ff1104 + #x56330c + #x550c05ff + #x75fc7703 + #x4505555 + #xc13ff11 + #xff005633 + #x3550c05 + #x5575fc77 + #x565055 + #x75ff7712 + #x7703550c + #x555575fc + #x12005650 + #xc75ff77 + #xfc770355 + #x50555575 + #x77120056 + #x550c75ff + #x75fc7703 + #x56505555 + #xff771200 + #x3550c75 + #x5575fc77 + #x565055 + #x75ff7712 + #x7703550c + #x555575fc + #x12005650 + #xc75ff77 + #xfc770355 + #x50555575 + #x77120056 + #x550c75ff + #x75fc7703 + #x56505555 + #xff771200 + #x3550c75 + #x5575fc77 + #x565055 + #x75ff7712 + #x4408550c + #x77120055 + #x550c75ff + #x554408 + #x75ff7712 + #x4408550c + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x60ff660b + #x33050048 + #x44080004 + #x34ff3304 + #x660b440f + #x4860ff + #x43305 + #x44408 + #x440f04ff + #x60ff660b + #x33050048 + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff660b + #x433303 + #x43305 + #x44408 + #x440f04ff + #x660b46ff + #x330363ff + #x33050043 + #x44080004 + #x4ff0004 + #x660b4410 + #x330363ff + #x3ff003f + #x43308 + #x44408 + #x441004ff + #x63ff660a + #x3f3304 + #x330803ff + #x44080004 + #x4ff0004 + #x660a4410 + #x3f3305 + #x330803ff + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x54ff5504 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x54ff5504 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x5506000b + #x440f54ff + #x660946ff + #x330563ff + #x40ff4407 + #x3ff0036 + #xb3308 + #x54ff5506 + #x46ff440f + #x63ff6609 + #x44073305 + #x3640ff + #x330803ff + #x5506000b + #x440f54ff + #x660946ff + #x330563ff + #x40ff4407 + #x3ff0036 + #xb3308 + #x50ff5506 + #x220b0003 + #x660a26ff + #x44073305 + #x3640ff + #x330803ff + #x5506000b + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330803ff + #x5506000b + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x60ff6605 + #x33050003 + #x40ff4407 + #x3ff0036 + #xc3307 + #x50ff5506 + #x220b0003 + #x660526ff + #x360ff + #x44073305 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x60ff6605 + #x440d0003 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x22097701 + #x660526ff + #x360ff + #x40ff440d + #x3ff0036 + #xc3307 + #x50ff5506 + #x77050003 + #x220572ff + #x660426ff + #x360ff + #x40ff440d + #x3ff0036 + #xc3307 + #x50ff5506 + #x77060003 + #x26ff2205 + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x72ff7706 + #x26ff2204 + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55062209 + #x350ff + #x72ff7706 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x50ff5506 + #x77060003 + #x220572ff + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55062209 + #x350ff + #x72ff7706 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x50ff5506 + #x77060003 + #x220572ff + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x17ff1105 + #x72ff7705 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x11055505 + #x770617ff + #x26ff2205 + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x17ff1105 + #x22067706 + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77051107 + #x220572ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77051108 + #x66032205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x11085505 + #x770417ff + #x220472ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77041109 + #x220472ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x7703110a + #x220472ff + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x110b5505 + #x72ff7702 + #x26ff2203 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11045505 + #x313313fd + #x12ff1106 + #x26ff2203 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11045505 + #x11063302 + #x220312ff + #x660326ff + #x4960ff + #x330703ff + #x2ff0001 + #x55052209 + #x13ff1103 + #x11053303 + #x26ff2204 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11020005 + #x11043306 + #x26ff2204 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11010005 + #x330613ff + #x110231ff + #x220412ff + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x33071101 + #x110231ff + #x220412ff + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x1102330a + #x66042205 + #x4960ff + #x330703ff + #x2ff0001 + #x20ff2203 + #x330a000a + #x22051102 + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x1102330a + #x66042205 + #x4960ff + #x330703ff + #x2ff0001 + #x20ff2203 + #x330a000a + #x22051102 + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x31fc330a + #x4121111 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x4660233 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x6636fd33 + #x4220466 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #xfd330b00 + #x4666636 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x6636fc33 + #x22036266 + #x60ff6604 + #x330e0043 + #x2ff0001 + #x20ff2203 + #x330b000a + #x666636fc + #x4220362 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #xfd330b00 + #x3666636 + #x426ff22 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #x1330b00 + #x362ff66 + #x426ff22 + #x4360ff66 + #xff330800 + #xff000630 + #xff220302 + #x2000a20 + #x663ff33 + #x6636fd33 + #xff220462 + #xff660426 + #x8004360 + #x630ff33 + #x302ff00 + #xd20ff22 + #x2660100 + #x2660433 + #x2211fd22 + #xff660522 + #x8004360 + #x630ff33 + #x302ff00 + #xd20ff22 + #x2660100 + #xf9660333 + #x21222262 + #x5221211 + #x4360ff66 + #xff330800 + #xff000630 + #xff220302 + #x6000220 + #x1000377 + #x3330266 + #x1220366 + #x516ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x3770600 + #xfd660100 + #x3363363 + #xff220166 + #xff110221 + #xff660516 + #x8004360 + #x734ff33 + #xff220344 + #x6000220 + #xff000277 + #x1660806 + #x5110422 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x606ff00 + #x4220366 + #x416ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x426ff22 + #x362ff66 + #x512ff22 + #x316ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x426ff22 + #x262ff66 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xd770600 + #xff110822 + #x8004610 + #x734ff33 + #xff220344 + #x6000220 + #x8220d77 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x827ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #x8770600 + #x7227fa22 + #x71772222 + #x10ff1107 + #x77070060 + #x77fa2207 + #x77222272 + #xff110777 + #xb006010 + #x2272f577 + #x77772722 + #x77772722 + #xff110671 + #x16006010 + #xff110677 + #x16006010 + #xff110677 + #x16006010 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x7f007f77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x3d007f00 + #x0 + #x0 + ) + :layer9 (new 'static 'array uint32 888 + #x452301f8 + #xcdab8967 + #x1f0057ef + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x1a221f00 + #xff332200 + #xc661336 + #xff221e00 + #x22001a20 + #x1336ff33 + #x1e000c66 + #x1a20ff22 + #xff332200 + #xc661336 + #x1b221e00 + #xff332200 + #x4661336 + #x1e000755 + #x22001b22 + #x1336ff33 + #x6550566 + #x1b221e00 + #xff332200 + #x6661336 + #x1d000555 + #x1b20ff22 + #xff332200 + #x7661336 + #x1d000455 + #x22001c22 + #x1336ff33 + #xff550766 + #x1c000350 + #x1c20ff22 + #xff332200 + #x8661336 + #x250ff55 + #xff221b00 + #x22001d20 + #x1336ff33 + #x2550966 + #x1e221b00 + #xff332200 + #xa661336 + #x1a000155 + #xff001d22 + #xff220202 + #xff331f23 + #xa661336 + #x50fe55 + #x20ff2218 + #x2ff001e + #x23ff2202 + #x36ff331f + #x65ff6612 + #x50ff550b + #x20ff2217 + #x2ff001f + #x23ff2202 + #x36ff331f + #x65ff6612 + #x2217550c + #x2ff0020 + #x23ff2202 + #x36ff331f + #x65ff6612 + #x52ff550c + #x20ff2214 + #x2ff0021 + #x33202203 + #x65ff6612 + #x52ff550d + #x20ff2212 + #x2ff0022 + #x33202203 + #x65ff6612 + #x52ff550e + #x20ff2210 + #x2ff0023 + #x23ff2203 + #x6612331f + #x550f65ff + #x220e52ff + #x2ff0025 + #x331e2205 + #x65ff6612 + #x220b5510 + #x2720ff + #x220702ff + #x331b23ff + #x65ff6612 + #x22095510 + #x2920ff + #x220702ff + #x6612331c + #x551065ff + #x220752ff + #x2a20ff + #x220702ff + #x36ff331c + #x5ff6611 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x36ff331c + #x5ff6611 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x6610331d + #x100560fe + #x3350ff55 + #x602ff00 + #x1d23ff22 + #xf36ff33 + #x560fe66 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x36ff331d + #xfe660f + #xff551005 + #xff003350 + #x1e220702 + #xfe660f33 + #x55100500 + #x2ff0034 + #x331f2207 + #x660c36ff + #x50060fd + #x345510 + #x220702ff + #x36ff3321 + #x60fd660a + #x55100500 + #x2ff0034 + #x33212207 + #x660a36ff + #x50060fd + #x50ff550f + #x2ff0034 + #x23ff2207 + #x36ff3320 + #x1660a + #x550f05ff + #x3450ff + #x220802ff + #x333323fc + #x18550335 + #xa36ff33 + #xff000166 + #x35550f05 + #x802ff00 + #x3323fd22 + #xff550435 + #xa331703 + #x60fc66 + #x550f0500 + #x2ff0035 + #x25ff2208 + #xff5506 + #x660a3317 + #x60fc + #xff550e05 + #xff003550 + #xff220802 + #xfe550625 + #x33160300 + #x2660a + #x550e05ff + #x2ff0036 + #x55072208 + #x160300fe + #x2660a33 + #xd05ff00 + #x3650ff55 + #x702ff00 + #x725ff22 + #x50fe55 + #x66093316 + #x260ff + #x550d05ff + #x2ff0037 + #x25ff2207 + #xfe5508 + #x9331503 + #x260ff66 + #xd05ff00 + #xff003755 + #x9220702 + #x50fd55 + #x9331403 + #xff000366 + #xff550c05 + #xff003750 + #xff220602 + #x1550a25 + #x1303ff00 + #x3660933 + #xc05ff00 + #xff003855 + #xff220602 + #xfc550a25 + #x3000050 + #x66083312 + #x360ff + #x550c05ff + #x2ff0038 + #x25ff2206 + #x2550b + #x66083312 + #x360ff + #x550b05ff + #x3850ff + #x220602ff + #x2550c + #x331103ff + #x46608 + #x550a05ff + #x3950ff + #x220602ff + #x50ff550c + #x3ff0002 + #x36ff3310 + #x4b6607 + #x220602ff + #x3550d + #x330f03ff + #x660636ff + #x4b60ff + #x220502ff + #x550d25ff + #x350ff + #x330f03ff + #x60ff6606 + #x2ff004b + #x25ff2205 + #x4550e + #x330d03ff + #x660636ff + #x2ff004c + #x25ff2205 + #x50ff550e + #x330d0004 + #x660536ff + #x4c60ff + #x220502ff + #x550f25ff + #x330c0005 + #x60ff6606 + #x2ff004c + #x25ff2205 + #x50ff550f + #x330a0005 + #x660600ff + #x440f0007 + #x2ff0035 + #x25ff2205 + #x55510 + #x330803ff + #xf30ff + #x35440f + #x220502ff + #x551025ff + #x1f50ff + #x35440f + #x220502ff + #x551125ff + #x1e50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220602ff + #x50ff5513 + #xaff0013 + #xa0ffaa03 + #x440f0002 + #x2ff0035 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #x35440f + #x220602ff + #x50ff5513 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2ff0035 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #xc440f + #x20ff2206 + #x2ff0020 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #xc440f + #x20ff2206 + #x2ff0020 + #x25ff2206 + #x50ff5512 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206000c + #x2020ff + #x220702ff + #x50ff5512 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220702ff + #x551125ff + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11012208 + #x50ff550f + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220802ff + #x550f1101 + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11012208 + #x50ff550f + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220802ff + #x550f1101 + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11022208 + #x550d15ff + #x650ff + #xaa100aff + #x2a0ff + #x44097705 + #x220202ff + #x22061108 + #x2020ff + #x220602ff + #x110521ff + #x50ff550c + #xaff0006 + #xa0ffaa10 + #x77050002 + #x440874ff + #x220202ff + #x22061108 + #x2220ff + #x110c01ff + #x550a15ff + #x650ff + #xaa100aff + #x7709a7ff + #x2ff4408 + #x11082202 + #x20ff2206 + #x1ff0022 + #x550a110d + #x650ff + #xaa100aff + #x7709a7ff + #x2ff4408 + #x11082202 + #x20ff2206 + #x1ff0022 + #x15ff110d + #x50ff5509 + #xaff0006 + #xa7ffaa10 + #x44087709 + #x220202ff + #x22061108 + #x2220ff + #x110e01ff + #x50ff5509 + #xaff0006 + #xddffaa10 + #x44087709 + #x220202ff + #x22061108 + #x2220ff + #x110e01ff + #x550815ff + #x650ff + #xaa0f0aff + #x9ddadfe + #xff440877 + #xff221202 + #xff002220 + #x8110f01 + #x650ff55 + #xf0aff00 + #x9dd01aa + #xff440877 + #xff221202 + #xff002220 + #xff110f01 + #xff550715 + #xff000650 + #xfdaa0e0a + #x9d7ddad + #xff440877 + #xff221202 + #xff002220 + #xff110f01 + #xff550715 + #xff000650 + #xfeaa0e0a + #x770addad + #x2ff0008 + #x20ff2212 + #x1ff0022 + #x55071110 + #x650ff + #xaa0e0aff + #xad7adfe + #xff000877 + #xff221202 + #xff002220 + #xff111001 + #xff550615 + #xff000650 + #xffaa0e0a + #x8770bdd + #x1202ff00 + #x2220ff22 + #x1501ff00 + #x5515fc11 + #x65055 + #xaa0d0aff + #xbd7adfe + #xff000877 + #xff221202 + #xff002220 + #xff111801 + #xff000650 + #xfeaa0d0a + #x7707d7dd + #x2ff000c + #x20ff2212 + #x1ff0022 + #x10ff1118 + #xaff0006 + #xadfdaa0c + #x7706dddd + #xc70ff + #x221202ff + #x2220ff + #x111a01ff + #xaa0c0006 + #xd7ffdd02 + #x55017705 + #x2ff0011 + #x20ff220c + #x1ff0022 + #x5111b + #xaa0a0aff + #xdd0322ff + #x75fc7704 + #x10505555 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #x9000611 + #x22a2fdaa + #xffdd022d + #xff7702d7 + #x10550375 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #x8000611 + #x6a2ffaa + #x5770222 + #xff000f55 + #xff220c02 + #xff002220 + #x6111b01 + #x70aff00 + #xfd2207aa + #x5757727 + #xff000f55 + #xff220c02 + #xff002220 + #x7111b01 + #x9aa0600 + #x675ff22 + #xe50ff55 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #xff000711 + #xffaa040a + #xff2209a2 + #xff551625 + #xff220c52 + #xff002220 + #xff111a01 + #x4000810 + #x17220aaa + #xc52ff55 + #x2220ff22 + #x1a01ff00 + #x3000911 + #x9a2ffaa + #xff551822 + #xff220c52 + #xff002220 + #xff111901 + #xff000910 + #x9aa020a + #x1825ff22 + #xc52ff55 + #x2220ff22 + #x1901ff00 + #xa10ff11 + #xffaa0100 + #xff2209a2 + #xff551825 + #xff220c52 + #xff002220 + #xff111901 + #xff000b10 + #xff220a02 + #xff551825 + #xff220c52 + #xff002220 + #xff111901 + #xb000b10 + #x1925ff22 + #xb52ff55 + #x2220ff22 + #x1901ff00 + #xa10ff11 + #xb02ff00 + #x1a25ff22 + #xa52ff55 + #x2220ff22 + #x1901ff00 + #xc000b11 + #x1c25ff22 + #xff220955 + #xff002220 + #xa111901 + #xc02ff00 + #x2025ff22 + #xff002955 + #x2111901 + #x406ff00 + #xd000166 + #x2025ff22 + #xff002955 + #x9110301 + #xa41ff44 + #xff000211 + #xfe660406 + #x220d0200 + #x552025ff + #x440a002e + #x10fc110a + #x4060000 + #xe00ff66 + #x2025ff22 + #xa002e55 + #x941ff44 + #x10fc11 + #x66040600 + #x220d02ff + #x552125ff + #x440b002e + #x1110a + #x660406ff + #x82205 + #x550f05ff + #xf4534fe + #xc002e55 + #xfc110844 + #x6004414 + #x22046604 + #x20620fe + #xff000466 + #xfd550e05 + #xf443433 + #xd002e55 + #xfb110644 + #x40444414 + #x2660606 + #xff660522 + #xff000260 + #xfc550d05 + #x45343353 + #x2e550f + #x1103440f + #x46ff4404 + #x26610 + #x550d05ff + #x343353fc + #x2e550f45 + #xff441800 + #x2661146 + #x1550d00 + #x4434fe33 + #x2e550f + #x46ff4418 + #x60fc6611 + #xc050000 + #xfe330155 + #x550f4434 + #x4419002e + #x16612 + #x550c05ff + #x34fd3301 + #x550e4544 + #x4419002e + #x661146ff + #x60fd + #x53fa550b + #x44343333 + #x2e550e45 + #x12441a00 + #xff000166 + #xfa550a05 + #x34333353 + #x550e4444 + #x441a002e + #x661146ff + #x550a0002 + #x333353fa + #xe444434 + #x1b002e55 + #x2661144 + #x905ff00 + #x3353fa55 + #x44443433 + #x2e550e + #x46ff441b + #x60fc6610 + #x9050000 + #x3353fa55 + #x44443433 + #x2e550e + #x46ff441c + #x26610 + #x33025509 + #x444434f8 + #x44545545 + #x2e550945 + #xff441d00 + #xfd660f46 + #x8000060 + #xff330355 + #x9440634 + #x1e002e55 + #xf46ff44 + #xff000166 + #xff550605 + #xff330353 + #x9440634 + #x1e002e55 + #xf46ff44 + #x6000266 + #x353ff55 + #x634ff33 + #x2e550944 + #xff441e00 + #xfd660f46 + #x6000060 + #xff330455 + #x9440634 + #x1e002e55 + #xf46ff44 + #x60fd66 + #xff550500 + #xff330453 + #xff440634 + #x2e550845 + #xff441e00 + #x1661046 + #x5550500 + #x634ff33 + #x845ff44 + #x1f002e55 + #xfd661044 + #x3050060 + #x553ff55 + #x534ff33 + #x8110144 + #x1f002e55 + #xfd661044 + #x3050060 + #xfc330655 + #x41444434 + #x15ff1103 + #x2e5508 + #x6611441f + #x5fc0001 + #x3535555 + #x6220233 + #x915ff11 + #x1f002e55 + #xfb661144 + #x55000060 + #xff330353 + #x6220232 + #x2e550a11 + #x11441f00 + #x260ff66 + #x3330400 + #xa110622 + #x1f002e55 + #xff661144 + #x3000260 + #x332ff33 + #xa110622 + #x1f002e55 + #x1046ff44 + #x260ff66 + #xff330200 + #xff220332 + #xa110621 + #x1f002e55 + #x1146ff44 + #x2000266 + #x332ff33 + #x521ff22 + #xa15ff11 + #x20002e55 + #x4661144 + #x302ff00 + #x621ff22 + #xa15ff11 + #x20002e55 + #x4661144 + #x302ff00 + #xff110722 + #x2e550a15 + #x11442000 + #xff000466 + #xff220202 + #xff110621 + #x2e550b15 + #xff442000 + #xff661146 + #xfc000260 + #x21222202 + #x550c1107 + #x4421002e + #x661046ff + #x260ff + #x222202fd + #x15ff1105 + #x2e550e + #x66114421 + #x10060fd + #x15ff1109 + #x2e550e + #x46ff4420 + #x60fd6611 + #x11090100 + #x550e15ff + #x4420002e + #x661146ff + #x10060fd + #x15ff1109 + #x2e550e + #x46ff441f + #x60fd6612 + #x11090100 + #x550e15ff + #x441e002e + #x60fd6614 + #x11090100 + #x550e15ff + #x66190048 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x7f60ff + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x2a007f + #x0 + #x0 + ) + :layer10 (new 'static 'array uint32 108 + #x452301f8 + #xcdab8967 + #x7f117fef + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x77117f11 + #x11 + #x0 + ) + :layer11 (new 'static 'array uint32 384 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d004100 + #x1d006166 + #x1d006166 + #x1d006166 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1000533 + #x1a6aff66 + #xc004e66 + #x1000533 + #xa6aafe66 + #x4e6619 + #x5330c + #xaa016601 + #x4e6619 + #x5330c + #xaa016601 + #x6618a6ff + #x330c004e + #x66010005 + #x6618aa02 + #x330c004e + #x5aff5506 + #xa6ffaa02 + #x4e6617 + #x5506330c + #xaa035aff + #x4e6617 + #x5506330c + #xaa035aff + #x4e6617 + #x5507330c + #xa6ffaa03 + #x4e6616 + #x5507330c + #xaa035aff + #x4e6616 + #x5508330c + #xa6ffaa03 + #x4e6615 + #x5508330c + #xaa035aff + #x4e6615 + #x5509330c + #xa6ffaa03 + #x4e6614 + #x5509330c + #xaa035aff + #x4e6614 + #x550a330c + #xa6ffaa03 + #x4e6613 + #x550a330c + #x16a65afe + #xc004e66 + #x17550b33 + #xc004e66 + #x17550b33 + #xb004e66 + #x4534fe33 + #x6617550a + #x330b004e + #x550a4401 + #x4e6617 + #x4402330a + #x6617550a + #x3309004e + #x440234ff + #x550945ff + #x4e6617 + #x34ff3309 + #x55094403 + #x4e6617 + #x4403330a + #x550845ff + #x4e6617 + #x34ff330a + #x55084403 + #x4e6617 + #x4403330b + #x66175508 + #x330b004e + #x84403 + #x4e6617 + #x34ff330b + #x84402 + #x11086616 + #x4510ff + #x4402330c + #x66150008 + #x110861ff + #x4510ff + #x4402330c + #x66150008 + #x10ff1109 + #x330c0045 + #x6614000b + #x110961ff + #x4510ff + #xb330c + #x61ff6613 + #x10ff110a + #x330c0045 + #x6613000b + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x6613005e + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x6613005e + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x1ff0072 + #x14ff110a + #x40ff4404 + #x1ff006c + #x14ff110a + #x40ff4404 + #x1ff006c + #x4405110a + #x6c40ff + #x110901ff + #x440514ff + #x6c40ff + #x110801ff + #x440614ff + #x6c40ff + #x110701ff + #x440714ff + #x6c40ff + #x110601ff + #x440814ff + #x6c40ff + #x110501ff + #x440914ff + #x6c40ff + #x110401ff + #x440a14ff + #x6c40ff + #x110301ff + #x440b14ff + #x6c40ff + #x110201ff + #x440c14ff + #x6c40ff + #x111101fc + #xff440d14 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xd006e40 + #x5545fd44 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xffaa2300 + #xff660da6 + #xff550765 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xffaa2300 + #xff660da6 + #xff550765 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xffaa2200 + #xff660ea6 + #xff550765 + #x22004250 + #xea6ffaa + #x765ff66 + #x4250ff55 + #xffaa2200 + #xff660ea6 + #xff550765 + #x22004250 + #xff660faa + #xff550765 + #x22004250 + #xfd660daa + #x7353363 + #x4250ff55 + #xdaa2200 + #x6330366 + #x4250ff55 + #xcaa2300 + #xff330566 + #xff550335 + #x23004250 + #xba6ffaa + #xff330666 + #xff550235 + #x24004250 + #x9a6ffaa + #xa63ff66 + #x25004333 + #xff6609aa + #x43330a63 + #x8aa2600 + #xa63ff66 + #x26004333 + #x7a6ffaa + #x43330b66 + #xffaa2700 + #xb6606a6 + #x28004333 + #xff6605aa + #x43330b63 + #xffaa2800 + #xff6604a3 + #x43330b63 + #xfeaa2800 + #x660333a3 + #x43330c + #x3301aa28 + #x660236ff + #x43330c + #xa3ffaa27 + #x36fd3302 + #x330c6666 + #xaa270043 + #x3303a3ff + #xc6366fe + #x27004333 + #xff3305aa + #x43330c63 + #xffaa2600 + #x433313a3 + #xffaa2600 + #x433313a3 + #x14aa2600 + #x25004333 + #x14a3ffaa + #x25004333 + #x14a3ffaa + #x25004333 + #x433315aa + #xffaa2400 + #x433315a3 + #x16aa2400 + #x23004333 + #x16a3ffaa + #x23004333 + #x433317aa + #xffaa2200 + #x433317a3 + #x18aa2200 + #x21004333 + #x433319aa + #xffaa2000 + #x433319a3 + #xffaa1f00 + #x62331aa3 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x7f331c00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x9007f00 + #x0 + #x0 + #x0 + ) + :layer12 (new 'static 'array uint32 712 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d007f00 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xa71ff77 + #x1e12ff11 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1702ff00 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1702ff00 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1302ff00 + #x221ff22 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x13020060 + #x221ff22 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x13020060 + #xff110322 + #x24002f10 + #xd76ff77 + #x60fd66 + #xff221202 + #xff110321 + #x24002f10 + #xd76ff77 + #x60fd66 + #x4221202 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x11020060 + #xff110522 + #x1d002f10 + #x573ff77 + #xfd660e33 + #x10020060 + #x521ff22 + #x2f10ff11 + #x6771d00 + #xfd660e33 + #x10020060 + #xff110622 + #x1c002f10 + #x673ff77 + #xfd660e33 + #xf020060 + #x621ff22 + #x2910ff11 + #xe441300 + #xe330777 + #x60fd66 + #x7220f02 + #x2910ff11 + #xff441300 + #xff770c47 + #xe330773 + #x60fd66 + #xff220e02 + #xff110721 + #x14002910 + #xff770b44 + #xe330873 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441400 + #x9770a47 + #xff660e33 + #xff000860 + #xff110f01 + #x15002910 + #xff770944 + #xe330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441500 + #xa770847 + #xff660e33 + #xff000860 + #xff110f01 + #x15002910 + #x747ff44 + #x973ff77 + #xff660f33 + #xff000860 + #xff110f01 + #x16002910 + #xff770644 + #xff330973 + #xff660f36 + #xff000860 + #xff110f01 + #x16002910 + #x547ff44 + #x973ff77 + #xff661033 + #xff000860 + #xff110f01 + #x17002910 + #x547ff44 + #xff330977 + #xff660f36 + #xff000860 + #xff110f01 + #x18002910 + #xff770444 + #x10330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x4441800 + #xff330977 + #xff661036 + #xff000860 + #xff110f01 + #x18002910 + #xff770344 + #x11330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441800 + #x9770247 + #x1136ff33 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x1441900 + #x973ff77 + #xff661233 + #xff000860 + #xff110f01 + #x1b002910 + #x13330944 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x8441b00 + #x1336ff33 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x8441b00 + #xff661033 + #x7550465 + #xf01ff00 + #x2910ff11 + #x7441b00 + #x1036ff33 + #x7550566 + #xf01ff00 + #x2910ff11 + #x5441b00 + #x6336fe33 + #x65ff6610 + #x75505 + #x110f01ff + #x2910ff + #x3305441b + #x55066612 + #x1ff0007 + #x10ff110f + #x441b0029 + #x36ff3304 + #x65ff6611 + #x75506 + #x110f01ff + #x2910ff + #x3304441b + #x55076612 + #x1ff0007 + #x10ff110f + #x441b0029 + #x66123303 + #x75508 + #x110f01ff + #x2910ff + #x6616441a + #x75509 + #x110f01ff + #x2910ff + #x6615441a + #x550965ff + #x1ff0007 + #x10ff110f + #x441a0029 + #x550a6615 + #x1ff0007 + #x10ff110f + #x441a0029 + #x65ff6614 + #x7550a + #x110f01ff + #x2910ff + #x6614441a + #x7550b + #x30ff3310 + #x441a0029 + #x550c6613 + #x33100007 + #x2930ff + #x6612441a + #x550b65ff + #x33104408 + #x2930ff + #x6612441a + #x54ff550b + #x33104408 + #x2930ff + #x6611441a + #x550b65ff + #x33104409 + #x2930ff + #x660f441a + #xb6561fe + #x954ff55 + #xff331044 + #x19002930 + #x2642fe44 + #x11fe660e + #x1b550b15 + #x2940ff44 + #x1441900 + #xaa6afe22 + #x61fd660b + #x550a1111 + #x441b54ff + #x2940ff + #x45f84416 + #x22225255 + #xaa6aaaa + #xff110266 + #x1c550915 + #x2940ff44 + #x1441600 + #x2252fd55 + #x9aa0222 + #x7110466 + #x1d54ff55 + #x2940ff44 + #x2441500 + #x2252fd55 + #xffaa0222 + #xff6607a6 + #xff110461 + #xff550515 + #xff441e54 + #x14002940 + #x245ff44 + #x3220255 + #x66607aa + #x1f550511 + #x2940ff44 + #xff441300 + #x2550345 + #x22aff22 + #x5a6ffaa + #x661ff66 + #x315ff11 + #x1f54ff55 + #x2940ff44 + #x4441300 + #x2220355 + #x86606aa + #x20550311 + #x2940ff44 + #x3441300 + #xfd220455 + #x526aa2a + #x861ff66 + #x215ff11 + #xff442055 + #x13002940 + #xff550244 + #xfe220552 + #x660522a2 + #x5501110a + #x442054ff + #x2940ff + #x55024413 + #x26ff2208 + #x61ff6603 + #x15fe110a + #xff442155 + #x13002940 + #xa550144 + #xc660322 + #x2154ff11 + #x2940ff44 + #xc441300 + #x6626fd22 + #x21110e66 + #x2940ff44 + #xd441300 + #x6166fe22 + #x14ff110e + #x40ff4420 + #x44130029 + #x21ff220d + #x44201110 + #x2940ff + #x220d4413 + #x111021ff + #x441f14ff + #x2940ff + #x42ff4413 + #x21ff220c + #x441f1111 + #x2940ff + #x220c4414 + #x111121ff + #x441e14ff + #x2940ff + #x42ff4414 + #x21ff220b + #x441e1112 + #x2940ff + #x220b4415 + #x111221ff + #x441d14ff + #x2940ff + #x42ff4415 + #x21ff220a + #x441d1113 + #x2940ff + #x220a4416 + #x111321ff + #x441c14ff + #x2940ff + #x220a4416 + #x111421ff + #x40ff441c + #x44160029 + #x220942ff + #x111421ff + #x441b14ff + #x2940ff + #x42ff4416 + #x21ff2209 + #x441b1115 + #x2940ff + #x22094417 + #x111521ff + #x441a14ff + #x2940ff + #xc4419 + #x111101ff + #x40ff441a + #x44190029 + #x1111000d + #x441914ff + #x2940ff + #xd4419 + #x111101ff + #x40ff4419 + #x44190029 + #x1111000e + #x441814ff + #x2940ff + #xe4419 + #x111101ff + #x40ff4418 + #x44190029 + #x1111000f + #x441714ff + #x2940ff + #xf4419 + #x111101ff + #x40ff4417 + #x44190029 + #x11110010 + #x441614ff + #x2940ff + #x104419 + #x111101ff + #x40ff4416 + #x44190029 + #x11110011 + #x441514ff + #x2940ff + #x114419 + #x111101ff + #x40ff4415 + #x44190029 + #x11110012 + #x441414ff + #x2940ff + #x124419 + #x111101ff + #x40ff4414 + #x44190029 + #x11110013 + #x441314ff + #x2940ff + #x134419 + #x111101ff + #x40ff4413 + #x44190029 + #x1111aa14 + #x441214ff + #x2940ff + #xaa144419 + #x1111a1ff + #x40ff4412 + #x44190029 + #x1111aa15 + #x441114ff + #x2940ff + #xaa154419 + #x1111a1ff + #x40ff4411 + #x44190029 + #x1111aa16 + #x441014ff + #x2940ff + #xaa164419 + #x111161ff + #x40ff4410 + #x44190029 + #x66ffaa16 + #x14ff1111 + #x40ff440f + #x44190029 + #x66feaa16 + #xf111161 + #x2940ff44 + #x2441600 + #x1aa1655 + #xff111166 + #xff440e14 + #x15002940 + #x245ff44 + #x1aa1655 + #x1161ff66 + #xff440e11 + #x15002940 + #x16550344 + #x116602aa + #xff440e11 + #x14002940 + #x245ff44 + #x165aff55 + #xff6602aa + #xe111061 + #x2940ff44 + #xff441400 + #x17550245 + #x106603aa + #x14003911 + #xff550244 + #x3aa175a + #xf61ff66 + #x13003911 + #x245ff44 + #x175aff55 + #xf6604aa + #x13003911 + #x18550344 + #xff6604aa + #x39110e61 + #x3441300 + #x5aa1855 + #x39110e66 + #xff441200 + #xff550245 + #x5aa185a + #xd61ff66 + #x12003911 + #x19550344 + #xff6605aa + #x4b110d61 + #x305ff00 + #x5aa1955 + #xd61ff66 + #xff004b11 + #xff550205 + #x5aa195a + #xd61ff66 + #xff004b11 + #xff550205 + #x6aa195a + #x4b110d66 + #x205ff00 + #x195aff55 + #xd6606aa + #xff004b11 + #xff550205 + #x6aa195a + #x4b110d66 + #x205ff00 + #x195aff55 + #xff6606aa + #x4b110c61 + #x205ff00 + #x195aff55 + #xff6606aa + #x4b110c61 + #x205ff00 + #x195aff55 + #x5a6ffaa + #xc61ff66 + #xff004b11 + #xff550205 + #xffaa195a + #xff6605a6 + #x4b110c61 + #x205ff00 + #x195aff55 + #x5a6ffaa + #xc61ff66 + #xff004b11 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #x7f007f60 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2600 + #x0 + #x0 + ) + :layer13 (new 'static 'array uint32 1200 + #x452301f8 + #xcdab8967 + #x16110bef + #xb660544 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x66054416 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #x5441611 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44161113 + #x220b6605 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x16111366 + #xb660544 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x66054416 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #x5441611 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44161113 + #x220b6605 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x441c1113 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xb441c11 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x220b441c + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x441c1113 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xb441c11 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x220b441c + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44091113 + #x441177ff + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xfd440811 + #xd747747 + #x6646fd44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44081113 + #x440d7702 + #x220b6602 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x7111366 + #x247ff44 + #xb74ff77 + #x246ff44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44071113 + #x440b7704 + #x220b6603 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x6111366 + #x447ff44 + #x974ff77 + #x346ff44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33041113 + #x77064401 + #x66044409 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xfe330411 + #x77064734 + #x440774ff + #x660446ff + #x72ff7701 + #x11162208 + #x770e17ff + #x111871ff + #x136616fe + #x8330511 + #x5440777 + #xff770166 + #x16220872 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33051113 + #x770737ff + #x440574ff + #x660546ff + #x72ff7701 + #x11162208 + #x770e17ff + #x111871ff + #x136616fe + #xff330511 + #x5770837 + #x2660644 + #xb220877 + #x7717fe11 + #x17ff1108 + #x71ff770e + #x16fe1118 + #x5111366 + #x837ff33 + #x374ff77 + #x646ff44 + #xff770266 + #xb220772 + #xff770111 + #xff110771 + #xff770e17 + #xfe111871 + #x11136616 + #x77093306 + #x66074403 + #x72ff7703 + #x110a2206 + #x777717fc + #xff110771 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3306 + #x74fc7708 + #x7464444 + #xff770466 + #xa220572 + #x8770211 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33071113 + #x74fd7708 + #x66074444 + #x770567ff + #x110e51ff + #x777717fc + #xff110871 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3307 + #x44fe7708 + #x5660746 + #x5575fe77 + #x7702110e + #x17ff1109 + #x71ff770e + #x16fe1118 + #x8111366 + #xff770833 + #x5660844 + #x5575fd77 + #xfc110c51 + #x71777717 + #x17ff1109 + #x71ff770e + #x16fe1118 + #x8111366 + #x737ff33 + #xfe660977 + #x77024467 + #x11085503 + #x47fd4403 + #x110a7777 + #x770e17ff + #x111871ff + #x136616fe + #xff330811 + #x9770737 + #x4464fb66 + #x4757747 + #x3110755 + #x7747fd44 + #xff110a71 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3308 + #x76ff7706 + #x44016609 + #x757747fd + #x51ff5504 + #x44041106 + #x110b77ff + #x770e17ff + #x111871ff + #x136616fe + #xff330811 + #x9770637 + #x4464fd66 + #x4770244 + #x651ff55 + #xff440511 + #xff110a41 + #xffdd031d + #xff7709d7 + #xfe111871 + #x11136616 + #x37ff3308 + #x76ff7705 + #x44016609 + #x770247ff + #x33fe5504 + #x5110531 + #xa41ff44 + #x31dff11 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770537ff + #x64fd6609 + #x77034444 + #x33015504 + #x44051105 + #x110a41ff + #xdd031dff + #x7709d7ff + #x111871ff + #x136616fe + #xff330811 + #xff770437 + #x1660976 + #x346ff44 + #xfc550377 + #x31333353 + #x44051104 + #x110a41ff + #xd7ffdd04 + #x71ff7709 + #x16fe1118 + #x8111366 + #x437ff33 + #x1660a77 + #x366ff44 + #x3550377 + #xff110333 + #xff440514 + #x5110941 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770437ff + #x44fd660a + #x11036646 + #x33045503 + #x44061102 + #x110841ff + #xdd051dff + #x7709d7ff + #x111871ff + #x136616fe + #xff330811 + #xd770437 + #x6110566 + #x1131fd33 + #xff440614 + #x6110841 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770437ff + #x1105660d + #x11ff3307 + #x41ff4407 + #x1dff1107 + #xd7ffdd06 + #x71ff7709 + #x16fe1118 + #x8111366 + #x437ff33 + #x5660d77 + #xff330711 + #xff440734 + #x7110741 + #x1b770add + #x8111366 + #x437ff33 + #x5660d77 + #x8330711 + #x641ff44 + #x71dff11 + #x1b770add + #x8111366 + #x437ff33 + #x5660d77 + #xff330611 + #xff440834 + #xff110441 + #xffdd081d + #xff7709d7 + #x13661b76 + #xff330811 + #xa550735 + #x6110566 + #xff440933 + #xff110441 + #xffdd081d + #x1c7709d7 + #x8111366 + #x735ff33 + #x5660a55 + #xff330511 + #xff440934 + #xff110441 + #x9dd081d + #x1c76ff77 + #x8111366 + #x735ff33 + #x5660a55 + #x10330511 + #x74dff44 + #x9d7ffdd + #x13661d77 + #xff330811 + #xa550735 + #x4110566 + #x1034ff33 + #x74dff44 + #xff7709dd + #x13661d76 + #xff330811 + #xa550735 + #x4110566 + #x1034ff33 + #x64dff44 + #x9d7ffdd + #x13661e77 + #xff330811 + #xa550735 + #xff110a66 + #xff441014 + #x9dd064d + #x1e76ff77 + #x8111366 + #x735ff33 + #x5440455 + #xff110a66 + #xff440f14 + #xadd064d + #x13661f77 + #xff330811 + #x4550735 + #x7660544 + #x216ff11 + #x6440f66 + #xad7ffdd + #x13661f77 + #xff330811 + #x4550735 + #x7660544 + #x216ff11 + #xd64ff66 + #x64dff44 + #xff770bdd + #x13661e76 + #xff330811 + #x4550735 + #x7660544 + #x316ff11 + #x6440d66 + #xcd7ffdd + #x13661e77 + #xff330811 + #x4550735 + #x7660544 + #x316ff11 + #xb64ff66 + #x64dff44 + #xff770ddd + #x13661d76 + #xff330811 + #x4550735 + #x7660544 + #x416ff11 + #xa64ff66 + #x54dff44 + #xdd7ffdd + #x1d76ff77 + #x8111366 + #x735ff33 + #x5440455 + #xff110766 + #xa660516 + #xedd0644 + #x1d76ff77 + #x8111366 + #x635ff33 + #x454ff55 + #x7660544 + #x516ff11 + #x864ff66 + #x54dff44 + #xfd7ffdd + #x1c76ff77 + #x8111366 + #x635ff33 + #x5440555 + #xff110766 + #x8660616 + #x11dd0644 + #x13661c77 + #xff330811 + #xff550535 + #x5440554 + #x7110766 + #x664ff66 + #x54dff44 + #x11d7ffdd + #x13661c77 + #xff330811 + #xff550535 + #x5440554 + #xff110666 + #x6660816 + #x11dd0644 + #x1c76ff77 + #x8111366 + #x535ff33 + #x554ff55 + #x6660544 + #xff660911 + #xff440464 + #xffdd054d + #x1d7711d7 + #x9111366 + #x435ff33 + #x5440655 + #xff110566 + #xff660916 + #x6440464 + #xff7711dd + #x13661d76 + #x3330a11 + #x654ff55 + #xa110b44 + #x36dff66 + #x54dff44 + #x10d7ffdd + #x1e76ff77 + #xa111366 + #x5535fc33 + #x44074555 + #x16ff110a + #xddfe660a + #x64402d4 + #xff7711dd + #x13661e76 + #xfe330b11 + #x44085455 + #x16ff110a + #x6dfa6609 + #x4444d4dd + #xffdd054d + #x1e7712d7 + #xb111366 + #x955ff33 + #xff110a44 + #x2660916 + #x64401dd + #xff7713dd + #x13661d76 + #xff330b11 + #xa440934 + #x916ff11 + #xfedd0266 + #xdd054dd4 + #x7713d7ff + #x661d76ff + #x330b1113 + #x440934ff + #x16ff110a + #x6dff6609 + #x7714dd09 + #x1113661e + #x440a330b + #x16ff110a + #x6dff660a + #xd7ffdd07 + #x76ff7713 + #x1113661e + #x37fe330a + #xa440977 + #xb16ff11 + #x14dd0766 + #x13661f77 + #x1330a11 + #x874ff77 + #xff110a44 + #x6660b16 + #x13d7ffdd + #x1f76ff77 + #x9111366 + #x237ff33 + #x8440877 + #xff770311 + #xff660976 + #x14dd051d + #x13662077 + #x3330911 + #x774ff77 + #x3110844 + #x771ff77 + #x4330211 + #x13d7ffdd + #x2076ff77 + #x8111366 + #x337ff33 + #x774ff77 + #x3110844 + #x771ff77 + #xff330211 + #x13dd043d + #x13662177 + #x5330811 + #x8440777 + #xff770311 + #x2110771 + #x431ff33 + #x11d7ffdd + #x2176ff77 + #x8111366 + #xff770533 + #x8440674 + #xff770311 + #x2110771 + #x1d31fe33 + #x7711dd04 + #x11136622 + #x77063308 + #x11084406 + #x71ff7703 + #x33021107 + #x41d31fe + #xfd7ffdd + #x2276ff77 + #x8111366 + #x5770733 + #x3110844 + #x771ff77 + #xfe220211 + #xdd051d21 + #x6623770f + #x33081113 + #x74ff7707 + #x11064404 + #x440314ff + #x22021109 + #x111121fd + #xd7ffdd04 + #x76ff770d + #x11136623 + #x77083308 + #x64344fe + #x1131fc33 + #x44031411 + #x22021109 + #x111121fc + #xddd041d + #x13662477 + #x8330811 + #x774ff77 + #x1131fc33 + #x44031411 + #x22021109 + #x110221ff + #xd7ffdd04 + #x76ff770b + #x11136624 + #x73ff7711 + #x31fc3307 + #x3141111 + #x2110944 + #x221ff22 + #x41dff11 + #x25770bdd + #x11111366 + #xfc330877 + #x14111131 + #x11114403 + #xd7ffdd04 + #x76ff7709 + #x11136625 + #x73ff7710 + #x31fc3308 + #x3141111 + #x6110944 + #x511ff55 + #x267709dd + #x10111366 + #xfc330977 + #x14111131 + #x11094403 + #x11ff5506 + #xd7ffdd05 + #x76ff7707 + #x11136626 + #x73ff770f + #x31fc3309 + #x3141111 + #x6110944 + #x1d11fe55 + #x7707dd05 + #x11136627 + #x330a770f + #x111031ff + #x11025506 + #xd7ffdd04 + #x76ff7705 + #x11136627 + #x73ff770e + #x36ff330a + #x61ff6607 + #x55061107 + #x1dff1102 + #x7705dd04 + #x11136628 + #x330b770e + #x660736ff + #x110761ff + #x11035506 + #xd1fedd03 + #xff770317 + #x13662876 + #xff770d11 + #xff330b73 + #xff660736 + #x6110761 + #xff110355 + #x1dd021d + #x29770311 + #xd111366 + #xff330c77 + #xff660736 + #x6110761 + #x1110455 + #x11d1fddd + #xff770211 + #x13662976 + #xff770c11 + #xff330c73 + #xff660736 + #x6110761 + #xfe110455 + #x1102d11d + #x777717fd + #x1113662a + #x73ff770c + #x36ff330c + #x61ff6607 + #x55061107 + #x77fe110a + #x13662a76 + #xff770c11 + #xff330c73 + #xff660736 + #x6110761 + #xff110a55 + #x13662b17 + #xff770c11 + #xff330c73 + #xff660736 + #xff111961 + #x13662b16 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #x2c110944 + #xc111366 + #xc73ff77 + #x736ff33 + #x561ff66 + #x8440911 + #x2c16ff11 + #xc111366 + #xc73ff77 + #x736ff33 + #x561ff66 + #x8440911 + #x13662d11 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #xff110744 + #x13662d16 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #x2e110744 + #xc111366 + #xc73ff77 + #xff660833 + #x9110561 + #xff110644 + #x13662e16 + #xff770c11 + #xff330673 + #x8550435 + #x561ff66 + #x6440911 + #x13662f11 + #xff770c11 + #xff330673 + #xff550335 + #xff660857 + #x9110561 + #x2f110644 + #xc111366 + #x673ff77 + #x335ff33 + #x7657fe55 + #x61ff6607 + #x44091105 + #x662f1106 + #x770c1113 + #x330673ff + #x550335ff + #x66077701 + #x110561ff + #x11064409 + #x1113662f + #x55024415 + #x777757fc + #xff660676 + #x9110561 + #x2f110644 + #x15111366 + #x3550244 + #xff660677 + #x9110561 + #x2f110644 + #x15111366 + #x3550244 + #x4550177 + #x561ff66 + #x6440911 + #x13662f11 + #x2441511 + #x7757fd55 + #xb550277 + #xfd440d11 + #x2f111141 + #x15111366 + #xfe550344 + #x55027577 + #x440d110b + #x222242fd + #x1113662f + #x55034415 + #x550357ff + #x440d110b + #x222242fc + #x13662e26 + #x8441511 + #xd110b55 + #x242ff44 + #x13662e22 + #x8441511 + #xd110b55 + #x242ff44 + #x2d26ff22 + #x15111366 + #xb550844 + #xff440d11 + #x2d220342 + #x15111366 + #xb550844 + #xff440d11 + #xff220342 + #x13662c26 + #x8441511 + #xd110b55 + #x442ff44 + #x13662c22 + #x8441511 + #xd110b55 + #x442ff44 + #x2b26ff22 + #x15111366 + #xb550844 + #xff440d11 + #xff220442 + #x13662b26 + #x8441511 + #xd110b55 + #x542ff44 + #x13662b22 + #x8441511 + #xd110b55 + #x542ff44 + #x13662b22 + #xff441511 + #xfd110b41 + #x4333313 + #x5440e11 + #x2a26ff22 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff440e11 + #xff220442 + #x13662a26 + #xff441511 + #xfd110441 + #x3333313 + #x3313fd11 + #xf110433 + #xff220444 + #x13662a26 + #xff441511 + #xfd110441 + #x3333313 + #x3313fd11 + #xf110433 + #x342ff44 + #x2a26ff22 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff441011 + #x2a110341 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff441011 + #xff110341 + #x13662916 + #xff441511 + #xfd110441 + #x3222212 + #x3313fd11 + #x10110433 + #x441ff44 + #x13662911 + #xff441511 + #xfd110441 + #x3222212 + #x3313fd11 + #x10110433 + #x441ff44 + #x2816ff11 + #x15111366 + #x441ff44 + #x2212fd11 + #xfd110322 + #x4333313 + #xff441011 + #x28110541 + #xc111366 + #xfd110e77 + #x3222212 + #x3313fd11 + #x10110433 + #x541ff44 + #x2716ff11 + #xc111366 + #xfd110e77 + #x3222212 + #x3313fd11 + #x10110433 + #x641ff44 + #x13662711 + #x12770c11 + #x1161fa66 + #x33331311 + #x44101104 + #x110641ff + #x662616ff + #x770c1113 + #x11016613 + #x333313fd + #x44101104 + #x110741ff + #x11136626 + #x6613770c + #x131161fb + #x11043333 + #x41ff4410 + #x16ff1107 + #x11136625 + #x6614770c + #x44101108 + #x110841ff + #x11136625 + #x6614770c + #x110761ff + #x41ff4410 + #x16ff1108 + #x11136624 + #x6615770c + #x44101107 + #x110941ff + #x11136624 + #x6615770c + #x110661ff + #x41ff4410 + #x16ff1109 + #x11136623 + #x6616770c + #x44101106 + #x110a41ff + #x11136623 + #x6616770c + #x110561ff + #x41ff4410 + #x16ff110a + #x11136622 + #x6617770c + #x44101105 + #x110b41ff + #x11136622 + #x6617770c + #x112261ff + #x662116ff + #x77081113 + #x661b76ff + #x66211123 + #x77091113 + #x1123661b + #x662016ff + #x77091113 + #x661a76ff + #x770a1159 + #x1159661a + #x661a770a + #x770a1159 + #x1159661a + #x6616770a + #x667677fc + #x8115966 + #x1776ff77 + #x7677fc66 + #x11596666 + #x66187708 + #x667677fc + #x7115966 + #x1876ff77 + #x7677fc66 + #x11596666 + #x76ff7707 + #x77fc6618 + #x1c666676 + #x1144fc11 + #x11384111 + #x76ff7707 + #x77fc6618 + #x1b666676 + #xfc440111 + #x41441411 + #x772b1137 + #x111471ff + #x414414fb + #x11384414 + #x71ff772b + #x14f6110f + #x41141141 + #x44414414 + #x2b113844 + #xf71ff77 + #xfc440111 + #x11444411 + #x11384403 + #x771e220c + #x440574ff + #x110741ff + #x444414f9 + #x11444411 + #x11014403 + #x113544ff + #x771e220c + #x440574ff + #x110741ff + #x444414fb + #x44051441 + #x441441fd + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x41ff440c + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x41ff440c + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x11fe440d + #xc113344 + #x5771f22 + #x641ff44 + #xf14ff11 + #x3241ff44 + #x1f220c11 + #x474ff77 + #x341ff44 + #x32441411 + #x1f220c11 + #x1e74ff77 + #xc113244 + #x1e771f22 + #x3241ff44 + #x1f220c11 + #xfe441e77 + #x11311411 + #x771f220c + #x41fd441e + #x11304144 + #x771f220c + #x440d74ff + #x106466fe + #xc113044 + #xff771f22 + #x4440474 + #x1440311 + #xff440f66 + #xc113041 + #x4772022 + #x3110444 + #x6646fe44 + #x1131440f + #x7720220c + #x770344ff + #x44031104 + #x446646fb + #x44106666 + #x220c112d + #x11057725 + #x46ff4402 + #x64ff6603 + #x112d440f + #x7725220c + #x44031105 + #x64ff6603 + #x112d440f + #x7724220d + #x44021105 + #x660346ff + #x440e64ff + #x112d41ff + #x7724220d + #x44021105 + #x440f6604 + #x220d112e + #x11057724 + #x46ff4401 + #x64ff6603 + #x41ff440e + #x220d112e + #x11057724 + #x66044401 + #x41ff440f + #x2211112e + #x11057720 + #x34614fe + #xf64ff66 + #x11112f44 + #x6772022 + #xf660411 + #x11113044 + #x5772022 + #x316ff11 + #xe64ff66 + #x3041ff44 + #x20221111 + #xff110577 + #xff660316 + #xff440d11 + #x11113141 + #x6772022 + #xff660211 + #xff440d61 + #x11113241 + #x6772022 + #x6616fc11 + #x440a1166 + #x411441fd + #x22111133 + #x11077720 + #x116166fd + #x11ff4402 + #x41ff4406 + #x22111135 + #x11077720 + #x110216ff + #x11ff4401 + #x11fd4404 + #x11354144 + #x77202211 + #x14fd110b + #x44041144 + #x414411fd + #x22111135 + #x110e7720 + #x11fd4404 + #x11354144 + #x77202211 + #x4404110e + #x22111138 + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x1138 + ) + :layer14 (new 'static 'array uint32 448 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x29007f00 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #x10005522 + #x1772ff77 + #x11005522 + #x55221777 + #xff771100 + #x55221672 + #x16771200 + #x12005522 + #x3220377 + #xd42ff44 + #x12005522 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x240ff44 + #xff660800 + #x12005660 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xfc005260 + #x67666606 + #x70ff7707 + #x4404000c + #x240ff + #x60ff6608 + #x6fc0052 + #x7676666 + #xc70ff77 + #xff440800 + #xff660746 + #xfc005260 + #x67666606 + #x70ff7707 + #x4408000c + #x660746ff + #x5260ff + #x666606f9 + #x76777767 + #xf6602 + #x46ff4408 + #x60ff6607 + #x6ff0052 + #x77016602 + #xf6603 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x66084408 + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #x4408000f + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x330a6608 + #x6608000d + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #xd330a + #x67ff6608 + #x70ff7714 + #x6ff003c + #x330a6608 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x470ff + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6870ff + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x7f441c + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x38007f + #x0 + #x0 + ) + :layer15 (new 'static 'array uint32 512 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #xff001700 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000466 + #x56331a03 + #x19660e00 + #x10005633 + #x56331766 + #xff661100 + #x56331563 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #x26003033 + #xb46ff44 + #xf60ff66 + #x30330900 + #xa442800 + #xf60ff66 + #x30330900 + #x9442900 + #xf60ff66 + #x30330900 + #x8442a00 + #xf60ff66 + #x30330900 + #x7442b00 + #xf60ff66 + #x30330900 + #x6442c00 + #xf60ff66 + #x30330900 + #xff442c00 + #xff660546 + #x9000f60 + #x2d003033 + #xff660544 + #x9000f60 + #x2d003033 + #x9001644 + #x2d003033 + #x9001644 + #x2d003033 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #xc770944 + #x27330900 + #x707ff00 + #x2c74ff77 + #xc770944 + #x27330900 + #x707ff00 + #x2b74ff77 + #xc770a44 + #x27330900 + #x807ff00 + #xff442a77 + #xc770a47 + #x27330900 + #x807ff00 + #xb442a77 + #x9000c77 + #xff002733 + #x28770907 + #xb47ff44 + #x9000c77 + #xff002733 + #x8772907 + #xc770c44 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xff003e77 + #x3e773f07 + #x3f07ff00 + #xff003e77 + #x3e773f07 + #x3f07ff00 + #x7f007f77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d00 + ) + :layer16 (new 'static 'array uint32 448 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x29007f00 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #x10005522 + #x1772ff77 + #x11005522 + #x55221777 + #xff771100 + #x55221672 + #x16771200 + #x12005522 + #x3220377 + #xd42ff44 + #x12005522 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x240ff44 + #xff660800 + #x12005660 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xfc005260 + #x67666606 + #x70ff7707 + #x4404000c + #x240ff + #x60ff6608 + #x6fc0052 + #x7676666 + #xc70ff77 + #xff440800 + #xff660746 + #xfc005260 + #x67666606 + #x70ff7707 + #x4408000c + #x660746ff + #x5260ff + #x666606f9 + #x76777767 + #xf6602 + #x46ff4408 + #x60ff6607 + #x6ff0052 + #x77016602 + #xf6603 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x66084408 + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #x4408000f + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x330a6608 + #x6608000d + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #xd330a + #x67ff6608 + #x70ff7714 + #x6ff003c + #x330a6608 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x470ff + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6870ff + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x7f441c + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x38007f + #x0 + #x0 + ) + :layer17 (new 'static 'array uint32 692 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x35002c00 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x3530ff33 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x3530ff33 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x4430fd33 + #x4770647 + #x747ff44 + #x1d74ff77 + #x3d40ff44 + #xff330900 + #x1b771937 + #x3d40ff44 + #xff330900 + #xff772837 + #xff440b74 + #x9003d40 + #x2937ff33 + #xff440b77 + #x9003d40 + #x2937ff33 + #xa74ff77 + #x3d40ff44 + #xff330900 + #xa772a37 + #x3d40ff44 + #xff330900 + #xff772a37 + #xff440974 + #x9003d40 + #x2a37ff33 + #x974ff77 + #x3d40ff44 + #xff330900 + #xff772a37 + #xff440974 + #x9003d40 + #x2a37ff33 + #x974ff77 + #x3d40ff44 + #xff330900 + #xa772a37 + #x3d40ff44 + #xff330900 + #xff772937 + #xff440a74 + #xa003d40 + #xb772933 + #x3d40ff44 + #x28330a00 + #xb74ff77 + #x3d40ff44 + #x28330a00 + #xff440c77 + #xa003d40 + #xff772733 + #xff440c74 + #xa003d40 + #xd772733 + #x3d40ff44 + #xff330a00 + #xff772537 + #xff440d74 + #xa003d40 + #x2537ff33 + #xff440e77 + #xa003d40 + #x2437ff33 + #xe74ff77 + #x3d40ff44 + #xff330a00 + #xf772437 + #x3d40ff44 + #x9330b00 + #xff661977 + #xff440574 + #x21771947 + #xb05ff00 + #x9330a55 + #x6661977 + #x21771a44 + #xb05ff00 + #xff330a55 + #x19770837 + #xff440566 + #x21771a47 + #xb05ff00 + #xff330a55 + #xff770437 + #xff661c76 + #x1b440464 + #xff002177 + #xa550b05 + #x437ff33 + #x1d76ff77 + #xff440366 + #x21771b47 + #x1c05ff00 + #x1d56ff55 + #x264ff66 + #x21771c44 + #x1c05ff00 + #x1e56ff55 + #xff440166 + #x21771c47 + #x1c05ff00 + #x1e56ff55 + #x4464fe66 + #x21771d + #x551c05ff + #x661256ff + #x440364ff + #x660646ff + #x771d47ff + #x5ff0021 + #x56ff551c + #x64ff6608 + #x46ff4403 + #x44066602 + #x67ff6606 + #x21771d + #x551c05ff + #x660656ff + #x46ff4411 + #x67ff6605 + #x21771d + #x551c05ff + #x660556ff + #x441164ff + #x660646ff + #x21771d + #x551c05ff + #x660456ff + #x441364ff + #x771d6606 + #x5ff0021 + #x56ff551c + #x44146604 + #x660546ff + #x21771d + #x551c05ff + #x660356ff + #x441564ff + #x67ff6605 + #x21771c + #x551c05ff + #x660356ff + #x46ff4416 + #x67ff6604 + #x21771c + #x551c05ff + #x660256ff + #x441764ff + #x67ff6604 + #x21771c + #x551c05ff + #x660256ff + #x441764ff + #x660446ff + #x21771c + #x551c05ff + #x660256ff + #x46ff4418 + #x771c6604 + #x5ff0021 + #x56ff551c + #x44186602 + #x660446ff + #x21771c + #x551c05ff + #x660256ff + #x46ff4418 + #x67ff6604 + #x21771b + #x551c05ff + #x660256ff + #x46ff4418 + #x67ff6604 + #x21771b + #x551c05ff + #x666656fc + #xff441864 + #xff660446 + #x21771b67 + #x1c05ff00 + #x6656fc55 + #x44186466 + #x660446ff + #x771b67ff + #x5ff0021 + #x56fc551c + #x18646666 + #x546ff44 + #x21771b66 + #x1c05ff00 + #x6656fd55 + #xff441966 + #x1b660546 + #xff002177 + #xfd551c05 + #x19666656 + #x546ff44 + #x21771b66 + #xc05ff00 + #x456ff55 + #xff442666 + #xff660546 + #x21771a67 + #xc05ff00 + #x456ff55 + #xff442666 + #xff660546 + #x2f771a67 + #x406ff00 + #xff442666 + #x1a660646 + #xff002f77 + #x26660406 + #x646ff44 + #x2f771a66 + #x406ff00 + #xff442666 + #xff660646 + #x2f771967 + #x406ff00 + #xff442666 + #xff660646 + #x2f771967 + #x406ff00 + #xff442666 + #x19660746 + #xff002f77 + #x26660406 + #x746ff44 + #x2f771966 + #x406ff00 + #xff442666 + #x19660746 + #xff002f77 + #x26660406 + #x746ff44 + #x1867ff66 + #xff002f77 + #x26660406 + #x846ff44 + #x2f771866 + #x406ff00 + #xff442666 + #xff660846 + #x2f771767 + #x406ff00 + #xff442666 + #xff660846 + #x2f771767 + #x406ff00 + #xff442666 + #x17660946 + #xff002f77 + #x26660406 + #x946ff44 + #x2f771766 + #x406ff00 + #xff442666 + #xff660946 + #x2f771667 + #x406ff00 + #xff442666 + #xff660946 + #x2f771667 + #x406ff00 + #xff442666 + #x16660a46 + #xff002f77 + #x26660406 + #xa46ff44 + #x2f771666 + #x406ff00 + #xff442666 + #x16660a46 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x2f771566 + #x406ff00 + #xff442666 + #x15660b46 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x1367ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x2f771366 + #x406ff00 + #xff442666 + #x13660d46 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xff660e44 + #x26771267 + #x202ff00 + #x926ff22 + #xe442666 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xe46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xe46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xff660f44 + #x26771267 + #xe02ff00 + #x2224ff22 + #xf46ff44 + #x1267ff66 + #xff002677 + #xff220e02 + #xff442224 + #xff660f46 + #x26771267 + #xe02ff00 + #x2224ff22 + #xff661044 + #x26771267 + #xe02ff00 + #x2124ff22 + #x1046ff44 + #x1267ff66 + #xff002677 + #xff220e02 + #xff442124 + #xff660546 + #x17550565 + #xff002677 + #xff220e02 + #x6442124 + #x565ff66 + #x26771755 + #xe02ff00 + #x2124ff22 + #xff660644 + #x17550565 + #xff002677 + #xff220e02 + #xff442024 + #xff660646 + #x17550565 + #xff002677 + #xff220e02 + #xff442024 + #xff660646 + #x17550565 + #xff002677 + #xff220e02 + #x7442024 + #x565ff66 + #x26771755 + #xe02ff00 + #x2024ff22 + #xff660744 + #x17550565 + #xff002677 + #xff220e02 + #x7442024 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xc02ff00 + #x2124ff22 + #xff660844 + #x17550565 + #xff002677 + #xff220c02 + #x8442124 + #x565ff66 + #x26771755 + #xc02ff00 + #x2124ff22 + #xff660844 + #x17550565 + #xff002677 + #xff220c02 + #x8442124 + #x17550666 + #xff002677 + #xff220c02 + #x8442124 + #x17550666 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #x7660744 + #x26771755 + #xf02ff00 + #x7441f22 + #x17550766 + #xff002677 + #x1f220f02 + #x7660744 + #x26771755 + #xf02ff00 + #xff441e22 + #xff660646 + #x3e550765 + #xf02ff00 + #x7441e22 + #x765ff66 + #xff003e55 + #x1e220f02 + #x8660744 + #xff003e55 + #x1e220f02 + #x8660744 + #xff003e55 + #x1e220f02 + #xff660644 + #x3e550865 + #xf02ff00 + #x6441e22 + #x3e550966 + #xf02ff00 + #x6441e22 + #x3e550966 + #xf02ff00 + #x5441e22 + #x965ff66 + #xff003e55 + #x6220f02 + #x6646fb44 + #x12664664 + #xa660544 + #xff003e55 + #x5220f02 + #xff660544 + #x5441164 + #x3e550a66 + #xf02ff00 + #xff440422 + #xff660546 + #xff441064 + #xff660446 + #x3e550a65 + #xf02ff00 + #x7440422 + #xff441066 + #xff660446 + #x3e550a65 + #xf02ff00 + #xff440322 + #x10660746 + #xb660544 + #x13004855 + #xff440566 + #xff660e46 + #x48550b65 + #xff662900 + #x48550b65 + #xc662900 + #x29004855 + #x48550c66 + #xd662800 + #x27004855 + #xd65ff66 + #x26004855 + #xe65ff66 + #x25004855 + #xf65ff66 + #x24004855 + #x1065ff66 + #x23004855 + #x1165ff66 + #x22004855 + #x48551366 + #xff661d00 + #x48551765 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x7f552e65 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1b00 + #x0 + #x0 + ) + :layer18 (new 'static 'array uint32 1168 + #x452301f8 + #xcdab8967 + #x80037ef + #x7510ff11 + #xff110800 + #x8007510 + #x7510ff11 + #xff110800 + #x8007510 + #x7510ff11 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440204 + #x5000540 + #x8001066 + #x5310ff11 + #x204ff00 + #x540ff44 + #x9660500 + #x12770100 + #xff550111 + #xff004c50 + #xff440204 + #x5000540 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #x5000540 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #xff550111 + #x18000650 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x9111277 + #xff221855 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x9111277 + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x201ff00 + #x710ff11 + #x206ff00 + #xff000266 + #x12770707 + #x18550911 + #x2b20ff22 + #x201ff00 + #x710ff11 + #x506ff00 + #x767ff66 + #x9111277 + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002720 + #xff550205 + #xff110251 + #x3550315 + #x506ff00 + #x667ff66 + #x27aff77 + #xfd110daa + #x8a5aa1a + #x2220455 + #xff221044 + #xff002720 + #x2550305 + #x3550411 + #x506ff00 + #x667ff66 + #xdaa0377 + #xaa1afc11 + #x5507a5aa + #x44022204 + #x220f42ff + #x2720ff + #x550305ff + #x55041102 + #x6ff0003 + #x60ff6605 + #xaa040005 + #x1aff110d + #xa5ffaa02 + #x22035506 + #x440324ff + #x20ff220f + #x5ff0027 + #x11025503 + #x35504 + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5fc0021 + #x4777755 + #x1770155 + #x4001155 + #xff110daa + #xffaa021a + #xff0007a0 + #x15440604 + #x2170ff77 + #x5505fc00 + #x55047777 + #x55017701 + #xaa040011 + #x1aff110d + #xa0ffaa02 + #x4ff0007 + #x77154406 + #x2170ff + #x775505fc + #x1550477 + #x11550177 + #xdaa0400 + #x21aff11 + #x7a0ffaa + #x604ff00 + #xff771544 + #xfc002170 + #x77775505 + #x77015504 + #x115501 + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x33025503 + #x115504 + #x110daa04 + #xaa021aff + #x7a0ff + #x440804ff + #x771247ff + #x2170ff + #x550305ff + #x55043302 + #xaa040011 + #x11023304 + #x330413ff + #xaa023aff + #x7a0ff + #x440804ff + #x771247ff + #x2170ff + #x550305ff + #x55043302 + #xaa040011 + #x3aff330d + #xa0ffaa02 + #x4ff0007 + #x47ff4408 + #x70ff7712 + #x5ff0021 + #x33025503 + #xe5504 + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x5ff0021 + #x53ff5502 + #x35ff3302 + #xe5503 + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x771247ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x771247ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x940ff + #x770707ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x40ff4408 + #x7ff0009 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x940ff + #x770707ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x40ff4408 + #x7ff0009 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x4ff0025 + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x550605ff + #x55072202 + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x55090009 + #xe50ff + #x331b03ff + #x5ff0001 + #x22025506 + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x360ff + #x50ff5509 + #x3ff000e + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x220362ff + #x51ff5509 + #x44fe1104 + #xff220742 + #xc331b23 + #xc20ff22 + #x707ff00 + #xa70ff77 + #xc03ff00 + #x436ff33 + #x362ff66 + #xff550922 + #xfe110451 + #x22074244 + #x331b23ff + #x20ff220c + #x7ff000c + #x70ff7707 + #x3ff000a + #x36ff330c + #x62ff6604 + #x55092203 + #x110451ff + #x74244fe + #x1b23ff22 + #xff220c33 + #xff000c20 + #xff770707 + #xff000a70 + #xff330c03 + #xff660436 + #x9220362 + #x451ff55 + #x4244fe11 + #x23ff2207 + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x220362ff + #x51ff5509 + #x44fe1104 + #xff220742 + #xc331b23 + #xc20ff22 + #x707ff00 + #xa70ff77 + #xc03ff00 + #x436ff33 + #x362ff66 + #xff550922 + #xfe110451 + #x22074244 + #x331b23ff + #x20ff220c + #x7ff000c + #x70ff7707 + #x3ff000a + #x36ff330c + #x62ff6604 + #x55092203 + #x110451ff + #x74244fe + #x1b23ff22 + #xff220c33 + #xff000c20 + #xff770707 + #xff000a70 + #xff330c03 + #xff660436 + #x9220362 + #x451ff55 + #x4244fe11 + #x23ff2207 + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #x1170ff + #x30ff3306 + #xbff000b + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5504000f + #x550550ff + #x660c56ff + #x1260ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x550b000f + #x660c56ff + #x1260ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x550b000f + #x660c56ff + #x1560ff + #x60ff6616 + #x7ff001c + #x70ff7707 + #x5507000f + #x5502cdff + #x660c56ff + #x1560ff + #x60ff6616 + #x7ff001c + #x70ff7707 + #x550b000f + #x660c56ff + #x1560ff + #x62fd6615 + #x182222 + #x70ff770b + #x550b000f + #x660c56ff + #x1560ff + #x62ff6615 + #x20ff220c + #x770b000c + #xf70ff + #x56ff550b + #x60ff660c + #x66150015 + #x220e62ff + #x770b000b + #xf70ff + #x56ff550b + #x60ff660c + #x66150015 + #x220f62ff + #x920ff + #x70ff770b + #x550b000f + #x660c56ff + #x1560ff + #x62ff6615 + #x82211 + #x70ff770b + #x5502000f + #x55052202 + #x660c56ff + #x1560ff + #x62ff6615 + #x20ff2212 + #x1ff0002 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66150023 + #x221662ff + #x110221ff + #x70ff770b + #x5502000f + #x55052202 + #x2350ff + #x62ff6615 + #x21ff2216 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xd60ff + #x21ff2207 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xe60ff + #x21ff2206 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xf60ff + #x21ff2205 + #x770b1102 + #xf70ff + #x50ff550b + #x66160023 + #x1060ff + #x220302ff + #x110221ff + #x70ff770b + #x550b000f + #x2350ff + #x60ff6616 + #x770b0019 + #xf70ff + #x50ff550b + #x66160023 + #x3660ff + #x50ff550b + #x66160023 + #x3660ff + #x50ff550b + #x66160023 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x2e007f + #x0 + #x0 + ) + :layer19 (new 'static 'array uint32 668 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4b007f00 + #xff330a00 + #xa007330 + #x7330ff33 + #xff330a00 + #xa007330 + #x7330ff33 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x5e770e37 + #xa660500 + #xe37ff33 + #x6005e77 + #xe330a66 + #x6005e77 + #x963ff66 + #xd37ff33 + #x7005e77 + #xd330a66 + #x7005e77 + #xff330a66 + #x5e770c37 + #xff660700 + #xc330a63 + #x7005e77 + #xa63ff66 + #xb37ff33 + #x7005e77 + #xb63ff66 + #x5e770b33 + #xff660700 + #xff330b63 + #x56770a37 + #x604ff00 + #xff660744 + #xa330c63 + #xff005677 + #xff440604 + #xff660646 + #xff330c63 + #x56770937 + #x704ff00 + #xff660644 + #xff330c63 + #x56770937 + #x704ff00 + #x546ff44 + #xc63ff66 + #x937ff33 + #xff005677 + #x5440804 + #xc63ff66 + #x930ff33 + #xff005677 + #xff440804 + #xff660446 + #xff330c63 + #x56770930 + #x804ff00 + #x446ff44 + #xc63ff66 + #x907ff33 + #xff005677 + #x4440904 + #xb63ff66 + #xa30ff33 + #xff005677 + #x4440904 + #xb63ff66 + #xa07ff33 + #xff005677 + #x4440904 + #xa63ff66 + #xb30ff33 + #xff006677 + #xff330a03 + #x66770b07 + #x903ff00 + #xc30ff33 + #xff006677 + #xff330903 + #x66770c07 + #x803ff00 + #xd30ff33 + #xff006677 + #xff330803 + #x1c770d07 + #xff551800 + #xff002f50 + #xff330703 + #x1c770e30 + #xff551800 + #xff002f50 + #xff330703 + #x1c770e07 + #xff551800 + #xff002f50 + #xff330603 + #x1c770f30 + #xff551800 + #xff003750 + #x1c770f07 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #xff770a00 + #x1c660576 + #xff551800 + #xa003650 + #x576ff77 + #x18001c66 + #x3650ff55 + #x7770900 + #x18001c66 + #x3650ff55 + #x8770800 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #xff770600 + #x1c660976 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #x2e660856 + #xf06ff00 + #x18001c66 + #x856ff55 + #xff002e66 + #x1c660f06 + #xfc551400 + #x55556556 + #x2e6609 + #x660f06ff + #x5513001c + #x666650fb + #x66095665 + #x6ff002e + #x1c660f + #xff5513 + #xa660d + #x550f05ff + #x1150ff + #x660f06ff + #x5512001c + #xd0600fe + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x651ff55 + #x910ff11 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x651ff55 + #x910ff11 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #x3660506 + #x2110ff11 + #x4550d00 + #xe06ff44 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #xff660406 + #xff110361 + #xd002110 + #xff440455 + #xff660e06 + #xff330a00 + #xff550e35 + #xff110651 + #xff000910 + #xff660306 + #xff110461 + #xd002110 + #xfe440455 + #x660d0600 + #x330a00ff + #x550e35ff + #x111c51ff + #x2110ff + #x4404550d + #xd0600fe + #xa00ff66 + #xe35ff33 + #x1c51ff55 + #x2110ff11 + #x4550d00 + #x600fe44 + #xff660d + #x35ff330a + #x51ff550e + #x10ff111c + #x550e0021 + #xfe4403 + #xff660d06 + #xff330a00 + #xff550435 + #xff550915 + #xff111b51 + #xe002110 + #xfe440355 + #x660d0600 + #x330a00ff + #x30fc + #xff110201 + #x1b550915 + #x2110ff11 + #xff550e00 + #xfe440254 + #x660d0600 + #x330a00ff + #x30fc + #xff110301 + #x1b550815 + #x2110ff11 + #x2550f00 + #x600fe44 + #xff660d + #x30fc330a + #x4010000 + #x1b550811 + #x2110ff11 + #x2550f00 + #x600fe44 + #xff660d + #x30fc330a + #x4010000 + #xff550711 + #xff111b51 + #xf002110 + #xfe440255 + #x660d0600 + #x330a00ff + #x30fc + #x7110401 + #x1b51ff55 + #x2110ff11 + #x3550f00 + #xd06ff00 + #xa00ff66 + #x30fc33 + #x11040100 + #x1fc0003 + #x1c551511 + #x2110ff11 + #x3550f00 + #xd06ff00 + #xa00ff66 + #x30fc33 + #x11040100 + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33090002 + #x220232ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x220332ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x220332ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x21ff2205 + #x31103 + #x10ff1120 + #x7709002b + #x660a76ff + #x260ff + #x22063308 + #x31103 + #x10ff1120 + #x770a002b + #x60ff660a + #x33070002 + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770a1107 + #x660976ff + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770b1107 + #x60ff6609 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110701ff + #x770a17ff + #x660876ff + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770b1108 + #x60ff6608 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110901ff + #x76ff770a + #x60ff6607 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110a01ff + #x6607770a + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x17ff110a + #x76ff7709 + #x60ff6606 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110b01ff + #x76ff7709 + #x60ff6606 + #x32ff330a + #x20ff2207 + #x1ff0009 + #x10ff111b + #x1ff0022 + #x7709110b + #x60ff6607 + #x32ff330a + #x20ff2207 + #x1ff0009 + #x10ff111b + #x1ff0022 + #x7708110b + #x660776ff + #x330a60ff + #x220732ff + #x920ff + #x111b01ff + #x2210ff + #x110b01ff + #x76ff7708 + #x60ff6607 + #x153308 + #x111b01ff + #x2210ff + #x110b01ff + #x66087708 + #x330860ff + #x1ff0015 + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x153308 + #x111b01ff + #x2210ff + #x110b01ff + #x66082208 + #x330860ff + #x40ff4404 + #x1ff000f + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x34ff3307 + #x40ff4404 + #x1ff000f + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x44053307 + #xf40ff + #x111b01ff + #x2210ff + #x110b01ff + #x20ff2209 + #x33060007 + #x440534ff + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x220912ff + #x720ff + #x44063306 + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x220912ff + #x720ff + #x44073305 + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x24ff220a + #x43fe440b + #xff440734 + #xff000f40 + #xff111b01 + #xff002210 + #xff110901 + #xff220a12 + #xff440c24 + #xff440734 + #xff000f40 + #xff111b01 + #xff002210 + #xff110901 + #xff220a12 + #xff441524 + #xff000f40 + #xff111b01 + #xff002210 + #xb110901 + #x1524ff22 + #xf40ff44 + #x1b01ff00 + #x2210ff11 + #x901ff00 + #xff220b11 + #xff441524 + #xff000f40 + #xff111b01 + #xff002210 + #xff110801 + #xff220b12 + #xff441524 + #xff000f40 + #xff111b01 + #xe002a10 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #xff441622 + #xd005840 + #x1624ff22 + #x5840ff44 + #xff220d00 + #xff441624 + #xc005840 + #xff441822 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #x7f007f40 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4300 + #x0 + ) + ) + ) diff --git a/goal_src/jak2/engine/ui/bigmap-h.gc b/goal_src/jak2/engine/ui/bigmap-h.gc index 29b6dd88b..e07551c60 100644 --- a/goal_src/jak2/engine/ui/bigmap-h.gc +++ b/goal_src/jak2/engine/ui/bigmap-h.gc @@ -63,27 +63,27 @@ (deftype bigmap-compressed-layers (structure) - ((data uint32 20 :offset-assert 0) - (layer0 uint32 :offset 0) - (layer1 uint32 :offset 4) - (layer2 uint32 :offset 8) - (layer3 uint32 :offset 12) - (layer4 uint32 :offset 16) - (layer5 uint32 :offset 20) - (layer6 uint32 :offset 24) - (layer7 uint32 :offset 28) - (layer8 uint32 :offset 32) - (layer9 uint32 :offset 36) - (layer10 uint32 :offset 40) - (layer11 uint32 :offset 44) - (layer12 uint32 :offset 48) - (layer13 uint32 :offset 52) - (layer14 uint32 :offset 56) - (layer15 uint32 :offset 60) - (layer16 uint32 :offset 64) - (layer17 uint32 :offset 68) - (layer18 uint32 :offset 72) - (layer19 uint32 :offset 76) + ((data (pointer uint32) 20 :offset-assert 0) + (layer0 (pointer uint32) :offset 0) + (layer1 (pointer uint32) :offset 4) + (layer2 (pointer uint32) :offset 8) + (layer3 (pointer uint32) :offset 12) + (layer4 (pointer uint32) :offset 16) + (layer5 (pointer uint32) :offset 20) + (layer6 (pointer uint32) :offset 24) + (layer7 (pointer uint32) :offset 28) + (layer8 (pointer uint32) :offset 32) + (layer9 (pointer uint32) :offset 36) + (layer10 (pointer uint32) :offset 40) + (layer11 (pointer uint32) :offset 44) + (layer12 (pointer uint32) :offset 48) + (layer13 (pointer uint32) :offset 52) + (layer14 (pointer uint32) :offset 56) + (layer15 (pointer uint32) :offset 60) + (layer16 (pointer uint32) :offset 64) + (layer17 (pointer uint32) :offset 68) + (layer18 (pointer uint32) :offset 72) + (layer19 (pointer uint32) :offset 76) ) :method-count-assert 9 :size-assert #x50 @@ -209,18 +209,57 @@ (set! (-> gp-0 sprite-tmpl dma-vif dma) (new 'static 'dma-tag :qwc #x6 :id (dma-tag-id cnt))) (set! (-> gp-0 sprite-tmpl dma-vif vif0) (new 'static 'vif-tag)) (set! (-> gp-0 sprite-tmpl dma-vif vif1) (new 'static 'vif-tag :imm #x6 :cmd (vif-cmd direct) :msk #x1)) - (set! (-> gp-0 sprite-tmpl gif0) (the-as uint #x50ab400000008001)) - (set! (-> gp-0 sprite-tmpl gif1) (the-as uint #x53531)) + (set! (-> gp-0 sprite-tmpl gif0) + (the uint64 (new 'static 'gif-tag64 + :nloop #x1 + :eop #x1 + :pre #x1 + :prim (new 'static 'gs-prim :prim (gs-prim-type sprite) :tme #x1 :abe #x1 :fst #x1) + :nreg #x5 + ) + ) + ) + (set! (-> gp-0 sprite-tmpl gif1) + (the uint64 (new 'static 'gif-tag-regs + :regs0 (gif-reg-id rgbaq) + :regs1 (gif-reg-id uv) + :regs2 (gif-reg-id xyz2) + :regs3 (gif-reg-id uv) + :regs4 (gif-reg-id xyz2) + ) + ) + ) (set! (-> gp-0 draw-tmpl dma-vif dma) (new 'static 'dma-tag :qwc #xa :id (dma-tag-id cnt))) (set! (-> gp-0 draw-tmpl dma-vif vif0) (new 'static 'vif-tag)) (set! (-> gp-0 draw-tmpl dma-vif vif1) (new 'static 'vif-tag :imm #xa :cmd (vif-cmd direct) :msk #x1)) - (set! (-> gp-0 draw-tmpl gif0) (the-as uint #x90aa400000008001)) - (set! (-> gp-0 draw-tmpl gif1) (the-as uint #x535353531)) + (set! (-> gp-0 draw-tmpl gif0) + (the uint64 (new 'static 'gif-tag64 + :nloop #x1 + :eop #x1 + :pre #x1 + :prim (new 'static 'gs-prim :prim (gs-prim-type tri-strip) :tme #x1 :abe #x1 :fst #x1) + :nreg #x9 + ) + ) + ) + (set! (-> gp-0 draw-tmpl gif1) (the uint64 (new 'static 'gif-tag-regs + :regs0 (gif-reg-id rgbaq) + :regs1 (gif-reg-id uv) + :regs2 (gif-reg-id xyz2) + :regs3 (gif-reg-id uv) + :regs4 (gif-reg-id xyz2) + :regs5 (gif-reg-id uv) + :regs6 (gif-reg-id xyz2) + :regs7 (gif-reg-id uv) + :regs8 (gif-reg-id xyz2) + ) + ) + ) (set! (-> gp-0 adgif-tmpl dma-vif dma) (new 'static 'dma-tag :qwc #x6 :id (dma-tag-id cnt))) (set! (-> gp-0 adgif-tmpl dma-vif vif0) (new 'static 'vif-tag)) (set! (-> gp-0 adgif-tmpl dma-vif vif1) (new 'static 'vif-tag :imm #x6 :cmd (vif-cmd direct) :msk #x1)) - (set! (-> gp-0 adgif-tmpl gif0) (the-as uint #x1000000000008005)) - (set! (-> gp-0 adgif-tmpl gif1) (the-as uint 14)) + (set! (-> gp-0 adgif-tmpl gif0) (the uint64 (new 'static 'gif-tag64 :nloop #x5 :eop #x1 :nreg #x1))) + (set! (-> gp-0 adgif-tmpl gif1) (the uint64 (new 'static 'gif-tag-regs :regs0 (gif-reg-id a+d)))) (set-vector! (-> gp-0 offset) 0.0 0.0 0.0 0.0) (set-vector! (-> gp-0 scroll) 0.0 0.0 0.0 0.0) (set-vector! (-> gp-0 pos) 0 0 0 0) diff --git a/goal_src/jak2/levels/common/elec-gate.gc b/goal_src/jak2/levels/common/elec-gate.gc index f5d02b43e..3729f9ad6 100644 --- a/goal_src/jak2/levels/common/elec-gate.gc +++ b/goal_src/jak2/levels/common/elec-gate.gc @@ -83,9 +83,9 @@ :bolt-spec (new 'static 'lightning-spec :name #f :flags (lightning-spec-flags lsf2) - :start-color #x80ffffff - :end-color #x80000000 - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -102,9 +102,9 @@ :name #f :flags (lightning-spec-flags lsf2) :rand-func #x3 - :start-color #x80ffffff - :end-color #x80ffffff - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -971,9 +971,9 @@ :bolt-spec (new 'static 'lightning-spec :name #f :flags (lightning-spec-flags lsf2) - :start-color #x80ffffff - :end-color #x80000000 - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -990,9 +990,9 @@ :name #f :flags (lightning-spec-flags lsf2) :rand-func #x3 - :start-color #x80ffffff - :end-color #x80ffffff - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 diff --git a/test/decompiler/reference/jak2/engine/ambient/ambient-h_REF.gc b/test/decompiler/reference/jak2/engine/ambient/ambient-h_REF.gc index 60ee951ba..051b68f7c 100644 --- a/test/decompiler/reference/jak2/engine/ambient/ambient-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/ambient/ambient-h_REF.gc @@ -19,9 +19,9 @@ :size-assert #x18 :flag-assert #xe00000018 (:methods - (talker-speech-class-method-9 () none 9) + (talker-speech-class-method-9 (_type_) symbol 9) (talker-speech-class-method-10 (_type_) none 10) - (talker-speech-class-method-11 () none 11) + (talker-speech-class-method-11 (_type_) none 11) (talker-speech-class-method-12 (_type_ int) none 12) (talker-speech-class-method-13 (_type_ int) none 13) ) @@ -56,22 +56,22 @@ (total-off-time time-frame :offset-assert 160) (start-time time-frame :offset-assert 168) (state-time time-frame :offset-assert 176) - (voicebox uint64 :offset-assert 184) - (voice-id uint32 :offset-assert 192) - (message-id uint32 :offset-assert 196) + (voicebox handle :offset-assert 184) + (voice-id sound-id :offset-assert 192) + (message-id sound-id :offset-assert 196) (region region :offset-assert 200) (interp float :offset-assert 204) - (save? basic :offset-assert 208) + (save? symbol :offset-assert 208) ) :heap-base #x60 :method-count-assert 18 :size-assert #xd4 :flag-assert #x12006000d4 (:methods - (talker-method-14 () _type_ :state 14) - (talker-method-15 () none 15) - (talker-method-16 () none 16) - (talker-method-17 () none 17) + (idle () _type_ :state 14) + (active () _type_ :state 15) + (exit () _type_ :state 16) + (talker-method-17 (_type_) none 17) ) ) @@ -84,7 +84,7 @@ (let ((t9-0 (method-of-type process inspect))) (t9-0 obj) ) - (format #t "~2Ttrans: ~`vector`P~%" (-> obj stack)) + (format #t "~2Ttrans: ~`vector`P~%" (-> obj trans)) (format #t "~2Tmessage: #~%" (-> obj message)) (format #t "~2Ttotal-time: ~D~%" (-> obj total-time)) (format #t "~2Ttotal-off-time: ~D~%" (-> obj total-off-time)) diff --git a/test/decompiler/reference/jak2/engine/ambient/ambient_REF.gc b/test/decompiler/reference/jak2/engine/ambient/ambient_REF.gc new file mode 100644 index 000000000..86196554c --- /dev/null +++ b/test/decompiler/reference/jak2/engine/ambient/ambient_REF.gc @@ -0,0 +1,563 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for function can-display-query? +(defun can-display-query? ((arg0 process) (arg1 string) (arg2 float)) + (let ((a1-3 (gui-control-method-12 + *gui-control* + arg0 + (gui-channel query) + (gui-action play) + (if arg1 + arg1 + (symbol->string (-> arg0 type symbol)) + ) + 0 + arg2 + (new 'static 'sound-id) + ) + ) + ) + (= (gui-control-method-17 *gui-control* a1-3) (gui-action playing)) + ) + ) + +;; definition for function talker-surpress! +;; WARN: Return type mismatch int vs none. +(defun talker-surpress! () + (set! (-> *game-info* hint-play-time) (-> *display* base-clock frame-counter)) + 0 + (none) + ) + +;; definition for function talker-displayed? +(defun talker-displayed? () + #f + ) + +;; definition for function kill-current-talker +;; WARN: Return type mismatch int vs none. +(defun kill-current-talker ((arg0 symbol) (arg1 pair) (arg2 symbol)) + (if (not (member 'daxter arg1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel daxter) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (if (not (member 'voicebox arg1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel voicebox) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (if (not (member 'message arg1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel message) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (when (not (member 'notice arg1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel notice) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel notice-low) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + 0 + (none) + ) + +;; definition for function string->talker-speech +(defun string->talker-speech ((arg0 string)) + (dotimes (s5-0 465) + (let ((s4-0 (-> *talker-speech* s5-0))) + (if (string= arg0 (-> s4-0 name)) + (return s4-0) + ) + ) + ) + (-> *talker-speech* 0) + ) + +;; definition for method 9 of type talker-speech-class +(defmethod talker-speech-class-method-9 talker-speech-class ((obj talker-speech-class)) + (and (>= (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) (-> obj pos)) + (>= (-> obj neg) (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) + ) + ) + +;; definition for method 10 of type talker-speech-class +;; WARN: Return type mismatch int vs none. +(defmethod talker-speech-class-method-10 talker-speech-class ((obj talker-speech-class)) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) (the-as uint #xffff)) + 0 + (none) + ) + +;; definition for method 11 of type talker-speech-class +;; WARN: Return type mismatch int vs none. +(defmethod talker-speech-class-method-11 talker-speech-class ((obj talker-speech-class)) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) (the-as uint 0)) + 0 + (none) + ) + +;; definition for method 12 of type talker-speech-class +;; WARN: Return type mismatch int vs none. +(defmethod talker-speech-class-method-12 talker-speech-class ((obj talker-speech-class) (arg0 int)) + (if (>= arg0 0) + (set! (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (* (-> obj speech) 2))) #xfff0 arg0)) + ) + (set! (-> *game-info* unknown-pad6 (* (-> obj speech) 2)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (* (-> obj speech) 2))) 0 (- arg0))) + ) + ) + (if (talker-speech-class-method-9 obj) + (talker-spawn-func obj *entity-pool* (target-pos 0) (the-as region #f)) + ) + 0 + (none) + ) + +;; definition for method 13 of type talker-speech-class +;; WARN: Return type mismatch int vs none. +(defmethod talker-speech-class-method-13 talker-speech-class ((obj talker-speech-class) (arg0 int)) + (if (>= arg0 0) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) #xfff0 arg0)) + ) + (set! (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1)) + (the-as uint (seekl (the-as int (-> *game-info* unknown-pad6 (+ (* (-> obj speech) 2) 1))) 0 (- arg0))) + ) + ) + 0 + (none) + ) + +;; definition for function talker-spawn-func +(defun talker-spawn-func ((arg0 talker-speech-class) (arg1 process-tree) (arg2 vector) (arg3 region)) + (local-vars (s2-0 int)) + (when (or (not arg0) (zero? (-> arg0 speech)) (not (talker-speech-class-method-9 arg0))) + (set! s2-0 0) + (goto cfg-27) + ) + (if (and (or (not (-> *setting-control* user-current play-hints)) + (= (-> *setting-control* user-current dialog-volume) 0.0) + ) + (logtest? (-> arg0 flags) 1) + ) + (talker-speech-class-method-10 arg0) + ) + (set! s2-0 (gui-control-method-14 *gui-control* (-> arg0 name) (-> arg0 channel) (gui-action none))) + (set! s2-0 (cond + ((zero? s2-0) + (let ((v1-17 (process-spawn talker :init talker-init arg0 arg2 arg3 :to arg1))) + (cond + (v1-17 + (if (nonzero? (-> (the-as talker (-> v1-17 0)) voice-id)) + (the-as int (-> (the-as talker (-> v1-17 0)) voice-id)) + (the-as int (-> (the-as talker (-> v1-17 0)) message-id)) + ) + ) + (else + (empty) + s2-0 + ) + ) + ) + ) + (else + (empty) + s2-0 + ) + ) + ) + (label cfg-27) + s2-0 + ) + +;; definition for function talker-init +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defbehavior talker-init talker ((arg0 talker-speech-class) (arg1 vector) (arg2 region)) + (set! (-> self trans quad) (-> arg1 quad)) + (let ((v1-2 (shr (the-as int (-> arg0 channel)) 4))) + (if (not (or (or (= v1-2 4) (= v1-2 5)) + (or (not (-> *setting-control* user-current play-hints)) + (= (-> *setting-control* user-current dialog-volume) 0.0) + ) + ) + ) + (set! (-> self voice-id) + (gui-control-method-9 *gui-control* self (-> arg0 channel) (gui-action queue) (-> arg0 name) 81920.0 0) + ) + ) + ) + (when (nonzero? (-> arg0 text-message)) + (let* ((a0-6 *gui-control*) + (t9-1 (method-of-object a0-6 gui-control-method-9)) + (a1-3 self) + (v1-15 (shr (the-as int (-> arg0 channel)) 4)) + ) + (set! (-> self message-id) (t9-1 + a0-6 + a1-3 + (if (or (= v1-15 4) (= v1-15 5)) + (the-as gui-channel (the-as int (-> arg0 channel))) + (gui-channel message) + ) + (gui-action play) + (-> arg0 name) + 81920.0 + 0 + ) + ) + ) + ) + (set! (-> self message) arg0) + (set! (-> self region) arg2) + (set! (-> self total-time) 0) + (set! (-> self total-off-time) 0) + (set! (-> self start-time) (-> self clock frame-counter)) + (set! (-> self voicebox) (the-as handle #f)) + (set! (-> self save?) #f) + (if (logtest? (-> self message flags) 96) + (set! (-> self interp) 0.0) + (set! (-> self interp) 1.0) + ) + (go-virtual idle) + 0 + (none) + ) + +;; definition for method 10 of type talker +(defmethod deactivate talker ((obj talker)) + (send-event (handle->process (-> obj voicebox)) 'die) + ((the-as (function process none) (find-parent-method talker 10)) obj) + (none) + ) + +;; definition for method 17 of type talker +;; WARN: Return type mismatch int vs none. +(defmethod talker-method-17 talker ((obj talker)) + (let ((gp-0 (new + 'stack + 'font-context + *font-default-matrix* + 36 + 310 + 0.0 + (font-color default-#cddbcd) + (font-flags shadow kerning) + ) + ) + ) + (let ((f0-0 320.0)) + (let ((v1-2 gp-0)) + (set! (-> v1-2 scale) 0.75) + ) + (case (-> obj message channel) + (((gui-channel notice)) + (cond + ((logtest? (-> obj message flags) 128) + (let ((v1-9 gp-0) + (a1-1 36) + (a0-4 140) + ) + (set! (-> v1-9 origin x) (the float a1-1)) + (set! (-> v1-9 origin y) (the float a0-4)) + ) + ) + (else + (let ((v1-10 gp-0)) + (set! (-> v1-10 scale) 0.6) + ) + (let ((v1-11 gp-0) + (a1-2 36) + (a0-6 160) + ) + (set! (-> v1-11 origin x) (the float a1-2)) + (set! (-> v1-11 origin y) (the float a0-6)) + ) + ) + ) + (set! f0-0 160.0) + ) + ) + (let ((v1-14 gp-0)) + (set! (-> v1-14 width) (the float (the-as float #x1b8))) + ) + (let ((v1-15 gp-0)) + (set! (-> v1-15 height) (the float (the-as float #x8c))) + ) + (set! (-> gp-0 flags) (font-flags shadow kerning middle large)) + (if (logtest? (-> obj message flags) 32) + (set! (-> gp-0 alpha) (-> obj interp)) + (set! (-> gp-0 alpha) 1.0) + ) + (when (logtest? (-> obj message flags) 64) + (let ((s4-0 gp-0) + (s3-0 36) + (v1-27 (the int (lerp-scale 400.0 f0-0 (-> obj interp) 0.0 1.0))) + ) + (set! (-> s4-0 origin x) (the float s3-0)) + (set! (-> s4-0 origin y) (the float v1-27)) + ) + ) + ) + (let ((s4-1 print-game-text) + (a0-11 (lookup-text! *common-text* (the-as game-text-id (-> obj message text-message)) #f)) + (a2-3 #f) + (a3-2 44) + (v1-31 (-> obj message channel)) + ) + (s4-1 + a0-11 + gp-0 + a2-3 + a3-2 + (if (or (= v1-31 (gui-channel notice)) (= v1-31 (gui-channel notice-low)) (= v1-31 (gui-channel subtitle))) + 322 + 320 + ) + ) + ) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate idle (talker) + :virtual #t + :code (behavior () + (let ((gp-0 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-0) (the-as time-frame (-> self message delay))) + (suspend) + ) + ) + (case (-> self message channel) + (((gui-channel voicebox)) + (if *target* + (set! (-> self voicebox) (ppointer->handle (voicebox-spawn *target* (target-pos 0)))) + ) + ) + ) + (while (< (- (-> self clock frame-counter) (-> self start-time)) (the-as time-frame (+ (-> self message delay) 300))) + (if (and (or (zero? (-> self voice-id)) (= (gui-control-method-17 *gui-control* (-> self voice-id)) (gui-action play))) + (or (zero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + ) + ) + (go-virtual active) + ) + (suspend) + ) + (go-virtual exit) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate active (talker) + :virtual #t + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (if (logtest? (-> self message flags) 1) + (talker-speech-class-method-10 (-> self message)) + ) + (set-setting! 'hint (process->ppointer self) 0 0) + (set-setting! 'speech-control #f 0 0) + (if (nonzero? (-> self voice-id)) + (gui-control-method-16 + *gui-control* + (gui-action play) + (-> self voice-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (when (and (nonzero? (-> self voice-id)) (logtest? (-> self message flags) 2)) + (add-setting! 'music-volume 'rel (-> *setting-control* user-current music-volume-movie) 0) + (add-setting! 'sfx-volume 'rel (-> *setting-control* user-current sfx-movie-volume) 0) + (add-setting! 'dialog-volume 'rel (-> *setting-control* user-current dialog-volume-hint) 0) + ) + (if (logtest? (-> self message flags) 4) + (auto-save-user) + ) + (apply-settings *setting-control*) + (none) + ) + :exit (behavior () + (let ((gp-0 (-> self message on-close))) + (when gp-0 + (let* ((s5-0 (handle->process (-> self voicebox))) + (v1-5 (if (type? s5-0 process-drawable) + (the-as process-drawable s5-0) + ) + ) + ) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (if v1-5 + (-> v1-5 root trans) + ) + ) + (the-as pair gp-0) + ) + ) + ) + ) + (when (and (logtest? (-> self message flags) 8) (not (-> self save?))) + (set! (-> self save?) #t) + (auto-save-user) + ) + (if (nonzero? (-> self voice-id)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> self voice-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (if (nonzero? (-> self message-id)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> self message-id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (remove-setting! 'music-volume) + (remove-setting! 'sfx-volume) + (remove-setting! 'dialog-volume) + (remove-setting! 'hint) + (remove-setting! 'speech-control) + (apply-settings *setting-control*) + (none) + ) + :code (behavior () + (local-vars (v1-43 symbol)) + (let ((gp-1 (zero? (logand (-> self message flags) 2)))) + (while (or (and (nonzero? (-> self voice-id)) + (let ((v1-34 (gui-control-method-17 *gui-control* (-> self voice-id)))) + (or (= v1-34 (gui-action play)) (= v1-34 (gui-action playing))) + ) + (begin + (dotimes (s5-2 4) + (when (and (string-charp= (-> self message name) (the-as (pointer uint8) (-> *sound-iop-info* stream-name s5-2))) + (= (-> self voice-id) (-> *sound-iop-info* stream-id s5-2)) + (logtest? (-> *sound-iop-info* stream-status s5-2) (stream-status ststatus-six)) + ) + (set! v1-43 #f) + (goto cfg-39) + ) + ) + (set! v1-43 #t) + (label cfg-39) + (and v1-43 (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 120))) + ) + ) + (and (nonzero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + (or (< (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self message text-duration))) + (and (logtest? (-> self message flags) 16) (-> self region) (region-method-9 (-> self region) (target-pos 0))) + ) + ) + (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.05)) + ) + (when (and (nonzero? (-> self voice-id)) + (not gp-1) + (zero? (gui-control-method-17 *gui-control* (-> self voice-id))) + ) + (remove-setting! 'music-volume) + (remove-setting! 'sfx-volume) + (remove-setting! 'dialog-volume) + (set! gp-1 #t) + ) + (when (and (nonzero? (-> self message-id)) + (= (gui-control-method-17 *gui-control* (-> self message-id)) (gui-action playing)) + (not (paused?)) + ) + (if (logtest? (-> self message flags) 32) + (seek! (-> self interp) 1.0 (* 0.5 (-> self clock seconds-per-frame))) + (seek! (-> self interp) 1.0 (* 4.0 (-> self clock seconds-per-frame))) + ) + (talker-method-17 self) + ) + (suspend) + ) + ) + (when (and (nonzero? (-> self message-id)) (logtest? (-> self message flags) 96)) + (while (!= (-> self interp) 0.0) + (if (logtest? (-> self message flags) 32) + (seek! (-> self interp) 0.0 (* 0.5 (-> self clock seconds-per-frame))) + (seek! (-> self interp) 0.0 (* 4.0 (-> self clock seconds-per-frame))) + ) + (talker-method-17 self) + (suspend) + ) + ) + (when (and (logtest? (-> self message flags) 8) (not (-> self save?))) + (let ((gp-2 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-2) (seconds 1)) + (suspend) + ) + ) + (set! (-> self save?) #t) + (auto-save-user) + ) + (go-virtual exit) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate exit (talker) + :virtual #t + :code (the-as (function none :behavior talker) nothing) + ) diff --git a/test/decompiler/reference/jak2/engine/gfx/generic/generic-vu1-h_REF.gc b/test/decompiler/reference/jak2/engine/gfx/generic/generic-vu1-h_REF.gc index 2d271bc63..760031e79 100644 --- a/test/decompiler/reference/jak2/engine/gfx/generic/generic-vu1-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/generic/generic-vu1-h_REF.gc @@ -144,7 +144,7 @@ (deftype gcf-control (structure) ((matrix matrix :inline :offset-assert 0) (giftag generic-gif-tag :inline :offset-assert 64) - (adnops uint32 2 :offset-assert 80) + (adnops gs-adcmd 2 :inline :offset-assert 80) (num-strips uint32 :offset 76) (num-dps uint32 :offset 92) (kick-offset uint32 :offset 108) diff --git a/test/decompiler/reference/jak2/engine/gfx/lightning-h_REF.gc b/test/decompiler/reference/jak2/engine/gfx/lightning-h_REF.gc index 4fa37dc63..fba3095fe 100644 --- a/test/decompiler/reference/jak2/engine/gfx/lightning-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/lightning-h_REF.gc @@ -7,9 +7,9 @@ (flags lightning-spec-flags :offset-assert 8) (rand-func uint8 :offset-assert 10) (adjust-distance uint8 :offset-assert 11) - (start-color uint32 :offset-assert 12) - (end-color uint32 :offset-assert 16) - (fade-to-color uint32 :offset-assert 20) + (start-color rgba :offset-assert 12) + (end-color rgba :offset-assert 16) + (fade-to-color rgba :offset-assert 20) (fade-start-factor float :offset-assert 24) (fade-time float :offset-assert 28) (texture uint32 :offset-assert 32) @@ -88,8 +88,8 @@ (line vector-array :offset-assert 128) (meet vector-array :offset-assert 132) (path vector-array :offset-assert 136) - (start-color uint32 :offset-assert 140) - (end-color uint32 :offset-assert 144) + (start-color rgba :offset-assert 140) + (end-color rgba :offset-assert 144) ) :method-count-assert 9 :size-assert #x94 @@ -119,9 +119,9 @@ ;; definition of type lightning-control (deftype lightning-control (basic) - ((spec lightning-spec :offset-assert 4) - (process process :offset-assert 8) - (state lightning-state :inline :offset-assert 16) + ((spec lightning-spec :offset-assert 4) + (process (pointer process) :offset-assert 8) + (state lightning-state :inline :offset-assert 16) ) :method-count-assert 14 :size-assert #xa4 @@ -252,7 +252,7 @@ ) (set! (-> obj state box-size) f0-0) ) - (set! (-> obj process) (the-as process (process->ppointer arg1))) + (set! (-> obj process) (process->ppointer arg1)) (set! (-> obj state mode) (lightning-mode lm1)) (set! (-> obj state line) ((method-of-type vector-array new) allocation vector-array s3-0)) (set! (-> obj state meet) ((method-of-type vector-array new) allocation vector-array s3-0)) diff --git a/test/decompiler/reference/jak2/engine/math/matrix_REF.gc b/test/decompiler/reference/jak2/engine/math/matrix_REF.gc index 046a82a64..ed393ec69 100644 --- a/test/decompiler/reference/jak2/engine/math/matrix_REF.gc +++ b/test/decompiler/reference/jak2/engine/math/matrix_REF.gc @@ -776,6 +776,7 @@ ;; ERROR: Unsupported inline assembly instruction kind - [prot3w a1, v1] ;; ERROR: Unsupported inline assembly instruction kind - [prot3w a2, a1] (defun matrix-axis-sin-cos-vu! ((arg0 matrix) (arg1 vector) (arg2 float) (arg3 float)) + "@unused" (local-vars (a1-2 uint128) (a2-1 uint128) (a3-1 uint128) (a3-2 uint128)) (rlet ((vf0 :class vf) (vf1 :class vf) diff --git a/test/decompiler/reference/jak2/engine/sound/speech-h_REF.gc b/test/decompiler/reference/jak2/engine/sound/speech-h_REF.gc index 25541d143..824b2791f 100644 --- a/test/decompiler/reference/jak2/engine/sound/speech-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/sound/speech-h_REF.gc @@ -46,10 +46,10 @@ ;; definition of type speech-request (deftype speech-request (structure) - ((handle uint64 :offset-assert 0) - (time time-frame :offset-assert 8) - (priority float :offset-assert 16) - (speech-type int8 :offset-assert 20) + ((handle handle :offset-assert 0) + (time time-frame :offset-assert 8) + (priority float :offset-assert 16) + (speech-type speech-type :offset-assert 20) ) :pack-me :method-count-assert 9 @@ -74,27 +74,27 @@ ;; definition of type speech-channel (deftype speech-channel (structure) - ((flags speech-channel-flag :offset-assert 0) - (gui-channel gui-channel :offset-assert 1) - (delay uint16 :offset-assert 2) - (id uint32 :offset-assert 4) - (update-time time-frame :offset-assert 8) - (start-time time-frame :offset-assert 16) - (end-time time-frame :offset-assert 24) - (request speech-request :inline :offset-assert 32) - (last-request speech-request :inline :offset-assert 56) - (target-pos vector :inline :offset-assert 80) - (speech-table uint32 :offset-assert 96) + ((flags speech-channel-flag :offset-assert 0) + (gui-channel gui-channel :offset-assert 1) + (delay uint16 :offset-assert 2) + (id sound-id :offset-assert 4) + (update-time time-frame :offset-assert 8) + (start-time time-frame :offset-assert 16) + (end-time time-frame :offset-assert 24) + (request speech-request :inline :offset-assert 32) + (last-request speech-request :inline :offset-assert 56) + (target-pos vector :inline :offset-assert 80) + (speech-table (pointer speech-type-info) :offset-assert 96) ) :method-count-assert 14 :size-assert #x64 :flag-assert #xe00000064 (:methods - (speech-channel-method-9 () none 9) - (speech-channel-method-10 () none 10) - (speech-channel-method-11 () none 11) - (speech-channel-method-12 () none 12) - (speech-channel-method-13 () none 13) + (speech-channel-method-9 (_type_ process-drawable speech-type) none 9) + (speech-channel-method-10 (_type_ handle) none 10) + (speech-channel-method-11 (_type_) none 11) + (speech-channel-method-12 (_type_) none 12) + (speech-channel-method-13 (_type_) none 13) ) ) @@ -135,14 +135,14 @@ :size-assert #x1c4 :flag-assert #x11000001c4 (:methods - (speech-control-method-9 () none 9) + (speech-control-method-9 (_type_) none 9) (speech-control-method-10 (_type_ int speech-type-info) none 10) (speech-control-method-11 (_type_) none 11) - (speech-control-method-12 () none 12) - (speech-control-method-13 () none 13) - (speech-control-method-14 () none 14) - (speech-control-method-15 () none 15) - (speech-control-method-16 () none 16) + (speech-control-method-12 (_type_ process-drawable speech-type) none 12) + (speech-control-method-13 (_type_ handle) none 13) + (speech-control-method-14 (_type_) none 14) + (speech-control-method-15 (_type_ process-drawable) none 15) + (speech-control-method-16 (_type_) none 16) ) ) diff --git a/test/decompiler/reference/jak2/engine/sound/speech_REF.gc b/test/decompiler/reference/jak2/engine/sound/speech_REF.gc new file mode 100644 index 000000000..f61699f9e --- /dev/null +++ b/test/decompiler/reference/jak2/engine/sound/speech_REF.gc @@ -0,0 +1,521 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for method 12 of type speech-channel +;; WARN: Return type mismatch int vs none. +(defmethod speech-channel-method-12 speech-channel ((obj speech-channel)) + (set! (-> obj request handle) (the-as handle #f)) + (set! (-> obj request priority) -10000000000000000000000000000000000000.0) + 0 + (none) + ) + +;; definition for method 13 of type speech-channel +;; WARN: Return type mismatch int vs none. +(defmethod speech-channel-method-13 speech-channel ((obj speech-channel)) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + (set! (-> obj last-request priority) -10000000000000000000000000000000000000.0) + 0 + (none) + ) + +;; definition for method 11 of type speech-channel +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod speech-channel-method-11 speech-channel ((obj speech-channel)) + (local-vars (v1-44 int)) + (with-pp + (logclear! (-> obj flags) (speech-channel-flag disable)) + (if (or (not (-> *setting-control* user-current speech-control)) + (load-in-progress? *level*) + (nonzero? (-> obj id)) + ) + (logior! (-> obj flags) (speech-channel-flag disable)) + ) + (set! (-> obj target-pos quad) (-> (target-pos 0) quad)) + (when (not (logtest? (-> obj flags) (speech-channel-flag disable))) + (let ((s5-1 (-> obj speech-table (-> obj request speech-type)))) + (cond + (s5-1 + (let ((a0-8 (- (-> obj update-time) (-> obj request time))) + (v1-20 (handle->process (-> obj request handle))) + ) + (if (or (< (the-as time-frame (-> s5-1 request-timeout)) a0-8) + (or (not v1-20) + (let ((f0-0 245760.0)) + (< (* f0-0 f0-0) + (vector-vector-distance-squared (-> obj target-pos) (-> (the-as process-drawable v1-20) root trans)) + ) + ) + ) + ) + (speech-channel-method-12 obj) + ) + ) + (let ((s4-0 (handle->process (-> obj request handle)))) + (when s4-0 + (when (or (and (>= (-> obj request priority) 0.0) + (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> s5-1 delay))) + ) + (and (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> s5-1 delay))) + (>= (- (-> pp clock frame-counter) (-> obj end-time)) (the-as time-frame (-> obj delay))) + ) + ) + (let ((s3-0 (-> s5-1 list length)) + (v1-43 (-> s5-1 play-index)) + ) + (when (> s3-0 0) + (cond + ((logtest? (-> s5-1 flags) (speech-type-flag random-order)) + (set! v1-44 (rand-vu-int-count s3-0)) + (when (= v1-44 (-> s5-1 play-index)) + (+! v1-44 1) + (if (>= v1-44 s3-0) + (set! v1-44 0) + ) + ) + ) + (else + (set! v1-44 (+ v1-43 1)) + (if (>= v1-44 s3-0) + (set! v1-44 0) + ) + ) + ) + (set! (-> s5-1 play-index) v1-44) + (let ((s3-1 (-> s5-1 list v1-44))) + (mem-copy! (the-as pointer (-> obj last-request)) (the-as pointer (-> obj request)) 21) + (set! (-> obj start-time) (-> pp clock frame-counter)) + (set! (-> obj delay) + (the-as uint (rand-vu-int-range (the-as int (-> s5-1 min-delay)) (the-as int (-> s5-1 max-delay)))) + ) + (set! (-> s5-1 delay) (-> obj delay)) + (set! (-> obj id) + (gui-control-method-9 *gui-control* s4-0 (-> obj gui-channel) (gui-action play) s3-1 -99.0 0) + ) + ) + (speech-channel-method-12 obj) + (logior! (-> obj flags) (speech-channel-flag disable)) + ) + ) + ) + ) + ) + ) + (else + (speech-channel-method-12 obj) + ) + ) + ) + ) + (set! (-> obj update-time) (-> pp clock frame-counter)) + (when (nonzero? (-> obj id)) + (let ((s4-1 (handle->process (-> obj last-request handle)))) + (cond + ((and s4-1 (-> *setting-control* user-current speech-control)) + (when *sound-player-enable* + (let ((s5-2 (the-as sound-rpc-set-param (get-sound-buffer-entry)))) + (set! (-> s5-2 command) (sound-command set-param)) + (set! (-> s5-2 id) (-> obj id)) + (set! (-> s5-2 params fo-min) 15) + (set! (-> s5-2 params fo-max) 90) + (set! (-> s5-2 params fo-curve) 9) + (let ((a1-12 (-> (the-as process-drawable s4-1) root trans))) + (let ((s4-2 pp)) + (when (= a1-12 #t) + (if (and s4-2 (type? s4-2 process-drawable) (nonzero? (-> (the-as process-drawable s4-2) root))) + (set! a1-12 (-> (the-as process-drawable s4-2) root trans)) + (set! a1-12 (the-as vector #f)) + ) + ) + ) + (sound-trans-convert (the-as vector3w (-> s5-2 params trans)) a1-12) + ) + (set! (-> s5-2 params mask) (the-as uint 480)) + (-> s5-2 id) + ) + ) + ) + (else + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + 0 + ) + ) + ) + (case (gui-control-method-17 *gui-control* (-> obj id)) + (((gui-action queue)) + (when (>= (- (-> pp clock frame-counter) (-> obj start-time)) (seconds 1)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj end-time) (-> obj update-time)) + ) + ) + (((gui-action none)) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + (set! (-> obj end-time) (-> obj update-time)) + ) + ) + ) + 0 + (none) + ) + ) + +;; definition for method 9 of type speech-channel +;; WARN: Return type mismatch int vs none. +(defmethod speech-channel-method-9 speech-channel ((obj speech-channel) (arg0 process-drawable) (arg1 speech-type)) + (with-pp + (let ((f0-0 (vector-vector-distance-squared (-> arg0 root trans) (-> obj target-pos))) + (f1-0 245760.0) + ) + (when (< f0-0 (* f1-0 f1-0)) + (let* ((f1-3 -1.0) + (f2-0 409600.0) + (f0-2 (+ (* f0-0 (/ f1-3 (* f2-0 f2-0))) (the float (-> obj speech-table arg1 priority)))) + ) + (when (< (-> obj request priority) f0-2) + (set! (-> obj request priority) f0-2) + (set! (-> obj request handle) (process->handle arg0)) + (set! (-> obj request speech-type) arg1) + (set! (-> obj request time) (-> pp clock frame-counter)) + ) + ) + ) + ) + 0 + (none) + ) + ) + +;; definition for method 10 of type speech-channel +;; WARN: Return type mismatch int vs none. +(defmethod speech-channel-method-10 speech-channel ((obj speech-channel) (arg0 handle)) + (when (= arg0 (handle->process (-> obj last-request handle))) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (-> obj id) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> obj id) (new 'static 'sound-id)) + (set! (-> obj last-request handle) (the-as handle #f)) + ) + 0 + (none) + ) + +;; definition for method 12 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-12 speech-control ((obj speech-control) (arg0 process-drawable) (arg1 speech-type)) + (let ((v1-2 (-> obj speech-table arg1))) + (when v1-2 + (let ((a0-1 (-> obj channel-array (-> v1-2 channel)))) + (if (not (logtest? (-> a0-1 flags) (speech-channel-flag disable))) + (speech-channel-method-9 a0-1 arg0 arg1) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 11 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-11 speech-control ((obj speech-control)) + (dotimes (s5-0 2) + (speech-channel-method-11 (-> obj channel-array s5-0)) + ) + 0 + (none) + ) + +;; definition for method 10 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-10 speech-control ((obj speech-control) (arg0 int) (arg1 speech-type-info)) + (set! (-> obj speech-table arg0) arg1) + 0 + (none) + ) + +;; definition for method 13 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-13 speech-control ((obj speech-control) (arg0 handle)) + (dotimes (s4-0 2) + (speech-channel-method-10 (-> obj channel-array s4-0) arg0) + ) + 0 + (none) + ) + +;; definition for method 14 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-14 speech-control ((obj speech-control)) + (speech-control-method-9 obj) + (let ((s5-0 (-> obj channel-array))) + ((method-of-type speech-channel speech-channel-method-13) (the-as speech-channel s5-0)) + (set! (-> s5-0 0 speech-table) (-> obj speech-table)) + (set! (-> s5-0 0 gui-channel) (gui-channel guard)) + ) + (let ((s5-1 (-> obj channel-array 1))) + (speech-channel-method-13 s5-1) + (set! (-> s5-1 speech-table) (-> obj speech-table)) + (set! (-> s5-1 gui-channel) (gui-channel citizen)) + ) + 0 + (none) + ) + +;; definition for method 15 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-15 speech-control ((obj speech-control) (arg0 process-drawable)) + (when (not (logtest? (-> obj channel-array 0 flags) (speech-channel-flag disable))) + (let ((v1-3 *target*)) + (when v1-3 + (cond + ((logtest? (focus-status dark) (-> v1-3 focus-status)) + (speech-control-method-12 obj arg0 (speech-type speech-type-3)) + ) + ((logtest? (focus-status pilot) (-> v1-3 focus-status)) + (speech-control-method-12 obj arg0 (speech-type speech-type-0 speech-type-1 speech-type-2)) + ) + (else + (speech-control-method-12 obj arg0 (speech-type speech-type-1 speech-type-2)) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 16 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-16 speech-control ((obj speech-control)) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel guard) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (gui-control-method-16 + *gui-control* + (gui-action stop) + (the-as sound-id 1) + (gui-channel citizen) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (dotimes (s5-0 2) + (speech-channel-method-12 (-> obj channel-array s5-0)) + ) + 0 + (none) + ) + +;; definition for method 9 of type speech-control +;; WARN: Return type mismatch int vs none. +(defmethod speech-control-method-9 speech-control ((obj speech-control)) + (dotimes (v1-0 57) + (set! (-> obj speech-table v1-0) #f) + ) + (dotimes (s5-0 2) + (speech-channel-method-12 (-> obj channel-array s5-0)) + ) + (speech-control-method-10 obj 0 (new 'static 'speech-type-info + :priority 3 + :request-timeout #x12c + :min-delay #x12c + :max-delay #x12c + :list (new 'static 'boxed-array :type string) + ) + ) + (speech-control-method-10 obj 3 (new 'static 'speech-type-info + :priority 3 + :request-timeout #x12c + :min-delay #x12c + :max-delay #x12c + :list (new 'static 'boxed-array :type string + "kg136" + "kg139" + "kg140" + "kg141" + "kg142" + "kg134" + "kg157" + "kg143" + "kg156" + "kg176" + "kg177" + "kg536" + "kg551" + ) + ) + ) + (speech-control-method-10 obj 9 (new 'static 'speech-type-info + :priority 1 + :min-delay #x258 + :max-delay #x4b0 + :list (new 'static 'boxed-array :type string + "kg133" + "kg135" + "kg137" + "kg138" + "kg144" + "kg145" + "kg146" + "kg147" + "kg148" + "kg149" + "kg150" + "kg151" + "kg152" + "kg153" + "kg154" + "kg155" + "kg158" + "kg159" + "kg160" + "kg163" + "kg164" + "kg507" + "kg508" + "kg509" + "kg511" + "kg513" + "kg514" + "kg515" + "kg516" + "kg517" + "kg518" + "kg520" + "kg521" + "kg523" + "kg526" + "kg527" + "kg528" + "kg529" + "kg530" + "kg532" + "kg534" + "kg535" + "kg537" + "kg538" + "kg539" + "kg540" + "kg541" + "kg542" + "kg543" + "kg544" + "kg545" + "kg546" + "kg549" + "kg550" + ) + ) + ) + (speech-control-method-10 obj 10 (new 'static 'speech-type-info + :flags (speech-type-flag random-order) + :priority #xa + :request-timeout #x258 + :min-delay #x258 + :max-delay #x4b0 + :list (new 'static 'boxed-array :type string + "kg165" + "kg165a" + "kg165b" + "kg166" + "kg166a" + "kg166b" + "kg167" + "kg167a" + "kg167b" + "kg168" + "kg168a" + "kg168b" + "kg169" + "kg169a" + "kg169b" + "kg170" + "kg170a" + "kg170b" + "kg171" + "kg171a" + "kg171b" + "kg172" + "kg172a" + "kg172b" + "kg173" + "kg173a" + "kg173b" + "kg174" + "kg174a" + "kg174b" + "kg175" + "kg175a" + "kg175b" + "kg510" + ) + ) + ) + (speech-control-method-10 obj 11 (new 'static 'speech-type-info + :priority 2 + :min-delay #x1e + :max-delay #x1e + :list (new 'static 'boxed-array :type string + "kg386a" + "kg428a" + "kg641" + "kg650" + "kg338a" + "kg339a" + "kg340a" + "kg341a" + "kg342a" + "kg343a" + "kg344a" + "kg512" + ) + ) + ) + 0 + (none) + ) + +;; definition for symbol *speech-control*, type speech-control +(define *speech-control* (new 'static 'speech-control)) + +;; failed to figure out what this is: +(speech-control-method-14 *speech-control*) diff --git a/test/decompiler/reference/jak2/engine/target/target-darkjak_REF.gc b/test/decompiler/reference/jak2/engine/target/target-darkjak_REF.gc index e3f6767f4..7ecefc282 100644 --- a/test/decompiler/reference/jak2/engine/target/target-darkjak_REF.gc +++ b/test/decompiler/reference/jak2/engine/target/target-darkjak_REF.gc @@ -1515,9 +1515,9 @@ :name "lightning-darkjak-bomb1" :flags (lightning-spec-flags lsf0 size-from-adjust-dist) :adjust-distance #xa - :start-color #x80ffffff - :end-color #x80ffffff - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :texture #xc08400 :reduction 0.42 diff --git a/test/decompiler/reference/jak2/engine/ui/bigmap-data_REF.gc b/test/decompiler/reference/jak2/engine/ui/bigmap-data_REF.gc new file mode 100644 index 000000000..d10f3d6d7 --- /dev/null +++ b/test/decompiler/reference/jak2/engine/ui/bigmap-data_REF.gc @@ -0,0 +1,15399 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *bigmap-compressed-layers*, type bigmap-compressed-layers +(define *bigmap-compressed-layers* (new 'static 'bigmap-compressed-layers + :layer0 (new 'static 'array uint32 600 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4003e00 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #x4007a77 + #xff007a77 + #xff440204 + #xff007a40 + #xff440204 + #xfb007a40 + #x54554404 + #xfb007a40 + #x54554504 + #xfb007a40 + #x54555505 + #xff007640 + #xfe550505 + #x764054 + #x550505ff + #x7650ff + #x51501fe + #x7350ff55 + #x7707fb00 + #x5157177 + #x7350ff55 + #x7707fb00 + #x5157177 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x204ff00 + #x641ff44 + #x7250ff55 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x7a440304 + #x304ff00 + #xff007a44 + #x4440304 + #x7470ff77 + #x304ff00 + #xff770444 + #xff007470 + #xff440204 + #xff770447 + #xff007470 + #x5440204 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x6007770 + #x7770ff77 + #xff770600 + #x3007770 + #x1711fc77 + #x777077 + #x11fc7703 + #x77707717 + #xfc770300 + #x70771711 + #x77030077 + #x771711fc + #xfe007b70 + #x7d1011 + #x7d1011fe + #x1011fe00 + #x44fd007c + #x44021411 + #x7840ff + #x141144fd + #x40ff4402 + #x44fd0078 + #x44021411 + #x7840ff + #x40ff4405 + #x44050078 + #x7840ff + #x40ff4405 + #x44050078 + #x7840ff + #x40ff4405 + #x41f90078 + #x44141111 + #x784044 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x7b101111 + #x1101fc00 + #x7b1011 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x7b101111 + #x1101fc00 + #x7b1011 + #x111101fc + #xfc007b10 + #x10111101 + #x1fc007b + #x73101111 + #x73550b00 + #x73550b00 + #x73550b00 + #x73550b00 + #xfd550800 + #x73455444 + #xfd550800 + #x73455444 + #x2550800 + #x8007366 + #x2660255 + #x204ff00 + #x7077fe44 + #x5508006a + #x77026602 + #x440274ff + #x57677fe + #x8006466 + #x2660255 + #x274ff77 + #x7677fe44 + #x646605 + #x66025508 + #x74ff7702 + #x77fe4402 + #x64660576 + #x2550800 + #xff770266 + #xfe440274 + #x66057677 + #x55040064 + #x15fe1101 + #x2660255 + #x274ff77 + #x7677fe44 + #x646605 + #x11015504 + #x66025501 + #x74ff7702 + #x77fe4402 + #x64660576 + #xfc550400 + #x55551511 + #x77026602 + #x440274ff + #x57677fe + #x4006466 + #x1511fc55 + #x66025555 + #x74ff7702 + #x66074402 + #x55040064 + #x551511fc + #x1660355 + #x274ff77 + #x64660744 + #x4550800 + #x7477fe66 + #x66074402 + #x55060064 + #x67fe6606 + #x7440274 + #x4006466 + #x3653fe55 + #x44026608 + #x64ff6606 + #x624403 + #x330203ff + #x660836ff + #x66064402 + #x440364ff + #x3ff0062 + #x36ff3302 + #x64fd6608 + #x66064644 + #x624404 + #x330203ff + #x660936ff + #x64644fe + #x62440466 + #x203ff00 + #x7637fe33 + #x44ff6608 + #x44046607 + #x3ff0062 + #x77013302 + #x65fe6608 + #x4660656 + #xfc006244 + #x37333303 + #x66077702 + #x56ff5501 + #x44016605 + #x447477fd + #x4ff005b + #x77044408 + #x55036605 + #x660556ff + #x70ff7702 + #x4ff005b + #x77044408 + #x776676fb + #x55056666 + #x660456ff + #x70ff7702 + #x4ff005b + #x77054408 + #x777767fd + #x56ff5507 + #x77026603 + #x5b70ff + #x440804ff + #x75ff7707 + #x66035508 + #x70ff7702 + #x4ff005b + #x67ff4408 + #x99017703 + #xc7577fe + #xff770255 + #xff005b70 + #xfe440704 + #x77036646 + #x77fe9901 + #x2550c75 + #x5b70ff77 + #x704ff00 + #x6646fd44 + #x1770266 + #xc330199 + #xff770255 + #xff005b70 + #xf6440704 + #x63666646 + #x99997777 + #x550c3333 + #x70ff7702 + #x4ff005b + #x45fb4407 + #x33336666 + #x33017702 + #x550a1101 + #x70ff7702 + #x4ff005b + #x55fb4407 + #x37333356 + #x33017702 + #x550a1101 + #x70ff7702 + #x4ff005b + #x45fa4406 + #x33335555 + #x1220432 + #x3550a11 + #x5a30ff33 + #x504ff00 + #xfc660144 + #x33335365 + #x11012205 + #x3303550a + #x5a30ff + #x440404ff + #x660256ff + #x333363fd + #x550c2205 + #x30ff3303 + #x4ff005a + #x45fe4403 + #xfd660256 + #x5333363 + #x3550c22 + #x5a30ff33 + #x304ff00 + #x2550144 + #x3363fd66 + #xc220533 + #xff330355 + #xf8005a30 + #x74777707 + #x54555544 + #x550c440a + #x30ff3303 + #x7ff005a + #x75fc7702 + #x6545555 + #x2422fc44 + #x550c4444 + #x330253ff + #x5a30ff + #x770207ff + #x555575fc + #xfc440654 + #x44442422 + #x75ff7705 + #x53ff5505 + #x30ff3302 + #x7ff005a + #x55027702 + #x440654ff + #x442422fc + #xff770544 + #xff550575 + #xff330253 + #x4005730 + #x7737fe33 + #x54ff5502 + #x7706440a + #x53ff5505 + #x30ff3302 + #x33050057 + #x660236ff + #x440a64ff + #x55057706 + #x5b50ff + #x36ff3305 + #x64ff6602 + #x7706440a + #x550475ff + #x5a7077fe + #xff330500 + #xff660236 + #x6440a64 + #x375ff77 + #x7757fd55 + #x5005a70 + #x236ff33 + #xa64ff66 + #x3770744 + #xff770155 + #x5005a70 + #x236ff33 + #xa64ff66 + #x2770844 + #x5b770155 + #xff330500 + #xff660236 + #x8440a64 + #x5575fb77 + #x5b777757 + #xff330500 + #xff660236 + #x9440a64 + #x275ff77 + #x5005b77 + #x236ff33 + #xa64ff66 + #x5b770d44 + #xff330500 + #xff660236 + #xd440a64 + #x5005b77 + #x232ff33 + #xa24ff22 + #xff770c44 + #x5005b70 + #x232ff33 + #xa24ff22 + #x5c770c44 + #xff330500 + #xff220232 + #xc440a24 + #x5005c77 + #x232ff33 + #xa24ff22 + #xff660644 + #xff770367 + #xff660476 + #x5005660 + #x232ff33 + #xa24ff22 + #x6566fd44 + #xfd660556 + #x5674644 + #x5660ff66 + #xff330500 + #xff220232 + #xfd440a24 + #x5566566 + #x4644fe66 + #x60ff6606 + #x33050056 + #x220232ff + #x440a24ff + #x44fe6608 + #xff660646 + #x5005660 + #x232ff33 + #xa24ff22 + #xfe660844 + #x66064644 + #x5660ff + #x32ff3305 + #x24ff2202 + #x6608440a + #x64644fe + #x5660ff66 + #xff770900 + #x8440a74 + #x4644fe66 + #x60ff6606 + #x77090056 + #x440a74ff + #x44fe6608 + #xff660646 + #x15005660 + #xfe660844 + #x66064644 + #x5660ff + #x66084415 + #x64644fe + #x5660ff66 + #x8441500 + #x4644fe66 + #x60ff6606 + #x66090056 + #x440a64ff + #x44fe6608 + #xfc660346 + #x50557577 + #x66090056 + #x440a64ff + #x64fd6602 + #x77042246 + #x660276ff + #x557577fc + #x9005650 + #xa64ff66 + #xfd660244 + #x4224664 + #x273ff77 + #x7577fc33 + #x565055 + #x64ff6609 + #x6602440a + #x361361fd + #x73ff7704 + #x77fc3302 + #x56505575 + #x2660900 + #x777ff33 + #xfd660244 + #x4361361 + #x273ff77 + #x7577fc33 + #x565055 + #x33026609 + #x440777ff + #x77096605 + #x505575fd + #x66090056 + #x77ff3302 + #x66054407 + #x75ff7707 + #x50ff5502 + #x66090056 + #x77ff3302 + #x66054407 + #x55037707 + #x5650ff + #x33026609 + #x440777ff + #x77076605 + #x50ff5503 + #x66090056 + #x77023302 + #x66054405 + #x55037707 + #x5650ff + #x33026609 + #x550e7702 + #x770357ff + #x50ff5503 + #x66090056 + #x77023302 + #x57ff550e + #x75ff7703 + #x50ff5502 + #x66090056 + #x77023302 + #x57ff550e + #x75fc7704 + #x56505555 + #x2660900 + #xe770233 + #x457ff55 + #x5544fc77 + #x565055 + #x33026609 + #x550e7702 + #x770357ff + #x404474fd + #x660c0058 + #x454464fd + #x57ff550e + #x74fe7703 + #xc005944 + #x4464fd66 + #xff550e45 + #xfe770357 + #x594044 + #x64fd660c + #x550e4544 + #x770257ff + #x5a4474fe + #x11660c00 + #x357ff55 + #x5a40ff77 + #x11660c00 + #x7757f955 + #x77677677 + #xc005977 + #xf9551166 + #x66667657 + #x59777767 + #x11660c00 + #x7657fc55 + #x77026666 + #x660c0059 + #x57fc5511 + #x2676676 + #x4006677 + #x457ff55 + #x575ff77 + #x557ff55 + #x2006677 + #x66771555 + #x66771800 + #xfd770e00 + #x6444774 + #xe006677 + #x4774fd77 + #x66770644 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #x66771800 + #xfd771100 + #x3474474 + #x11006677 + #x4474fd77 + #x78770347 + #x4404fd00 + #x78770347 + #x4404fd00 + #x78770347 + #x4404fd00 + #xfd007c40 + #x7f404404 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2900 + ) + :layer1 (new 'static 'array uint32 1276 + #x452301f8 + #xcdab8967 + #x3cd17ef + #x3cd0300 + #x1ccd0400 + #x6cd0300 + #xffcd0300 + #x1ccd0400 + #x1cd2100 + #x3cd0300 + #x1bcd0400 + #x6cd0400 + #x1cd0300 + #x1ccd0300 + #x3cd2700 + #x1acd0500 + #x6cd0400 + #xffcd0400 + #x1bcd0400 + #x3cd2700 + #x18cd0600 + #x6cd0500 + #x1bcd0a00 + #x4cd2700 + #x18cd0500 + #x7cd0400 + #x1acd0b00 + #x7cd0b00 + #x4cd1400 + #x16cd0500 + #x8cd0500 + #x1acd0a00 + #x10cd0800 + #x2cd1000 + #x15cd0600 + #x9cd0400 + #x1acd0a00 + #x14cd0700 + #x2cd0e00 + #x14cd0500 + #xacd0500 + #x1dcd0a00 + #x17cd0300 + #x1cd0c00 + #x13cd0600 + #xbcd0400 + #x1ccd0a00 + #x18cd0400 + #xffcd0d00 + #x12cd0500 + #xccd0500 + #x1bcd0a00 + #x18cd0400 + #x11cd1500 + #xdcd0400 + #x1bcd0a00 + #x18cd0300 + #xfcd1700 + #xdcd0500 + #x1bcd0a00 + #x18cd0300 + #x1cd0400 + #xfcd1000 + #xfcd0400 + #x1acd0a00 + #x18cd0300 + #x4cd0300 + #xdcd0f00 + #xfcd0500 + #x19cd0a00 + #x17cd0400 + #x5cd0400 + #xdcd0e00 + #x11cd0400 + #x18cd0a00 + #x18cd0300 + #x6cd0400 + #xbcd0e00 + #x11cd0500 + #x18cd0a00 + #x18cd0300 + #x8cd0300 + #xbcd0d00 + #x13cd0400 + #x18cd0900 + #x17cd0300 + #xacd0400 + #x9cd0c00 + #x13cd0500 + #x16cd0a00 + #x17cd0400 + #xbcd0400 + #x8cd0c00 + #x14cd0400 + #x14cd0a00 + #xcdfe00 + #x17cd04 + #xdcd03 + #x7cd0b + #x15cd05 + #x12cd0a + #xffcd01 + #x17cd03 + #xecd04 + #x6cd0b + #x16cd04 + #x11cd0a + #xffcd02 + #x17cd03 + #xfcd04 + #x5cd0a + #x17cd05 + #x10cd09 + #x17cd08 + #x11cd03 + #x4cd0a + #x18cd04 + #xfcd0a + #x16cd08 + #x12cd04 + #x3cd09 + #x19cd05 + #xecd09 + #x17cd08 + #x13cd04 + #x2cd09 + #x1acd04 + #xccd0a + #x2cd09 + #x11cd02 + #x14cd03 + #x1cd09 + #x1acd05 + #xbcd0a + #xffcd0a + #xecd06 + #x15cd04 + #xffcd09 + #x1ccd04 + #xbcd09 + #xdcd13 + #x16cd04 + #x1ccd0e + #x9cd0a + #xffcd06 + #xffcd02 + #xbcd09 + #x18cd04 + #x1ecd0c + #x8cd09 + #x1cd06 + #xffcd02 + #xbcd09 + #x19cd04 + #x1ecd0b + #x8cd09 + #x2cd05 + #xffcd02 + #xbcd09 + #x19cd04 + #x1fcd0a + #x6cd0a + #x2cd06 + #xffcd02 + #xacd09 + #x1bcd04 + #x20cd09 + #x5cd09 + #x3cd06 + #x1cd01 + #xacd09 + #x1ccd04 + #x21cd07 + #x4cd09 + #x4cd06 + #xffcd01 + #xacd0a + #x1dcd03 + #x21cd07 + #x3cd0a + #x4cd06 + #xffcd01 + #x9cd0a + #x1ecd04 + #x21cd07 + #x2cd09 + #x5cd06 + #xcdfd + #x9cd0a + #x1ecd04 + #x21cd07 + #xffcd0a + #xacd06 + #x9cd09 + #x1fcd03 + #x21cd08 + #xbcd10 + #x9cd08 + #x1ecd04 + #x21cd09 + #xbcd10 + #xbcd06 + #x1ecd04 + #x20cd0a + #xccd0f + #xbcd06 + #x1ecd03 + #x21cd0b + #xdcd0d + #xacd06 + #x1ecd04 + #x20cd0c + #xdcd0c + #x9cd08 + #x1dcd04 + #xffcd05 + #x20cd06 + #xdcd0c + #x8cd09 + #x1ecd03 + #x2cd04 + #x20cd06 + #xecd0a + #x7cd09 + #x1dcd04 + #x2cd05 + #x20cd06 + #xecd0a + #x6cd0a + #x1dcd04 + #x4cd04 + #x20cd05 + #xecd0a + #x6cd0a + #x1dcd03 + #x4cd05 + #x20cd06 + #xecd09 + #x5cd0a + #x1dcd04 + #x6cd04 + #x20cd05 + #xecd09 + #x5cd0a + #x1ccd04 + #x6cd05 + #x1ecd06 + #xdcd0b + #x5cd0a + #x1dcd03 + #x8cd04 + #x1ecd05 + #xdcd0b + #x4cd0a + #x1ccd04 + #x8cd05 + #x1ccd06 + #xdcd0c + #x4cd0a + #x1ccd04 + #xacd04 + #x1bcd05 + #xccd0e + #x3cd0a + #x1ccd04 + #xacd05 + #x1acd05 + #xccd0f + #x3cd0a + #x1ccd04 + #xccd04 + #x19cd05 + #xccd0f + #x3cd0a + #x1bcd04 + #xccd05 + #x2cd05 + #x441504ff + #xbcd10 + #x2cd0a + #x1ccd04 + #xecd04 + #x1cd05 + #x441504ff + #x1cd04 + #xbcd09 + #x2cd0a + #x1bcd04 + #xecd05 + #x1cd05 + #x441504ff + #x2cd03 + #xbcd09 + #x2cd0a + #x1bcd04 + #xfcd04 + #x1cd05 + #x441504ff + #x3cd03 + #xbcd08 + #x1cd0a + #x1bcd04 + #x10cd05 + #xfecd05 + #x2441504 + #x90004cd + #x10007cd + #x900ffcd + #x40002cd + #x4001bcd + #x50011cd + #x400fecd + #xcd014415 + #xcd090005 + #xcd020007 + #xcd0800ff + #xcd030002 + #xcd05001b + #xcd050012 + #x441504ff + #x5cd01 + #x7cd09 + #x1cd0c + #x1bcd04 + #x13cd04 + #x4ffcd05 + #xcdff4415 + #xcd090007 + #xcd0c0006 + #xcd040001 + #xcd05001a + #xcd050013 + #x441504ff + #xcd090008 + #xcd0d0006 + #xcd0300ff + #xcd04001b + #xcd050015 + #x64ff4407 + #x8440c + #x6cd09 + #x1acd12 + #x15cd05 + #x4406cd05 + #xc6646fe + #x9000944 + #x120005cd + #x4001acd + #x50016cd + #x14406cd + #xb64ff66 + #x9000944 + #x110005cd + #x5001acd + #x40017cd + #xff4405cd + #xb660246 + #x9000944 + #x100006cd + #x3001acd + #x1ccfffcd + #x574ff77 + #xff660344 + #xa440a64 + #x7cd0800 + #x19cd0f00 + #xffcd0400 + #xff771ccf + #xff440474 + #xa660446 + #x9000a44 + #xe0006cd + #x4001acd + #x1c07ffcd + #x474ff77 + #xff660544 + #xa440964 + #x6cd0900 + #x19cd0e00 + #xffcd0500 + #xff771c07 + #xff440374 + #x9660646 + #x8000b44 + #xe0006cd + #x40019cd + #x700fecd + #x73ff771c + #x66073303 + #x440864ff + #xcd09000b + #xcd0e0004 + #xcd050019 + #x1c0700fe + #x273ff77 + #x836ff33 + #xb440866 + #x4cd0900 + #x19cd0e00 + #x1cd0400 + #x1c07ff00 + #x373ff77 + #xff660733 + #xb440864 + #x4cd0900 + #x18cd0e00 + #x1cd0500 + #x1c07ff00 + #x373ff77 + #x636ff33 + #xc440966 + #x4cd0800 + #x18cd0e00 + #x6cdff00 + #x1c47ff44 + #x473ff77 + #xff660533 + #xc440964 + #x3cd0900 + #x17cd0e00 + #x6cd0100 + #x1c47ff44 + #x473ff77 + #x436ff33 + #xc440a66 + #x3cd0900 + #x8cd0b00 + #xfb770eaa + #xcd000070 + #xff4406cd + #xff771c47 + #x3330573 + #xa64ff66 + #x8000d44 + #xb0003cd + #xeaa08cd + #x70fe77 + #x4406cd02 + #x771c47ff + #x330573ff + #x660236ff + #xd440b + #x3cd08 + #xaa08cd0b + #x70fe770e + #x6cd0200 + #x1c47ff44 + #x673ff77 + #xff660133 + #xd440b64 + #x2cd0900 + #x8cd0b00 + #xff770eaa + #x6cd0370 + #x1c47ff44 + #x673ff77 + #x6636fd33 + #xd440b34 + #x3cd0900 + #x8cd0a00 + #xff770eaa + #x6cd0370 + #x1c47ff44 + #x773ff77 + #x3463fe33 + #xe440b + #x3cd08 + #xaa08cd0a + #x70ff770e + #x4406cd03 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000e + #xcd090002 + #xaa0800ff + #x70ff770e + #x4406cd03 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000e + #xcd090002 + #xaa0800ff + #x70ff770e + #x4406cd03 + #x73ff771d + #x34ff3308 + #xf440b + #x2cd08 + #xffcd09 + #x770eaa08 + #x330373ff + #x771d4406 + #x330873ff + #x440b34ff + #xcd08000f + #xcd080002 + #xaa080001 + #x73ff770e + #x44063303 + #x771c47ff + #x330873ff + #x440b34ff + #xcd09000f + #xcd080001 + #xaa080001 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd09001b + #xcd080001 + #xaa080001 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd08001c + #xcd0800ff + #xaa080002 + #x73ff770e + #x44063303 + #x771d47ff + #x30ff3308 + #xcd08001c + #xcd070001 + #xaa080002 + #x73ff770e + #x44063303 + #x70ff7723 + #x1dcd02 + #x1cd08 + #x2cd07 + #x770eaa08 + #x330373ff + #x77234406 + #xcd0370ff + #xcd08001c + #xcd060001 + #xaa080003 + #x22fe770e + #x6330223 + #xff772344 + #x1dcd0370 + #x1cd0700 + #x3cd0600 + #xeaa0800 + #xfd220177 + #x6333323 + #xff772344 + #x1dcd0370 + #x1cd0700 + #xbcd0600 + #xdcdff00 + #x472ff77 + #xff440622 + #xff772247 + #x1dcd0370 + #x1cd0700 + #xccd0500 + #xdcdff00 + #x472ff77 + #xff440622 + #xff772247 + #x1ccd0470 + #x1cd0700 + #xffcd0500 + #x9cd0200 + #x5770d00 + #xff440622 + #xff772247 + #x1dcd0470 + #x1cd0600 + #x8cd0a00 + #x5770d00 + #xff440622 + #xff772247 + #x1dcd0470 + #x1cd0600 + #x7cd0b00 + #xff770c00 + #x6220572 + #x2247ff44 + #x570ff77 + #x6001ccd + #xb0001cd + #xc0007cd + #x572ff77 + #xff440622 + #xff772247 + #x1ccd0570 + #x1cd0600 + #x7cd0b00 + #x6770c00 + #xff440622 + #xff772245 + #x1dcd0570 + #x2cd0300 + #x6cd0d00 + #x6770c00 + #xff440622 + #xff772245 + #x1ccd0670 + #x2cd0300 + #x9cd0d00 + #x1cd0700 + #x6220600 + #x2245ff44 + #x670ff77 + #x4001ccd + #xd0001cd + #x5000acd + #x60002cd + #xfe440622 + #x77215755 + #xcd0670ff + #xcd04001c + #xcd0e00ff + #xcd05000a + #x22050002 + #x440624ff + #x215755fe + #xcd70fc77 + #xcd0300cd + #xcd03001d + #xcd0e00ff + #xcd05000a + #x22050002 + #x440624ff + #x77215501 + #xcdcd70fc + #x1ccd0400 + #x9cd1300 + #x1cd0700 + #x6220500 + #x5545fd44 + #xfc772155 + #xcdcd70 + #x1ccd04 + #x9cd13 + #x1cd07 + #x24ff2204 + #x45fc4406 + #x20575555 + #xcd70fb77 + #x30000cd + #x13001ccd + #x90008cd + #x400ffcd + #x2440722 + #x2057ff55 + #xcd70fb77 + #x40000cd + #x13001bcd + #x90008cd + #x300ffcd + #x3440822 + #xfb772055 + #xcdcd70 + #x1acd0400 + #x7cd1400 + #x3cd0b00 + #x3440822 + #xfb772055 + #xcdcd70 + #x19cd0400 + #x8cd1400 + #x1cd0400 + #x3cd0400 + #xff440722 + #x20550345 + #x270ff77 + #x30001cd + #x150018cd + #x50007cd + #x50001cd + #x70002cd + #x345ff44 + #x1f57ff55 + #x270ff77 + #x40001cd + #x150016cd + #x40008cd + #x40003cd + #x70002cd + #xff550444 + #xff771f57 + #x1cd0270 + #x15cd0400 + #xffcd0a00 + #x7cd0a00 + #x3cd0500 + #x2cd0400 + #x4440700 + #x1f57ff55 + #x270ff77 + #x30002cd + #xa0014cd + #xa00ffcd + #x40008cd + #x40005cd + #x70001cd + #xff550444 + #xff771f57 + #x2cd0270 + #x13cd0300 + #xffcd0b00 + #x7cd0a00 + #x5cd0500 + #x1cd0400 + #xff440600 + #xff550445 + #xff771f57 + #x2cd0270 + #x11cd0400 + #xffcd0800 + #xffcd0200 + #x6cd0b00 + #x6cd0400 + #xffcd0500 + #x5440600 + #x1f57ff55 + #x270ff77 + #x40002cd + #x80010cd + #x10002cd + #xc00ffcd + #x50004cd + #x40007cd + #x500ffcd + #x545ff44 + #x1f57ff55 + #x270ff77 + #x30003cd + #x9000ecd + #x10003cd + #xd00ffcd + #x40003cd + #x50008cd + #x64405cd + #x1f57ff55 + #x270ff77 + #x30003cd + #x9000dcd + #x10004cd + #xd00ffcd + #x50002cd + #x40009cd + #xff4404cd + #xff550645 + #xff771f57 + #x3cd0270 + #xbcd0400 + #x5cd0900 + #x1cd0100 + #x2cd0c00 + #xacd0400 + #x4cd0400 + #x645ff44 + #x1f57ff55 + #x270ff77 + #x40003cd + #x9000acd + #xfd0007cd + #xd0000cd + #x500ffcd + #x3000bcd + #xff4404cd + #xff550645 + #xff771f57 + #x4cd0270 + #x9cd0300 + #xbcd0900 + #xffcd0d00 + #xccd0400 + #x4cd0300 + #x645ff44 + #x1f57ff55 + #x370ff77 + #x30003cd + #x80008cd + #xc000dcd + #x500ffcd + #x3000ccd + #xff4404cd + #xff550645 + #xff771f57 + #x3cd0370 + #x6cd0400 + #xfcd0800 + #xecd1100 + #x7cd0400 + #xffcd0200 + #xff771fcf + #x3cd0370 + #x5cd0400 + #x10cd0800 + #xecd1100 + #x6cd0400 + #xffcd0300 + #xff771fcf + #x4cd0370 + #x3cd0300 + #x11cd0900 + #x10cd1000 + #x5cd0400 + #xffcd0300 + #xff771fcf + #x4cd0370 + #x2cd0300 + #x12cd0900 + #x10cd1000 + #x4cd0400 + #xffcd0400 + #xff771fcf + #x4cd0370 + #xffcd0400 + #x13cd0900 + #x11cd0f00 + #x3cd0400 + #xffcd0500 + #xff771fcf + #x4cd0370 + #x13cd0e00 + #x12cd1000 + #x1cd0400 + #xffcd0600 + #xff771f07 + #x5cd0370 + #x14cd0c00 + #x13cd0f00 + #x1cd0400 + #xffcd0600 + #xff771f07 + #x5cd0370 + #x15cd0b00 + #x14cd0f00 + #xfecd0b00 + #x771f0700 + #xcd0370ff + #xcd090005 + #xcd0e0017 + #xcd0a0015 + #x7ff0001 + #x70ff771f + #x5cd03 + #x18cd08 + #x15cd0e + #x2cd09 + #x771f07ff + #xcd0370ff + #xcd080004 + #xcd0d0019 + #xcd080017 + #x7ff0002 + #x70ff771f + #x2cd03 + #x1acd09 + #x16cd0e + #x3cd07 + #x771f07ff + #xcd0370ff + #xcd090001 + #xcd0e001b + #xcd060016 + #x7ff0004 + #x70fe772e + #xe001bcd + #x60016cd + #xff0004cd + #xfe772e07 + #x1bcd70 + #xffcd03 + #x15cd09 + #x5cd06 + #x772e07ff + #x1ccd70fe + #x14cd0d00 + #x5cd0700 + #x2e07ff00 + #xcd70fe77 + #xcd0b001e + #xcd080013 + #x7ff0005 + #x70fe772e + #xb001dcd + #x90014cd + #xff0004cd + #xfd772e07 + #x1ccdcd70 + #x13cd0b00 + #x4cd0a00 + #x2e07ff00 + #x5575fe77 + #x43ff4402 + #x30ff330f + #xcd0c0007 + #xcd0b0012 + #x7ff0004 + #x75fe772e + #xff440255 + #xff330f43 + #xd000730 + #x60010cd + #x40001cd + #xff0003cd + #xfe772e07 + #x44025575 + #x330f43ff + #x730ff + #xfcd0e + #x1cd06 + #x3cd04 + #x772e07ff + #x545575fa + #xf434444 + #x730ff33 + #xecd0e00 + #x3cd0600 + #x3cd0300 + #x2e07ff00 + #x5575fb77 + #x10444454 + #x730ff33 + #xdcd0e00 + #x4cd0600 + #x2cd0400 + #x2e07ff00 + #x5575fb77 + #x10444454 + #x730ff33 + #xccd0e00 + #x5cd0600 + #x2cd0400 + #x2e07ff00 + #xfd550177 + #x10444454 + #x730ff33 + #xbcd0f00 + #x6cd0600 + #x2cd0300 + #x2e07ff00 + #xfd550177 + #x10424454 + #x730ff33 + #xacd0f00 + #x7cd0600 + #x1cd0400 + #x2e07ff00 + #xfe550277 + #x33102244 + #x630ff + #x9cd10 + #x8cd06 + #x1cd04 + #x772e07ff + #x42fe5502 + #xff331022 + #xf000630 + #x6000acd + #x40008cd + #xff0001cd + #x2772e07 + #x10220155 + #x530ff33 + #x9cd1000 + #xacd0600 + #x1cd0300 + #x2e07ff00 + #xfd550177 + #x10222252 + #x530ff33 + #x8cd1000 + #xbcd0600 + #xfecd0400 + #x772e0700 + #x52fd5501 + #x33102222 + #x430ff + #xccd0c + #xccd06 + #xfecd04 + #x1772e07 + #x2252fd55 + #xff331022 + #xe000430 + #x6000acd + #x3000dcd + #x700fecd + #x75fb772e + #x22225255 + #x30ff3310 + #xcd0e0004 + #xcd060009 + #xcd03000e + #x2f0700fe + #x5255fc77 + #x33102322 + #x430ff + #x8cd0e + #xfcd06 + #xecd04 + #x8cd08 + #x2cd03 + #x770707ff + #x225255fc + #xff331023 + #xe000430 + #x60007cd + #x40010cd + #x8000dcd + #x30009cd + #xff0002cd + #xfc770707 + #x23225255 + #x30ff3310 + #xcd020004 + #xcd0b00ff + #xcd060006 + #xcd030011 + #xcd08000c + #xcd03000a + #xcd01000c + #x3310cfff + #x430ff + #x6cd0e + #x12cd06 + #xacd03 + #xbcd09 + #xccd03 + #xcfffcd01 + #x30ff3310 + #xcd010004 + #xcd0b00ff + #xcd060005 + #xcd040013 + #xcd090008 + #xcd04000b + #xcd01000c + #x3310cfff + #x430ff + #xcdfd + #x4cd0c + #x15cd05 + #x7cd03 + #xccd09 + #xdcd03 + #xcfffcd01 + #x30ff3310 + #xcd0d0007 + #xcd060002 + #xcd030015 + #xcd090006 + #xcd03000d + #xcdfe000e + #xff3310cf + #xe000730 + #x600ffcd + #x30016cd + #x90005cd + #x3000ecd + #xfe000ecd + #x3310cfcd + #x830ff + #x17cd14 + #x3cd04 + #x10cd08 + #xecd03 + #x18cd03 + #x18cd14 + #x2cd03 + #x11cd08 + #xecd03 + #x18cd03 + #x19cd13 + #x1cd03 + #x12cd08 + #xecd03 + #x17cd04 + #x1acd12 + #x13cd0d + #xecd03 + #x17cd04 + #x1bcd11 + #x13cd0c + #xfcd04 + #x17cd03 + #x1bcd11 + #x14cd0b + #x10cd03 + #x17cd03 + #x1dcd10 + #x15cd09 + #x10cd03 + #x17cd03 + #x1dcd0f + #x16cd09 + #x10cd03 + #x17cd03 + #x1ccd0f + #x17cd09 + #x10cd03 + #x17cd03 + #x1bcd0f + #x19cd08 + #x10cd03 + #x10cd04 + #x4cd01 + #x1acd0e + #x18cd09 + #x11cd04 + #xecd03 + #x4cd03 + #x19cd0e + #x19cd09 + #x11cd04 + #xccd03 + #x4cd05 + #x18cd0e + #x19cd0a + #x12cd03 + #xacd03 + #x4cd07 + #x17cd0d + #x18cd0d + #x12cd03 + #x8cd03 + #x5cd09 + #x16cd0c + #x18cd0e + #x12cd03 + #x6cd03 + #x5cd0b + #x19cd08 + #x1cd09 + #x18cd03 + #x12cd03 + #x4cd03 + #x5cd0d + #x18cd08 + #x2cd09 + #x17cd03 + #x12cd04 + #x1cd04 + #x5cd0f + #x17cd08 + #x3cd09 + #x17cd03 + #x14cd03 + #x6cd13 + #x15cd0a + #x5cd08 + #x16cd04 + #x14cd03 + #x7cd11 + #xfcd10 + #x7cd08 + #x16cd03 + #x14cd03 + #x9cd0f + #xdcd11 + #x8cd08 + #x16cd03 + #x12cd03 + #xacd0f + #xccd12 + #x9cd08 + #x15cd03 + #x10cd04 + #xbcd0f + #xacd13 + #xacd09 + #x15cd03 + #xfcd03 + #xccd0f + #x9cd14 + #xbcd09 + #x14cd04 + #xdcd03 + #xdcd10 + #x8cd14 + #xdcd09 + #x14cd03 + #xbcd03 + #xecd10 + #x7cd15 + #xecd09 + #x13cd03 + #x9cd04 + #x10cd10 + #x6cd15 + #xfcd09 + #x13cd03 + #x7cd04 + #x10cd12 + #x5cd15 + #x11cd08 + #x13cd03 + #x6cd03 + #x10cd14 + #xffcd04 + #x4cd0f + #x12cd08 + #x13cd03 + #x5cd03 + #x1cd0f + #x10cd03 + #x2cd03 + #x4cd0d + #x13cd08 + #x11cd04 + #x3cd04 + #x3cd0f + #x10cd03 + #x4cd02 + #x4cd0b + #x15cd08 + #x11cd03 + #x1cd04 + #x5cd0f + #x10cd03 + #x5cd02 + #x3cd09 + #x16cd09 + #x11cd03 + #x7cd14 + #x10cd03 + #x6cd01 + #x2cd09 + #x17cd09 + #x10cd03 + #x9cd13 + #x18cd04 + #x1cd09 + #x18cd09 + #x10cd03 + #xccd11 + #x18cd03 + #xffcd09 + #x19cd09 + #xfcd03 + #xecd10 + #x18cd03 + #x1acd13 + #xdcd04 + #x10cd0f + #x18cd03 + #x1dcd11 + #xbcd03 + #x12cd0f + #x19cd03 + #x1ecd0f + #x9cd03 + #x14cd0f + #x19cd03 + #x1fcd0e + #x8cd03 + #x16cd0e + #x1bcd03 + #x20cd0b + #x7cd03 + #x18cd0d + #x1dcd03 + #x21cd08 + #x7cd03 + #x1acd0b + #x1fcd03 + #x22cd05 + #x7cd03 + #x1bcd0a + #xfcd03 + #x0 + #x0 + #x0 + #x0 + ) + :layer2 (new 'static 'array uint32 736 + #x452301f8 + #xcdab8967 + #xff0077ef + #x7f007fcd + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7007f00 + #x20aa0d00 + #x4f60ff66 + #x20aa0d00 + #x4f60ff66 + #x20aa0d00 + #x60fc66 + #x77120700 + #xcd240001 + #xaa0d0012 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x6620aa0d + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x20aa0d00 + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xaa0d0011 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x6620aa0d + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x20aa0d00 + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xaa0d0011 + #x60fc6620 + #x12070000 + #xff441277 + #xff331243 + #xd001130 + #xfc6620aa + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #xaa02bb05 + #x6666a6fb + #x6620cdcd + #x60fc + #x12771207 + #x1243ff44 + #x1130ff33 + #x2bb0500 + #x24a6ffaa + #x60fc66 + #x77120700 + #x43ff4412 + #x30ff3312 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x12070000 + #xff441277 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x44127712 + #x331243ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #x4440974 + #xff441277 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x77044409 + #x43ff4412 + #x30ff3312 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #x1243ff44 + #x1130ff33 + #x1bb0600 + #x2406ff00 + #x60fc66 + #x77020700 + #x442174ff + #x331243ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #xff442174 + #xff331243 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220a + #x30ff3306 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xa42ff44 + #x623ff22 + #x1130ff33 + #x1bb0600 + #x2406ff00 + #x60fc66 + #x77020700 + #x442174ff + #x220a42ff + #x330623ff + #x1130ff + #x1bb06 + #x662406ff + #x60fc + #xff770207 + #xff442174 + #xff220a42 + #xff330623 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220a + #x30ff3306 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xb42ff44 + #xff330622 + #x6001130 + #xff0001bb + #xfc662406 + #x7000060 + #x74ff7702 + #x42ff4421 + #x23ff220b + #x30ff3305 + #xbb060011 + #x6ff0001 + #x60fc6624 + #x2070000 + #x2174ff77 + #xc42ff44 + #xff330522 + #xff000d30 + #x4330303 + #xfe3301bb + #x66270630 + #x770207ff + #x442174ff + #x220c42ff + #x330423ff + #xd30ff + #x330303ff + #x3301bb04 + #x1c0630fe + #x9cfff66 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x60ff661b + #x7ff660a + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661b06 + #xff660acf + #xff770207 + #xff441f74 + #xff220f42 + #xff001220 + #x4330303 + #xfe3301bb + #x66270630 + #x770207ff + #x441f74ff + #x220f42ff + #x1220ff + #x330303ff + #x3301bb04 + #x270630fe + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1104 + #x7ff660b + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #xb110561 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1105 + #x7ff660a + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #xa110661 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1106 + #x7ff6609 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #xff661406 + #x9110761 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x61ff6614 + #x16ff1107 + #x7ff6608 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30fe3301 + #x13660a06 + #x7cfff11 + #x207ff66 + #x1f74ff77 + #xf42ff44 + #x1220ff22 + #x303ff00 + #x1bb0433 + #x630fe33 + #x1114660a + #x7ff6607 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #xbb043303 + #x30ff3301 + #x1116000a + #x7ff0006 + #x74ff7702 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x7111600 + #x7747fc44 + #x441f7477 + #x220f42ff + #x1220ff + #x331203ff + #x11160003 + #x47fc4407 + #x1f747777 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfc440711 + #x74777747 + #x42ff441f + #x20ff220f + #x3ff0012 + #x33312 + #x44071116 + #x777747fc + #xff441f74 + #xff220f42 + #xff001220 + #x3331203 + #x2b111600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x2b221600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x2b221600 + #xf42ff44 + #x1220ff22 + #x1203ff00 + #x16000333 + #xff442b22 + #xff220f42 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x54fe5514 + #xf660444 + #xf02ff00 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfe551422 + #x66044454 + #x2ff000f + #x20ff220f + #x3ff0012 + #x33312 + #x55142216 + #x44454fe + #xff000f66 + #xff220f02 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x54fe5514 + #xf660444 + #xf02ff00 + #x1220ff22 + #x1203ff00 + #x16000333 + #xfe551422 + #x66044454 + #x2ff000f + #x20ff220f + #x3ff0012 + #x33312 + #x55142216 + #x44454fe + #xff000f66 + #xff220f02 + #xff001220 + #x3331203 + #x14221600 + #x4454fe55 + #xf6604 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220f02ff + #x1220ff + #x331203ff + #x22160003 + #x46fd4418 + #xf6666 + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x44182216 + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221c0003 + #x441124ff + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221c0003 + #x441124ff + #x666646fd + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #xf660e + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x24ff221e + #x660e4403 + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #xf660e + #x220d02ff + #x110b21ff + #x3ff0008 + #x33312 + #x24ff221e + #x660e4403 + #x2ff000f + #x21ff220d + #x8110b + #x331203ff + #x221e0003 + #x440324ff + #x14660e + #x81116 + #x331203ff + #x221c0003 + #x441424ff + #x11160014 + #x3ff0008 + #x33312 + #x24ff221c + #x144414 + #x81116 + #x331203ff + #x221c0003 + #x441424ff + #x11160014 + #x3ff0008 + #x33312 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x201116 + #x24ff221c + #x144414 + #x3d1116 + #x441404ff + #x11160014 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x11160068 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x3 + #x0 + ) + :layer3 (new 'static 'array uint32 1004 + #x452301f7 + #xcdab8967 + #x663300ef + #x134437 + #x44376633 + #x66330013 + #x134437 + #x44376633 + #x66330013 + #x134437 + #x77056633 + #x443074ff + #x66330013 + #x74ff7705 + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x74ff770e + #x134430 + #x67ff6629 + #x4430770f + #x66260013 + #x444464fc + #xff770f47 + #x13442f74 + #x3662600 + #x2f771044 + #x25001344 + #x364ff66 + #x347ff44 + #x4440677 + #x2e74ff77 + #x24001344 + #x464ff66 + #x347ff44 + #xff440677 + #x2e770447 + #x24001344 + #x464ff66 + #x347ff44 + #x4440777 + #x2d74ff77 + #x24001344 + #xff440566 + #x7770347 + #x447ff44 + #x13442d77 + #x3662400 + #xff110144 + #xff770317 + #x4110271 + #xff770444 + #x13442c74 + #xff662300 + #xfc440264 + #x17111141 + #x11027704 + #x440314ff + #x770447ff + #x13442c + #x64ff6623 + #x11024402 + #x770417ff + #x110271ff + #x47ff4403 + #x442c7704 + #x66230013 + #x41ff4402 + #x77061102 + #x14ff1102 + #x47ff4402 + #x442c7704 + #x66230013 + #x41fc4402 + #x13171111 + #x5440477 + #x13442177 + #xff662200 + #xfd440264 + #x14111141 + #x5440477 + #x13442177 + #xff662200 + #xfd440264 + #x1f171141 + #x13442177 + #x1662200 + #x2347ff44 + #x13442177 + #x1662200 + #x21772444 + #x21001344 + #x4464fd66 + #x22772347 + #x21001344 + #x4464fd66 + #x22772347 + #x21001344 + #xff440166 + #x6771947 + #x22770244 + #x20001344 + #x4464fc66 + #x77124744 + #x440c74ff + #x777747fd + #x134422 + #x44026620 + #x771247ff + #x47fd440d + #x44227777 + #x661f0013 + #x440264ff + #x74ff7712 + #x47fd440d + #x44227777 + #x661f0013 + #x77134402 + #x47fd440e + #x44227777 + #x661e0013 + #x444464f9 + #x47447777 + #x440d7711 + #x777747fd + #x134422 + #x4401661e + #x44027701 + #x44fd770f + #x440c7777 + #x777747fd + #x134422 + #x64fc661d + #x3777744 + #xc47ff44 + #xfe440377 + #x440b7477 + #x777747fd + #x134422 + #x44fd661d + #x44057747 + #x74ff770b + #x47fd4403 + #x440a7477 + #x777747fd + #x134422 + #x47fd661d + #x44047477 + #x770b47ff + #x47fe4405 + #xfd440a77 + #x22777747 + #x1c001344 + #x7764fd66 + #xff440574 + #xfe440677 + #x44097447 + #x97477fe + #x7747fd44 + #x13442277 + #xfe661c00 + #x44057747 + #x67477fe + #x7447fe44 + #x77fe440a + #xfd440874 + #x22777747 + #x18001344 + #x264ff66 + #x4770144 + #x7747fe44 + #x47fe4407 + #xfe440a74 + #x44087747 + #x777747fd + #x134422 + #x64ff6615 + #x47fd4404 + #x44044774 + #x440877ff + #xb7447fe + #x7477fe44 + #x47fd4407 + #x44227777 + #x66120013 + #x77fd4408 + #x44037444 + #x87447fe + #x7447fe44 + #x47fe440b + #xfd440777 + #x22777747 + #x10001344 + #xfc440966 + #x74447447 + #x47fe4402 + #xfe440977 + #x440c7447 + #x67477fe + #x7747fd44 + #x13442277 + #xb660e00 + #x4477fd44 + #xff440347 + #xfe440a77 + #x440c7447 + #x67747fe + #x7747fd44 + #x13442277 + #xff660d00 + #xfc440a64 + #x74447747 + #x47fe4402 + #xfe440a74 + #x440d7447 + #x440677ff + #x777747fd + #x134422 + #x440b660d + #x447477f8 + #x47444474 + #xfe440b77 + #x440d7447 + #x57447fe + #x7747fd44 + #x13442277 + #xff660c00 + #xfd440b64 + #x2474477 + #x7477fe44 + #x47fe440b + #xfe440d74 + #x44057747 + #x777747fd + #x47fc4414 + #x9747777 + #xc001344 + #xa64ff66 + #x7447f844 + #x44444744 + #x440c7447 + #xe7447fe + #x577ff44 + #x7747fd44 + #xff441477 + #x9770247 + #xc001344 + #xf9440b66 + #x74447477 + #xd774444 + #x7447fe44 + #x47fe440e + #xff440374 + #x12770447 + #x247ff44 + #x874ff77 + #xc001344 + #xf9440b66 + #x44474477 + #x8747744 + #xd41ff44 + #xff440711 + #x5440377 + #x674ff77 + #xff770544 + #xff440374 + #x8770347 + #xc001344 + #x1440a66 + #x1711fb77 + #x9774744 + #xff110e44 + #xff440614 + #xff440277 + #xff770547 + #xff440474 + #xff770747 + #xff440274 + #xff770347 + #x13440774 + #xff660b00 + #xf9440964 + #x11717741 + #x9774411 + #xf41ff44 + #xfc440611 + #x44447447 + #x74ff7706 + #x47fd4403 + #x44057777 + #x27747fe + #x447ff44 + #x13440777 + #xff660b00 + #xfe440964 + #x11027711 + #x97417fe + #xff111044 + #xfc440514 + #x47447447 + #x74ff770c + #x77fb4407 + #x47444474 + #x74ff7704 + #x134406 + #x64ff660b + #x41fd4408 + #x11037711 + #x41ff4409 + #x44061111 + #xc4477fe + #x874ff77 + #x7747fb44 + #x5474444 + #x13440677 + #xff660b00 + #xfd440864 + #x3711711 + #x814ff11 + #xff111244 + #xfe440514 + #x77074777 + #x440e74ff + #x447477fc + #x6770547 + #xb001344 + #x764ff66 + #x1141fc44 + #x11037117 + #x440714ff + #x111341ff + #x47ff4405 + #x74ff7708 + #x47ff440e + #x44067708 + #x660b0013 + #x440764ff + #x77ff1101 + #x14ff1104 + #x11144407 + #x440414ff + #x770847ff + #x440f74ff + #x44067708 + #x660b0013 + #x440664ff + #x111141fc + #xff110477 + #xff440614 + #x5111541 + #xff770844 + #xff441174 + #x6770547 + #xb001344 + #x664ff66 + #xff110244 + #x7110471 + #xff111644 + #x8440414 + #x1174ff77 + #x547ff44 + #x13440677 + #x5660c00 + #x1141fb44 + #x3711711 + #x714ff11 + #x4111744 + #xff770844 + #xff441174 + #x6770547 + #xc001344 + #x2440566 + #x7117fe11 + #x44081103 + #x14ff1117 + #x77084403 + #x441274ff + #x44067705 + #x660c0013 + #x41ff4404 + #x17ff1102 + #x14fc1103 + #x5144444 + #xfd111944 + #x8444414 + #xff441377 + #x6770447 + #xc001344 + #x3440466 + #x377ff11 + #x4414fc11 + #x44051441 + #x14ff1104 + #x41ff440d + #x14fd1104 + #x77074444 + #x441474ff + #x44067704 + #x660b0013 + #x440364ff + #x110341ff + #x110377ff + #x414414fd + #x11044406 + #x41ff440e + #x14fd1104 + #x77074444 + #x47ff4415 + #x74ff7702 + #x134406 + #x4403660b + #x71fe7704 + #xfd110377 + #x5144414 + #x341ff44 + #xf14ff11 + #xfd110444 + #x6444414 + #x1674ff77 + #x7770244 + #xb001344 + #xff440266 + #x3770647 + #x4114fd11 + #xfe440514 + #x11024111 + #x41ff4410 + #x14fd1103 + #x77064444 + #x47fd4417 + #x44077477 + #x660b0013 + #x77074402 + #x14fe1103 + #xfa440541 + #x11441441 + #x44111411 + #x14fd1103 + #x77054444 + #x442274ff + #x660b0013 + #x47ff4401 + #x11037707 + #x44051401 + #x441611ff + #x14fd1103 + #x77054444 + #x134423 + #x4401660b + #x11047708 + #x41fe4405 + #x3441614 + #x4414fd11 + #xff770444 + #x13442374 + #xfe660b00 + #x77084744 + #x44051104 + #x441711ff + #x14fd1103 + #x77044444 + #x134424 + #x67ff6607 + #x1103770d + #x440414ff + #x171441fe + #xfd110344 + #x4444414 + #x13442477 + #xff660700 + #x3770d67 + #x414ff11 + #x1811ff44 + #xfd110344 + #x4444414 + #x13442477 + #xff660700 + #x3770d67 + #x314ff11 + #x1441fe44 + #x11034418 + #x444414fd + #x44247704 + #x66070013 + #x770d67ff + #x14ff1103 + #x11ff4403 + #x41ff4418 + #x14fd1103 + #x77044444 + #x134424 + #x67ff6607 + #x1105770d + #x41fe4401 + #x4441814 + #x4414fd11 + #x24770444 + #x7001344 + #xd67ff66 + #xfd110577 + #x18114414 + #x441ff44 + #x4414fd11 + #x24770444 + #xb001344 + #x8440166 + #xfe110677 + #x44181441 + #x14fd1105 + #x77044444 + #x134424 + #x4401660b + #x770747ff + #x44191107 + #x14fd1105 + #x77044444 + #x134424 + #x64ff660a + #x77024402 + #x111171fb + #x11077117 + #x11054419 + #x444414fd + #x74ff7704 + #x134423 + #x64ff660a + #x47fd4402 + #x11037777 + #x110771ff + #x441814ff + #x14fd1105 + #x77054744 + #x134423 + #x64ff660a + #x77014403 + #x71ff1103 + #x14ff1107 + #x11064418 + #x770644ff + #x442274ff + #x660a0013 + #x440564ff + #x71ff1103 + #x14fd1107 + #x44163333 + #x14ff1106 + #x74ff7706 + #x134422 + #x64ff660a + #x11034405 + #x110777ff + #x333314fd + #x11074416 + #x74ff7706 + #x134422 + #x64ff660a + #x41ff4405 + #x77ff1102 + #x14fd1107 + #x44163333 + #x77061107 + #x442274ff + #x660a0013 + #x11024407 + #x110777ff + #x333314fd + #x11074416 + #x74ff7706 + #x134422 + #x4407660a + #x111141fc + #xfd110717 + #x16333344 + #xff110744 + #xff770517 + #x13442274 + #xff660900 + #xfb440764 + #x17111141 + #xfc110571 + #x33334414 + #x11084416 + #x74ff7705 + #x134422 + #x64ff6609 + #x41fb4407 + #x71171111 + #x44011105 + #x44163301 + #x77051108 + #x442274ff + #x66090013 + #x440764ff + #x111141fb + #x11047117 + #x444414fb + #x44163333 + #x77051108 + #x442274ff + #x66090013 + #x41ff4408 + #x77ff1102 + #x44011104 + #x333343fc + #x8441534 + #xff770511 + #x13442274 + #x8660900 + #x241ff44 + #x377ff11 + #x4414f911 + #x33334344 + #x8441534 + #x4774fe11 + #x74ff7703 + #x134422 + #x44086609 + #x110241ff + #x110377ff + #x43fc4402 + #x15343333 + #x641ff44 + #x7417fd11 + #x23770344 + #x8001344 + #x864ff66 + #x241ff44 + #x7117fb11 + #x2141111 + #x3343fc44 + #x44163433 + #x17f91106 + #x77474474 + #x44237477 + #x66080013 + #x440864ff + #x110241ff + #x117117fc + #xfc440311 + #x34333343 + #x41ff4416 + #x77ff1105 + #x134429 + #x64ff6608 + #x41ff4408 + #x77fd1103 + #x44031411 + #x333343fc + #x5441734 + #x2977ff11 + #x8001344 + #x3440a66 + #x1177fe11 + #x43fc4404 + #x17343333 + #x341ff44 + #x7417fe11 + #x134429 + #x44096608 + #x21441fe + #x7417fe11 + #x43ff4404 + #x44183302 + #x17fe1103 + #xff442a74 + #x7001140 + #x964ff66 + #x4441fe44 + #x17fe1102 + #xff440477 + #xff330243 + #x3441734 + #x2b77ff11 + #x1140ff44 + #xff660700 + #xff440964 + #xfd440211 + #x4777747 + #x343ff44 + #xfe441633 + #x11021441 + #x442b74ff + #x1140ff + #x64ff6607 + #x41fe4408 + #x1440314 + #x474ff77 + #xff330344 + #xff441534 + #xfe440211 + #x442b7447 + #x1140ff + #x44096607 + #x31441fe + #x7747fd44 + #xff440477 + #x14330343 + #x1141fe44 + #x77fe4402 + #xff442b74 + #x7001140 + #xff440966 + #xfd440411 + #x5777747 + #xff330344 + #xfa441334 + #x44441411 + #x442c7747 + #x1140ff + #x44096607 + #x440511ff + #x74ff7701 + #x43ff4404 + #x44133303 + #x440211ff + #x2c7477fe + #x1140ff44 + #xff660600 + #xfe440864 + #x44051441 + #x777747fd + #x33034405 + #x441134ff + #x21441fe + #x2d77ff44 + #x1140ff44 + #x9660600 + #x741ff44 + #xff770144 + #xff440474 + #x6330343 + #xff440a11 + #xfe440211 + #x442d7447 + #x1140ff + #x440a6605 + #x440711ff + #x777747fd + #x33034405 + #x14ff1106 + #x41fe4408 + #xff440214 + #xff442e77 + #x4001140 + #xa64ff66 + #x714ff44 + #x7747fc44 + #x44047477 + #x333343fc + #x8110731 + #x1411fa44 + #x74474444 + #x94437 + #x440a6604 + #x81441fe + #x5770244 + #x8330144 + #x614ff11 + #x1141fe44 + #x77ff4402 + #xc4438 + #x41ff440c + #x47fc4409 + #x4747777 + #x3143fe44 + #x14f9110f + #x44441441 + #x44387477 + #x440c000c + #x440a11ff + #x774477fd + #x41ff4404 + #x44011112 + #x397747fe + #x18000c44 + #x4447fc44 + #x44037747 + #x111141ff + #x444414fb + #x44397477 + #x4419000c + #x774474fc + #xff440274 + #xf7110c41 + #x71777717 + #x77441111 + #xc443a77 + #xf8441900 + #x77444477 + #x41444474 + #x7703110c + #x47fe1101 + #xc443b77 + #xfb441c00 + #x44747747 + #xff110541 + #xfc770917 + #x74771771 + #xc443b + #x47fc441d + #x5417477 + #x3c770d11 + #x1e000c44 + #x7747fd44 + #xff110477 + #xfe770b17 + #x443c1471 + #x441f000c + #x777747fd + #x770b1103 + #x141171fd + #xc443c + #x47fa4420 + #x11717777 + #xfd770b11 + #x3c141171 + #x21000c44 + #xf11ff44 + #x1171fd77 + #xc443c14 + #xfc442100 + #x17111141 + #x71fd770c + #x443c1411 + #x4422000c + #x770b1103 + #x3d1171fe + #x22000c44 + #x241ff44 + #xfe770b11 + #x443d1471 + #x4423000c + #x770b1102 + #x443e71ff + #x4423000c + #x111141fd + #x74ff770b + #xc443e + #x11014424 + #x770a17ff + #xc443f + #x41fd4424 + #x77091111 + #x443f74ff + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4472000c + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x71440c + #x440c04ff + #x4ff0071 + #x41fd440a + #x701111 + #x440a04ff + #x701102 + #x440a04ff + #x701102 + #x440a04ff + #x701102 + #x440904ff + #x110241ff + #x4ff0070 + #x11034409 + #x4ff0070 + #x11034409 + #x2ff0049 + #x6221e + #x440804ff + #x110341ff + #x2ff0049 + #x6221e + #x440804ff + #x491104 + #x221e02ff + #x14ff1107 + #x11044407 + #x2ff0049 + #x1107221e + #x440614ff + #x110441ff + #x2ff0049 + #x110a221e + #x440214ff + #x110541ff + #x2ff0049 + #x110b221e + #x74144fe + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x15221e02 + #xff004911 + #x14221f02 + #xff004911 + #xff221f02 + #x49111321 + #x2002ff00 + #x49111322 + #x2002ff00 + #x49111322 + #x2002ff00 + #x1221ff22 + #xff004911 + #xff222002 + #x49111221 + #x2102ff00 + #x49111222 + #x2102ff00 + #x1121ff22 + #xff004911 + #xff222102 + #x49111121 + #x2102ff00 + #x1121ff22 + #xff004911 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #xff005b20 + #xff222102 + #x1120 + ) + :layer4 (new 'static 'array uint32 860 + #x450300f7 + #xcdab8967 + #x7fcdef + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x40007f + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x10660d + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x10660d + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #xa660d + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #xa660d + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x707707fd + #x1cd03 + #x330c03ff + #xc0ffcc08 + #x6ff0047 + #x7660d + #x777707fd + #x1cd03 + #x330b03ff + #xcc083cff + #x47c0ff + #x660d06ff + #x30fc3306 + #x3777707 + #xff0001cd + #xb330903 + #x47c0ffcc + #xd06ff00 + #xfb330666 + #x77774434 + #x1cd0270 + #x803ff00 + #xb3cff33 + #x47c0ffcc + #xd06ff00 + #xfe330666 + #x77024434 + #x1cd02 + #x330803ff + #xc0ffcc0c + #x6ff0047 + #x3306660d + #x474434fb + #xcd027777 + #x3ff0005 + #x3cff3303 + #xc0ffcc0c + #x6ff0047 + #x3306660d + #x47ff4402 + #xfcfcff06 + #x3c3cccc + #xc3cff33 + #x47c0ffcc + #xd06ff00 + #x2330666 + #xfcff0744 + #xc3ccccfc + #x3cff3303 + #xc0ffcc0c + #x6ff0047 + #x3306660d + #xff074402 + #xc3ffcc02 + #x3cff3303 + #xc0ffcc0c + #x6fd0047 + #x44026666 + #x33066608 + #x4fff4401 + #xfcffff06 + #xc3ffcc02 + #x3cff3303 + #xc0ffcc0c + #x6fd0047 + #x44026666 + #x660746ff + #x330463ff + #xf4ff3ffc + #xffff064f + #xffcc02fc + #xff330393 + #xffcc0c3c + #xfd0047c0 + #x3666606 + #xff660744 + #xa330463 + #x7cc03ff + #xffcc0199 + #x49dd06cd + #x206ff00 + #x4464fd66 + #xff660744 + #x9330463 + #xffcc03ff + #x19907c9 + #x49dd07cc + #x206ff00 + #x4464f966 + #x64664644 + #x4660444 + #xfdff0833 + #xaccccfc + #x7cc0199 + #xff0049dd + #xf8660206 + #x46444464 + #x46444464 + #x33046603 + #xcc01ff08 + #x990ac9ff + #x9dffcc01 + #x49dd06 + #x660206ff + #x440564ff + #x660546ff + #xff060003 + #xc9ffcc01 + #xdd06990e + #x6fd0049 + #x44076466 + #x660546ff + #xcfff0003 + #xcc01ff05 + #xdd06990f + #x6fd0049 + #x44036466 + #x440264ff + #x660546ff + #xcd030003 + #x5555f5fc + #x69910cc + #xfd0049dd + #x2646606 + #x6646fe44 + #x46ff4402 + #x36605 + #x5501cd04 + #xdd069911 + #x6f80049 + #x44646666 + #x2666646 + #x3660644 + #x1cd0400 + #x6991155 + #xff0049dd + #x1660606 + #x646ff44 + #x4000366 + #x5955fecd + #x9dff9910 + #x49dd06 + #x660606ff + #x66034401 + #x665665fc + #x5000366 + #x69912cd + #xff0049dd + #xff660606 + #x1660464 + #x3660155 + #x12cd0500 + #x59dff99 + #xff0049dd + #x1660c06 + #x6656fe55 + #x9ff0003 + #x90fe9902 + #xff9912cd + #x49dd059d + #xc06ff00 + #x5565fc66 + #x36655 + #x991709ff + #x49dd06 + #x660c06ff + #x550265ff + #x250ff + #x991609ff + #xdd069dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #x9ff0002 + #x9dff9916 + #x49dd06 + #x660c06ff + #x50ff5503 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660b06ff + #x50ff5504 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660a06ff + #x550465ff + #x250ff + #x991509ff + #xdd079dff + #x6ff0049 + #x65ff660a + #x50ff5504 + #x9ff0002 + #x9dff9915 + #x49dd07 + #x660c06ff + #x50ff5503 + #x9ff0002 + #x9dff9914 + #x49dd08 + #x660c06ff + #x550265ff + #x250ff + #x991309ff + #xdd099dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbfd0002 + #x9910b9bb + #xdd0a9dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbff0002 + #x990fbb02 + #xdd0a9dff + #x6ff0049 + #x65ff660c + #x50ff5502 + #xbff0002 + #xb9ffbb02 + #x9dff990e + #x49dd0a + #x661006ff + #x260ff + #xbb030bff + #x9dff990d + #x49dd0b + #x661006ff + #x260ff + #xbb030bff + #x990cb9ff + #xdd0b9dff + #x6ff0049 + #x60ff6610 + #xbff0002 + #xb9ffbb03 + #x9dff990c + #x49dd0b + #x661006ff + #x260ff + #xbb030bff + #x990cb9ff + #xdd0b9dff + #x6ff0049 + #x60ff6610 + #xbff0002 + #xb9ffbb03 + #x55019906 + #x94fd9903 + #x534444 + #x661006ff + #x260ff + #xbb030bff + #x9906b9ff + #x99ff5501 + #x54fd5502 + #x5a4444 + #x330b03ff + #xbff0001 + #xbffcbb03 + #x3f9ffff + #xff550199 + #xfd550299 + #x5a444454 + #xb03ff00 + #xff000133 + #xfcbb030b + #xf9ffffbf + #x55059903 + #x444454fd + #x30ff3302 + #x3ff0056 + #x1330b + #xbb030bff + #xffffbffc + #x59903f9 + #x4454fd55 + #xff330244 + #xff005630 + #x1330b03 + #x30bff00 + #xffbffbbb + #x255f5ff + #xfd550599 + #x5444454 + #x5330ff33 + #xb03ff00 + #xff000133 + #xf8bb030b + #xf5ffffbf + #x99995955 + #x54fd5505 + #x33054444 + #x5330ff + #x330b03ff + #xbff0001 + #xbff8bb03 + #x55f5ffff + #x5959955 + #x4454fd55 + #x2000244 + #x5370ff77 + #xb03ff00 + #xff000133 + #xfcbb030b + #xf5ffffbf + #x50ff550a + #x77020003 + #x5370ff + #x330b03ff + #xbff0001 + #xbfffbb03 + #x1ff02 + #x550805ff + #x77020003 + #x5c70ff + #x23303 + #xff02bb04 + #x5ff0002 + #x25508 + #x70ff7702 + #x3303005c + #xbff0002 + #xbffdbb03 + #x3ffff + #x550705ff + #x77020002 + #x4a70ff + #x3303cc11 + #xffcc02 + #xffbb0a + #x25507 + #x70ff7702 + #xcc11004a + #xcc023303 + #x90bc0fe + #x700ffbb + #x50fd55 + #xff770200 + #x11004a70 + #x33303cc + #x900ffcc + #x70001bb + #x50fe55 + #x70ff7702 + #xcc10004a + #x3303c3ff + #xc0fecc03 + #x1bb080b + #x705ff00 + #x288ff55 + #x4a70ff77 + #xffcc1000 + #xff3302c3 + #xffcc043c + #x3bb0800 + #xfe550500 + #x77028858 + #x4a70ff + #x3302cc11 + #xcc043cff + #x70bc0fe + #xff0003bb + #x1550405 + #x7787fd88 + #x11004b77 + #xff3302cc + #xfecc053c + #xbb060b00 + #x55030004 + #x880258ff + #x4b7077fe + #xfccc1100 + #x3c3333c3 + #x1cc05 + #x8bb06 + #x80ff8804 + #xcc11004b + #x3333c3fd + #xc4fdcc06 + #xbb050b44 + #x88040008 + #x4b80ff + #x7702cc11 + #xc4fdcc06 + #xbb050044 + #x88040008 + #x4b80ff + #x7702cc11 + #xc4fccc06 + #x40b0044 + #x14406bb + #xff880200 + #x4a660286 + #x2cc1100 + #x2cc0577 + #xff000144 + #x6bb030b + #x2000144 + #x4a660388 + #x2cc1100 + #x44cff44 + #x24402cc + #x7330200 + #x1000144 + #x386ff88 + #xa004a66 + #x66c6f9cc + #x88886866 + #xff440284 + #x2cc044c + #x2000244 + #x1440733 + #x4880100 + #xa004a66 + #xfc6602cc + #x84888868 + #x4cff4402 + #xc4fdcc04 + #x24444 + #x44073302 + #x66040003 + #xcc09004a + #x6602c6ff + #x888868fc + #xff440284 + #xffcc044c + #x24404c4 + #x3440733 + #x4a660400 + #x3cc0900 + #x8868fc66 + #x44028488 + #xcc044cff + #x4404c4ff + #x44073302 + #x66040003 + #xcc09004a + #x68fc6603 + #x2848888 + #x44cff44 + #x4c4ffcc + #x7330244 + #x4000344 + #x9004a66 + #xfc6603cc + #xc4cccc6c + #x4cff4402 + #xc4ffcc04 + #x33024404 + #x34407 + #x4a6604 + #x6603cc09 + #xcc0299ff + #x4444c4fd + #xc4ffcc05 + #x33024404 + #x6604440b + #xcc09004a + #x6666c6fa + #xa9c9969 + #x6c4ffcc + #xc34ff44 + #x5545fc44 + #x4a6666 + #xc6fecc0a + #xa990266 + #x6c4ffcc + #xc34ff44 + #x245ff44 + #xc004a55 + #xff9902cc + #xffcc0995 + #xff4406c4 + #xff440c34 + #x4a550245 + #x1cc0d00 + #x5c55fe99 + #xc4ffcc08 + #x34ff4406 + #x5502440d + #xcc0d004a + #x559599fc + #x7cc085c + #xd34ff44 + #x5545fd44 + #xd004a55 + #x2c9ffcc + #x7cc0855 + #xe34ff44 + #x4a550144 + #x3cc0d00 + #x75cff55 + #xff4407cc + #x1440e34 + #x7004a55 + #x35501cc + #xff5503cc + #xffcc075c + #xff4406c4 + #x1440e34 + #x6004a55 + #x55c5fccc + #xcc025c55 + #x5cff5503 + #xc4ffcc07 + #x34ff4406 + #x4c440e + #xc5ffcc06 + #x5cff5509 + #xc4ffcc07 + #x34ff4406 + #x4c440e + #xc5ffcc06 + #xcc085509 + #x4406c4ff + #x440e34ff + #xcc06004c + #x5502c5ff + #xc5fccc02 + #x85c5555 + #x6c4ffcc + #xe34ff44 + #x6004c44 + #x2c5ffcc + #xfdcc0255 + #x95555c5 + #x6c4ffcc + #xe34ff44 + #x6004c44 + #x55c5fdcc + #x6cc1055 + #x3343fe44 + #x4c440e + #xc5fdcc06 + #xcc105c55 + #x33014406 + #x4c440e + #xc4ffcc19 + #x33014406 + #x440d34ff + #xcc18004c + #x4406c4ff + #x333343fc + #x4c440d34 + #xfdcc0600 + #xe7c77c7 + #x6c4ffcc + #xd330344 + #x6004c44 + #x77c7fdcc + #x7cc0e7c + #xd330344 + #x6004c44 + #x77c7fccc + #xcc0d7c77 + #x33074407 + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #x4407cc0c + #x330643ff + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #xc4ffcc0b + #x33064408 + #x4c4409 + #xc7ffcc06 + #x7cff7702 + #xc4ffcc0b + #x43ff4409 + #x44093304 + #xcc05004c + #x233c3fe + #xb7cff77 + #xac4ffcc + #x9330444 + #x5004c44 + #x33c3facc + #x7c777737 + #xc4ffcc0b + #x43fd440b + #x440a3333 + #xcc05004c + #x37fc3301 + #xb7c7777 + #xbc4ffcc + #x3343fd44 + #x4c440a33 + #xffcc0400 + #xfe3302c3 + #xcc0c7737 + #x440bc4ff + #x330243ff + #x4c4409 + #x66fecc02 + #xff3304cc + #xffcc0c3c + #xff440bc4 + #xff330243 + #x4000330 + #x2004c44 + #x6c66fecc + #x3cff3304 + #x440dcc0c + #x36ff3302 + #x44046603 + #xcc01004c + #x6c66c6fd + #x3cff3304 + #x440dcc0c + #x333343fc + #x4660336 + #x1004c44 + #x46602cc + #xb3cff33 + #xec4ffcc + #xa330244 + #x4960ff66 + #xc6ccfe00 + #xccfb6602 + #x666636c3 + #xc4ffcc0c + #x3302440e + #x660936ff + #x4960ff + #x6603ccff + #x6601cc02 + #xc4ffcc0c + #x66fd440e + #x660a3633 + #x4960ff + #x6602ccff + #xcc026cff + #xcc0d6601 + #x66fe440e + #xff660b36 + #xff004960 + #xff6602cc + #x1cc026c + #xecc0d66 + #xff660d44 + #xff004960 + #xff6602cc + #x1cc026c + #xffcc0d66 + #x94403c4 + #xff660d00 + #xfe004960 + #x6602c6cc + #xcccc6cfb + #xcc0e6666 + #x94403 + #x60ff660d + #xcc020049 + #xcc016602 + #xcc0e6601 + #x4402c4ff + #x660d0009 + #x4960ff + #xc6ffcc02 + #xcc0e6605 + #x4402c4ff + #x660d0009 + #x4960ff + #x6605cc03 + #x4401cc0f + #x940ff + #x60ff660d + #xcc030049 + #x6604c6ff + #x4401cc0f + #x1040ff + #x660506ff + #x4960ff + #xc6ffcc03 + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #x6ff004d + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #x6ff004d + #xcc0f6604 + #x6ff0013 + #x60ff6605 + #xcff0051 + #x13cc10 + #x660506ff + #x5160ff + #xcc100cff + #x6ff0013 + #x60ff6605 + #xcc08005a + #x6ff0013 + #x60ff6605 + #xcc08005a + #x6ff0013 + #x60ff6605 + #x6ff0077 + #x60ff6605 + #x6ff0077 + #x60ff6605 + #x6ff0077 + #x88fe6604 + #xff007780 + #xfe660406 + #x778088 + #x660306ff + #x808868fd + #x7ff0064 + #x3770d + #x660306ff + #x80ff8801 + #x7ff0064 + #x8804770d + #x88016603 + #x6480ff + #x770d07ff + #x86fe8805 + #xff880266 + #xff006480 + #xa770d07 + #x6480ff88 + #xd07ff00 + #xff880a77 + #xff006480 + #x9770e07 + #x6480ff88 + #x307ff00 + #x5755fe77 + #x78ff7708 + #x80ff8808 + #x7ff0064 + #x55017703 + #x88087709 + #x6480ff + #x770207ff + #x555575fc + #x8770857 + #x6480ff88 + #x207ff00 + #x8550377 + #x778ff77 + #x6480ff88 + #x7707fc00 + #x55037577 + #x770757ff + #x6d70ff + #x777707fd + #x77075505 + #x6d70ff + #x757707fd + #x57ff5505 + #x70ff7706 + #x7fd006d + #x55067577 + #x70ff7706 + #x7fd006d + #x55067777 + #x70ff7706 + #x7fc006d + #x5757777 + #xff770655 + #xfc006d70 + #x75777707 + #x57ff5504 + #x70ff7706 + #x7ff006d + #x55047702 + #x70ff7707 + #x7ff006d + #x75ff7702 + #x77085502 + #x6d70ff + #x770307ff + #x57ff5501 + #x70ff7708 + #x7ff006d + #x75fe7703 + #xff770955 + #xff006d70 + #xff770407 + #xff770957 + #xff006d70 + #xff770f07 + #xff006d70 + #xff770f07 + #x7f007f70 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2a00 + #x0 + #x0 + ) + :layer5 (new 'static 'array uint32 932 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x15007f00 + #x6770600 + #x3323ff22 + #xb30ff33 + #x406ff00 + #x2860ff66 + #x6770600 + #x3323ff22 + #xb30ff33 + #x406ff00 + #x2860ff66 + #x6770600 + #x4023ff22 + #x436ff33 + #x2860ff66 + #x6770600 + #x2423ff22 + #x13550733 + #x436ff33 + #x2860ff66 + #x6770600 + #x2223ff22 + #x935ff33 + #x1253ff55 + #xff660433 + #x6002860 + #xff220677 + #xff332023 + #x11550d35 + #x336ff33 + #x2860ff66 + #x6770600 + #x1e23ff22 + #x1035ff33 + #x3331155 + #x2860ff66 + #x6770600 + #x1d23ff22 + #x1235ff33 + #xf53ff55 + #x236ff33 + #x2860ff66 + #x6770600 + #x1c23ff22 + #x4551733 + #x335ff33 + #x2330455 + #x2860ff66 + #x46770600 + #xfc330455 + #x60666636 + #x77060028 + #x33055546 + #x60ff6601 + #x77060028 + #x33055546 + #x606636fd + #x77060028 + #x33065546 + #x286066fe + #x46770600 + #xff330655 + #x6002930 + #x6554677 + #x2a30ff33 + #x46660500 + #xff330655 + #x5002a30 + #x6554666 + #x2a30ff33 + #x3660500 + #xa54afb44 + #x38aa5a55 + #x305ff00 + #xff330655 + #x5002a30 + #xfb440366 + #x5a55a54a + #xff0038aa + #x6550305 + #x2a30ff33 + #x6660200 + #xa54afb44 + #x3baa5a55 + #xff330800 + #x2002a30 + #xff440666 + #x28aa034a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x6660200 + #x34aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x2002a30 + #xff440666 + #x28aa034a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x1660500 + #x54aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x5002a30 + #xff440166 + #x28aa054a + #xe01ff00 + #x8000211 + #x2a30ff33 + #x1660500 + #x54aff44 + #xff0028aa + #x2110e01 + #xff330800 + #x5002a30 + #x3040ff66 + #xe01ff00 + #x8000211 + #x2a30ff33 + #xff660500 + #xff003040 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #x2110e01 + #xff330800 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xff110601 + #x6660216 + #xff330844 + #xff006230 + #xfc110701 + #x64666616 + #x33084405 + #x6230ff + #x110701ff + #x666616fc + #x8440564 + #x6230ff33 + #x701ff00 + #x6616fc11 + #x44056466 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x1ff0062 + #x16ff1106 + #x44066602 + #x30ff3308 + #x4ff006d + #x33084406 + #x6d30ff + #x440604ff + #x30ff3308 + #x4ff006d + #x33084406 + #x6d30ff + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x6f2207 + #x440604ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x24ff2207 + #x22074406 + #x3309005c + #x220732ff + #x440624ff + #x5c2207 + #x32ff3309 + #x582217 + #x110301ff + #x32ff3308 + #x582217 + #x110301ff + #x330713ff + #x220732ff + #x440624ff + #x582207 + #x110401ff + #x32ff3307 + #x24ff2207 + #x77044406 + #x5a70ff + #x110401ff + #x32ff3307 + #x27ff2207 + #x70ff770b + #x1ff005a + #x33071104 + #x220732ff + #x770b27ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x5a70ff + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #xf10ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x440b14ff + #x240ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x40ff440c + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x440c1104 + #x240ff + #x770b07ff + #x2e70ff + #x67ff6611 + #x17716 + #x110401ff + #x40ff440c + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x40ff440b + #x7ff0002 + #x70ff770b + #x6611002e + #x771667ff + #x1ff0001 + #x14ff1104 + #x5503440b + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440b04ff + #x550245ff + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440b04ff + #x550245ff + #x770b57ff + #x2e70ff + #x76613 + #x7770d + #x440a04ff + #x550354ff + #x770b57ff + #x2e70ff + #x76613 + #x13770d + #x57ff5504 + #x70ff770b + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x13770d + #x55506 + #xa0ffaa04 + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x13770d + #x55506 + #xa0ffaa04 + #x6613002e + #x770d0007 + #x55060013 + #xaa040005 + #x2ea0ff + #x76613 + #x7aff7707 + #xa0ffaa03 + #x55060013 + #x66010003 + #xa6fdaa04 + #x2c6066 + #xc6613 + #x444404fc + #xffaa034a + #x60013a0 + #x2000355 + #xfcaa0266 + #x606666a6 + #x6613002c + #x4fc000c + #x34a4444 + #x13a0ffaa + #x3550600 + #xff660800 + #x13002c60 + #xfc000c66 + #x4a444404 + #xa0ffaa03 + #x55060013 + #x66080003 + #x2c60ff + #xc5513 + #x444404fc + #xffaa034a + #x60013a0 + #x8000355 + #x2c60ff66 + #xc551300 + #x4404fc00 + #xaa034a44 + #x13a0ff + #x35506 + #x60ff6608 + #x5513002c + #x4fc000c + #x34a4444 + #x13a0ffaa + #x3550600 + #xff660800 + #xfd002c60 + #x10757755 + #xfc000c55 + #x4a444404 + #xa0ffaa03 + #x55060013 + #x66080003 + #x2c60ff + #x757755fd + #xc5510 + #x444404fc + #xffaa034a + #x60013a0 + #x8000355 + #x2c60ff66 + #x7757fd00 + #xc551075 + #x4404fc00 + #xaa034a44 + #x13a0ff + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x57fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107577 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107777 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fd002e + #x55107757 + #x4ff000c + #x134407 + #x55506 + #x30ff3304 + #x55fc002e + #xf757757 + #xff000c55 + #x13440704 + #x5550600 + #xff330400 + #x1002e30 + #xf770155 + #xff000c55 + #xff440304 + #x12330343 + #x5550600 + #xff330400 + #x1002e30 + #x7757fe55 + #xc550f + #x440304ff + #x330343ff + #x6604000d + #x55506 + #x30ff3304 + #x5502002e + #x550f75ff + #x4ff000c + #x43ff4403 + #xd3303 + #x55066604 + #xdfe0003 + #xff3304dd + #x13002e30 + #xff000c55 + #xff440304 + #xd330343 + #x6660400 + #xfd000355 + #x2dddd0d + #xdd3dfd33 + #x13002ddd + #xfa000c55 + #x55454404 + #x33034344 + #x6604000d + #x35506 + #xdd070dff + #x5513002d + #x4fa000c + #x44544544 + #xd330343 + #x6660400 + #xff000355 + #x2ddd070d + #xfe550a00 + #x5506aa5a + #x4fa000c + #x44545544 + #xb330343 + #xffaa0100 + #x66603a6 + #xff000355 + #x2ddd070d + #xff550800 + #xffaa045a + #xfa0010a0 + #x54554404 + #x33034344 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5508002d + #xaa045aff + #x10a0ff + #x556606fd + #x33036602 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5507002d + #xaa055aff + #x10a0ff + #x660406ff + #xb3303 + #xa6ffaa01 + #x55066603 + #xdff0003 + #x2ddd07 + #x5aff5507 + #xa0ffaa05 + #x6ff0010 + #x33036604 + #xaa01000b + #x6603a6ff + #x35506 + #xdd070dff + #x5507002d + #xaa055aff + #x10a0ff + #x660406ff + #x330263ff + #xaa01000b + #xea0ff + #xaa050aff + #x2ea0ff + #x5aff5507 + #xa0ffaa05 + #x6ff0010 + #x63ff6604 + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #x5507002e + #xaa055aff + #x10a0ff + #x660506ff + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #xaff0036 + #xa0ffaa05 + #x6ff0010 + #x33026605 + #xaa01000b + #xea0ff + #xaa050aff + #x36a0ff + #xaa050aff + #x10a0ff + #x660506ff + #xb3302 + #xa0ffaa01 + #xaff000e + #xa0ffaa05 + #x1103002e + #x210ff + #xaa050aff + #x10a0ff + #x660406ff + #x330263ff + #xaa01000b + #xea0ff + #xaa050aff + #x2ea0ff + #x10fd1103 + #x44020000 + #xaa034aff + #x10a0ff + #x660406ff + #x333363fc + #xffaa0d3a + #xff000ea0 + #xffaa050a + #x3002ea0 + #x10fd11 + #x12440600 + #x406ff00 + #xff330266 + #xffaa0d3a + #xff000ea0 + #xffaa050a + #x3002ea0 + #x10fd11 + #x12440600 + #x306ff00 + #x263ff66 + #xd3aff33 + #xa0fdaa + #xff220c00 + #xffaa052a + #x3002ea0 + #x10fd11 + #x12440600 + #x306ff00 + #x263ff66 + #x1030ff33 + #xfe220d00 + #xaa03ee2e + #x2ea0ff + #x10fd1103 + #x44060000 + #x2ff002c + #x2efd220d + #x32e0ee + #x16fd1103 + #x44066666 + #xff0b0020 + #x220df2ff + #xe0ee2efd + #x11030032 + #x660616ff + #x204401 + #x5502f5ff + #x12ff1107 + #x2efd220d + #x32e0ee + #x16ff1103 + #x44016606 + #xf5ff0020 + #x11075502 + #x220d12ff + #xe0ee2efd + #x11030032 + #x660616ff + #x204401 + #x5502f5ff + #x1ffa1102 + #x11f1ffff + #xfc220c12 + #x2022dd2d + #x11030032 + #x77033302 + #x2270ff + #x5502f5ff + #x1ffa1102 + #x11b1bbff + #xfc220c12 + #x2022dd2d + #x11030032 + #x77033302 + #x2270ff + #xbbfcff08 + #xc1211b1 + #xdd2dfc22 + #x322022 + #x33021103 + #x70ff7703 + #xff080022 + #xffbfbbfc + #xff220ff2 + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x220cf2ff + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x2222f2fb + #x22083323 + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfeff0100 + #xff07efee + #x2222f2fb + #x22083323 + #x22a2aafc + #x3003220 + #x3330211 + #x2270ff77 + #xfbff0b00 + #x232222f2 + #x2220833 + #x3920ffaa + #xff220300 + #x2002220 + #xddfdfeff + #xf2fcff06 + #x9424422 + #xffaa0222 + #x3003920 + #x1820ff22 + #x804ff00 + #xfeff0244 + #xff06ddfd + #x4422f2fc + #x2220942 + #x3920ffaa + #xff220300 + #xff001820 + #x2440804 + #xddfdfeff + #xf2fcff06 + #x9424422 + #xffaa0222 + #x3003920 + #x320ff22 + #x7550c00 + #x804ff00 + #xffff0b44 + #x2220cf2 + #x3920ffaa + #xff220300 + #xc000320 + #x700fe55 + #x17703 + #x440804ff + #xf2feff0b + #xff770627 + #x2220372 + #x3920ffaa + #xff220300 + #xc000320 + #x700fe55 + #xaa017703 + #x4408a4ff + #xf2feff0b + #xff770627 + #xff220672 + #x3003920 + #x320ff22 + #xff550d00 + #xfd770357 + #x8a4aa7a + #xfeff0b44 + #x770a27f2 + #x20ff2203 + #x22030039 + #x320ff + #x57ff550d + #x7afd7703 + #x4408a4aa + #xf2feff0b + #x3770a27 + #x3920ff22 + #xff220300 + #xd000320 + #x357ff55 + #xaa7afd77 + #xb4408a4 + #x27f2feff + #x2203770a + #x3820ff + #x551605ff + #x770357ff + #xa4aa7afd + #xff0b4408 + #xa27f2fe + #xff220377 + #xff003820 + #xff551605 + #xfd770357 + #x8040070 + #x55f0ff44 + #x1605ff00 + #x357ff55 + #x70fd77 + #xff440804 + #xff0055f0 + #xff551605 + #xfd770357 + #x8040070 + #x66f0ff44 + #x505ff00 + #x357ff55 + #x7f70ff77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x3c007f00 + #x0 + #x0 + #x0 + #x0 + ) + :layer6 (new 'static 'array uint32 1072 + #x452301f8 + #xcdab8967 + #xf0035ef + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x6e20ff22 + #xff220f00 + #xf006e20 + #x5620ff22 + #x1004ff00 + #xf330544 + #x5620ff22 + #x1004ff00 + #xf330544 + #x5620ff22 + #x1004ff00 + #xff330544 + #xff220e32 + #xff005620 + #x6441004 + #xff220e33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #x7441004 + #xff220d33 + #xff005620 + #xff441004 + #xff330643 + #xfc220b32 + #x30333323 + #x4ff0054 + #x33064411 + #x220b32ff + #x30ff3302 + #x4ff0054 + #x43ff4411 + #x220a3306 + #x30ff3303 + #x44120011 + #x2e40ff + #x441104ff + #x330643ff + #x33042209 + #x1130ff + #x40ff4412 + #x4ff002e + #x33064412 + #x33052208 + #x1130ff + #x40ff4412 + #x4ff002e + #x33064413 + #x33062206 + #x30fd + #x4412770f + #x2e40ff + #x441604ff + #x22043304 + #x30fd3307 + #x770f0000 + #x40ff4412 + #x4ff002e + #x43ff4416 + #x30fd3310 + #x770f0000 + #x40ff4412 + #x4ff002e + #x43ff4416 + #x4406330c + #x4412770f + #x2e40ff + #x441604ff + #x4406330d + #x4412770f + #x2e40ff + #x441604ff + #x34fe330b + #xf440633 + #xff441277 + #xff002e40 + #xb441604 + #xf440833 + #xff441277 + #x4002b40 + #xa441577 + #x834ff33 + #x12770f44 + #x2b40ff44 + #x15770400 + #x943ff44 + #x834ff33 + #x12770f44 + #x2b40ff44 + #x16770400 + #xfd330744 + #x8344344 + #x12770f44 + #x2b40ff44 + #x16770400 + #x443ff44 + #xc34ff33 + #x12770f44 + #x2b40ff44 + #xff770400 + #x1441774 + #xa34ff33 + #x12771344 + #x2b40ff44 + #xfc770500 + #x77474474 + #x77024407 + #x43fd4408 + #x44093433 + #x771247ff + #x441274ff + #x2b40ff + #x4403770b + #x770347ff + #x440874ff + #x440a34ff + #x44137713 + #x2b40ff + #x74ff770c + #x44137707 + #x74ff7713 + #x40ff4413 + #x7715002b + #x441174ff + #x771347ff + #x40ff4414 + #x7716002b + #x77134411 + #x441474ff + #x2b40ff + #x74ff7716 + #x47ff440f + #x44157713 + #x2b40ff + #x440f7717 + #x770247ff + #x550275ff + #x74ff770b + #x74ff4403 + #x40ff4410 + #x7712002b + #x555575fb + #x440f7757 + #x770247ff + #x770b5503 + #x47fe4403 + #xff441077 + #x8002b40 + #x537ff33 + #x475ff77 + #x7757fd55 + #xfd440e74 + #x5777747 + #x450ff55 + #x704ff00 + #x10770144 + #x2b40ff44 + #x1330a00 + #xfd550877 + #xe747757 + #xff770144 + #xff550575 + #xff000450 + #xfc440604 + #x74777747 + #x40ff440f + #x330c002b + #x57fd5508 + #x440d7477 + #x777747fd + #x50ff5506 + #x4ff0004 + #x77024406 + #x440f74ff + #x2b40ff + #x5508330c + #x747757fd + #x47ff440c + #x55067702 + #x450ff + #x440504ff + #x770247ff + #x440f74ff + #x2b40ff + #x5508330c + #x747757fd + #x7702440c + #x50ff5507 + #x4ff0004 + #x77034405 + #x440f74ff + #x2b40ff + #x5509330c + #xb7477fe + #x247ff44 + #xff550777 + #xff000450 + #xff440404 + #x10770347 + #x2b40ff44 + #x9330c00 + #x7477fe55 + #x7702440b + #x550775ff + #x450ff + #x440404ff + #x770247ff + #x441074ff + #x2b40ff + #x35ff330a + #x7701550a + #x440947ff + #x770247ff + #x550775ff + #x450ff + #x440404ff + #x770247ff + #x40ff4411 + #x3309002b + #x550b35ff + #x44087703 + #x55087703 + #x450ff + #x440404ff + #x44117703 + #x2b40ff + #x550c3309 + #x74ff7703 + #x47ff4406 + #x75ff7702 + #x50ff5508 + #x4ff0004 + #x77034404 + #x40ff4411 + #x3309002b + #x7704550c + #x47ff4405 + #x55097703 + #x450ff + #x440304ff + #x770347ff + #x40ff4411 + #x3309002b + #x57ff550c + #x74ff7703 + #x77044403 + #x550975ff + #x450ff + #x440304ff + #x44117704 + #x2b40ff + #x550c3309 + #x770457ff + #x47ff4402 + #x550a7704 + #x450ff + #x440304ff + #x44117704 + #x2b40ff + #x550c3309 + #x770457ff + #x444474fd + #x550a7705 + #x450ff + #x440304ff + #x74ff7704 + #x40ff4410 + #x3309002b + #x57ff550c + #x75ff770c + #x50ff550a + #x4ff0004 + #x77044403 + #x441074ff + #x2b40ff + #x550c3309 + #x770b57ff + #x550b75ff + #x450ff + #x440204ff + #x770447ff + #x441074ff + #x2b40ff + #x550c3309 + #x770b57ff + #x50ff550c + #x4ff0004 + #x47ff4402 + #x44087705 + #x777747fd + #x40ff4404 + #x3309002b + #x770a550d + #x50ff550d + #x4ff0004 + #x47ff4402 + #x74ff7705 + #x47ff4406 + #x44037703 + #x2b40ff + #x550d3309 + #x550e7709 + #x450ff + #x440204ff + #x44057707 + #x770447ff + #x440274ff + #x2b40ff + #x550d3309 + #x770757ff + #x50ff550f + #x4ff0004 + #x77074402 + #x440374ff + #x74fc7707 + #x2b404444 + #xe330900 + #xff770655 + #xff550f75 + #xfc000450 + #x47444404 + #x74fd7708 + #x770b4744 + #x2b70ff + #x55113309 + #x777757fc + #xff551075 + #xfc000450 + #x47444404 + #x73fd770f + #x77043333 + #x2b70ff + #x55263309 + #x450ff + #x444404fd + #x33027710 + #x770337ff + #x2b70ff + #x55263309 + #x450ff + #x474404fd + #x3304770f + #x70ff7703 + #x3309002b + #x50ff5526 + #x7ff0004 + #x73ff7710 + #x77033304 + #x2b70ff + #x34ff3308 + #x55234402 + #x450ff + #x771007ff + #x77033305 + #x2b70ff + #x34fd3301 + #x44073443 + #x552245ff + #x450ff + #x770f07ff + #x330573ff + #x70ff7703 + #x44120026 + #x59ff5518 + #x50ff5508 + #x3fe0004 + #x6770e33 + #xff770333 + #x12002670 + #xff551044 + #xff550659 + #xff550899 + #xfd000450 + #xc333303 + #x673ff77 + #xff770333 + #x12002670 + #xff551044 + #x1990359 + #x9959fd55 + #xff550799 + #xfc000450 + #x37333303 + #x73ff770b + #x77033306 + #x2670ff + #x55104412 + #x95ff990a + #x50ff5505 + #x3ff0004 + #x770b3302 + #x77033307 + #x2670ff + #x550f4412 + #x990b59ff + #xa90ff + #x330203ff + #x3307770b + #x70ff7703 + #x44130026 + #x55080005 + #x90ff990c + #x3ff000a + #x770b3302 + #x37ff3306 + #x70ff7703 + #x44170026 + #x9ff0001 + #x59ff9904 + #x90ff990e + #x3fc000a + #xb373333 + #xff330677 + #xff770337 + #x17002670 + #xff000144 + #xff991409 + #xfd000a90 + #xc333303 + #x4330677 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #x3303fd00 + #x5770c33 + #x437ff33 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #x3303fe00 + #x13ff770d + #x77053304 + #x2670ff + #x14417 + #x991409ff + #xa90ff + #xd3703fe + #x311ff77 + #x537ff33 + #x2670ff77 + #x1441700 + #x1409ff00 + #xa90ff99 + #xe07ff00 + #x311ff77 + #xff770633 + #x17002670 + #xff000144 + #xff991409 + #xff000a90 + #xfc770e07 + #x33737711 + #x70ff7707 + #x44170026 + #x9ff0001 + #x90ff9914 + #x6ff000a + #x67ff6602 + #x11ff770a + #x70ff770a + #x44170026 + #x9ff0001 + #x90ff9914 + #x6ff000a + #x67ff6603 + #x11ff7709 + #x70ff770a + #x441a0026 + #x90ff9914 + #x6ff000a + #x77096604 + #x770a11ff + #x2670ff + #x9914441a + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x49ff441a + #x90ff9913 + #x6ff000a + #x67ff6604 + #x11ff7708 + #x70ff770a + #x441b0026 + #x90ff9913 + #x6ff000a + #x67ff6604 + #x11ff7708 + #x70ff770a + #x441b0026 + #x991249ff + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x770a11ff + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x91711fe + #x2670ff77 + #x12441c00 + #xa90ff99 + #x406ff00 + #x867ff66 + #x1711fe77 + #x70ff7709 + #x441c0026 + #x90ff9912 + #x6ff000a + #x67ff6604 + #x11fd7708 + #x77084744 + #x2670ff + #x9912441c + #xa90ff + #x660406ff + #x770867ff + #x444411fc + #xff770747 + #x1c002670 + #xff991244 + #xff000a90 + #xff660406 + #x3770867 + #x647ff44 + #x2670ff77 + #x12441c00 + #xa90ff99 + #x306ff00 + #x822ff66 + #x474ff77 + #xff770644 + #x1c002670 + #xff991244 + #xff000a90 + #xff660306 + #xff770822 + #x5440574 + #x2670ff77 + #x1e441c00 + #x206ff00 + #x2277fe66 + #x44067708 + #x70ff7705 + #x441c0026 + #x7ff001e + #x22ff7703 + #x44067708 + #x70ff7705 + #x441c0026 + #x7ff001e + #x22ff7703 + #x44067708 + #x770447ff + #x2670ff + #x1e441c + #x770307ff + #x72722fe + #x674ff77 + #xff770444 + #x1c002670 + #xff001e44 + #xfe770307 + #x77072772 + #x440674ff + #x770347ff + #x2670ff + #x1e441c + #x770307ff + #x82772fe + #x3440777 + #x2670ff77 + #x1e441c00 + #x307ff00 + #x2272fe77 + #x74ff7708 + #x77034406 + #x2670ff + #x1e441c + #x770307ff + #x92272fe + #x3440677 + #x2670ff77 + #x1440700 + #x915ff11 + #x951ff55 + #xff001b11 + #xff770407 + #xff770922 + #x3440574 + #x2670ff77 + #x1440700 + #x915ff11 + #x951ff55 + #xff001b11 + #xfe770407 + #x77092722 + #x47ff4404 + #x70ff7703 + #x44060026 + #x15ff1102 + #x51ff5509 + #x1b1109 + #x770407ff + #x92772fe + #x374ff77 + #x347ff44 + #x2670ff77 + #xff440500 + #xff110241 + #xff550915 + #x1b110951 + #x407ff00 + #x2272fe77 + #x74ff770a + #x77044402 + #x2670ff + #x41ff4404 + #x15ff1103 + #x51ff5509 + #x1b1109 + #x770407ff + #x272272fd + #x4402770a + #x70ff7704 + #x11090026 + #x550915ff + #x110951ff + #x7ff001b + #x22fe7705 + #xfe770a27 + #x77059479 + #x2670ff + #x15ff1109 + #x51ff5509 + #x1b1109 + #x770507ff + #x770a2201 + #x59779fe + #x2670ff77 + #xff110900 + #xff550915 + #x1e110951 + #x247ff44 + #x2272fe77 + #x99fe770a + #xff770597 + #x9002670 + #x915ff11 + #x20110a55 + #xfe770244 + #x77092722 + #x59799fe + #x2670ff77 + #x9110900 + #xa51ff55 + #xfb442011 + #x72777747 + #xff770927 + #xff770699 + #x8002670 + #x5155fb11 + #x2515555 + #xb550211 + #x1442111 + #x2272fe77 + #x99ff7709 + #x70ff7706 + #x11070026 + #x65115fe + #x5515fd11 + #x22110b51 + #x7747fd44 + #xfe770822 + #x77069979 + #x2670ff + #x55ff1107 + #x55ff1108 + #x4423110c + #x272277f9 + #x57557577 + #x79fe7703 + #xff770699 + #x6002670 + #x5155fe11 + #x44231116 + #x257247fd + #x57ff5503 + #x79fe7702 + #xff770699 + #x5002670 + #x5515fe11 + #x44231117 + #x550645ff + #x99fe7702 + #xff770697 + #x5002670 + #x1855ff11 + #xff442311 + #x1550745 + #x9799fe77 + #x70ff7706 + #x55030026 + #x511551fd + #x44231118 + #x550945ff + #x69759fe + #x2670ff77 + #x19550500 + #xff442311 + #x6550b45 + #x2670ff77 + #xff550400 + #x5111951 + #x242ff44 + #xc441922 + #x557ff55 + #x2670ff77 + #x19550500 + #x5440411 + #x1724ff22 + #x5550d44 + #x2670ff77 + #xff550500 + #x3111851 + #xff220744 + #xd441624 + #xff770555 + #x5002670 + #x1851ff55 + #x9440211 + #xff441622 + #xff550c45 + #xff770457 + #x6002670 + #x1111855 + #xff220a44 + #xff441524 + #x4550d45 + #x2670ff77 + #x18550600 + #xc14ff11 + #xff441522 + #xff550d45 + #xff770357 + #x6002670 + #xff111855 + #x15220c12 + #xd45ff44 + #x357ff55 + #x2670ff77 + #x17550600 + #x612ff11 + #x4244fe22 + #x24ff2204 + #x45ff4414 + #x7703550e + #x2670ff + #x51ff5505 + #x22051118 + #x42ff4401 + #x24ff2204 + #x550d4415 + #x770357ff + #x2670ff + #x51ff5504 + #x12ff1119 + #x44032203 + #x24ff2204 + #x550d4415 + #x770357ff + #x2670ff + #x12ff111f + #x44042202 + #x24ff2204 + #x550b4415 + #x70ff7706 + #x11200026 + #x44052201 + #x24ff2204 + #x550b4415 + #x70ff7706 + #x11220026 + #x22034406 + #x441524ff + #x550a45ff + #x70ff7706 + #x11220026 + #x440614ff + #x44152203 + #x550a45ff + #x70ff7706 + #x44050026 + #x14ff111c + #x22fd4407 + #x44152224 + #x550a45ff + #x70ff7706 + #x44050026 + #x14ff111c + #x22fe4409 + #xa441524 + #xff770655 + #x5002670 + #xff111c44 + #xfe440914 + #x44152442 + #x77085508 + #x2670ff + #x111d4405 + #x42fe4409 + #xff441522 + #xff550645 + #xff770857 + #x5002670 + #xa111d44 + #x1622ff44 + #x545ff44 + #xff770955 + #x5002670 + #xa111d44 + #x1a22ff44 + #x5545fd44 + #xff770955 + #x23002670 + #xff440a11 + #x9441d22 + #x2670ff77 + #xa112300 + #x2022ff44 + #xff770644 + #x23002670 + #xfd440911 + #x1f222242 + #xff770644 + #x23002670 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #x9112300 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x547ff44 + #x2670ff77 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #xff770547 + #x4002670 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x2d40ff44 + #xff330400 + #x9111d31 + #x2242fd44 + #xff441f22 + #x4002d40 + #x1d31ff33 + #xfd440911 + #x1f222242 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xa111d31 + #x2022ff44 + #x2d40ff44 + #xff330400 + #xff111c31 + #xfe440914 + #x44202242 + #x2d40ff + #x31ff3304 + #x14ff111c + #x42fe4409 + #xff442024 + #x4002d40 + #x1c31ff33 + #x714ff11 + #x2422fc44 + #x440a2442 + #x333343fc + #xff441134 + #x4002d40 + #x1c31ff33 + #xfc440811 + #x24222422 + #x33044409 + #x441034ff + #x2d40ff + #x111c3305 + #x42ff4407 + #x24ff2202 + #x330c4405 + #x440c34ff + #x2d40ff + #x111b3305 + #x440714ff + #x24ff2203 + #x43ff4403 + #x34ff330d + #x40ff440c + #x3305002d + #x111a31ff + #x22044407 + #x43ff4404 + #x440c330e + #x2d40ff + #x31ff3305 + #x21fe1118 + #xff440611 + #x3220542 + #xe43ff44 + #xb34ff33 + #x2d40ff44 + #x18330600 + #x6220111 + #x542ff44 + #x224ff22 + #xff330e44 + #xff440c34 + #x7002d40 + #xff111633 + #xff220212 + #xff440424 + #xff220542 + #xe440224 + #xc34ff33 + #x2d40ff44 + #x15330800 + #xff220411 + #x6440324 + #x4e20ff22 + #xff330800 + #xff111331 + #x1220612 + #x642ff44 + #x4e20ff22 + #xff330800 + #xff111331 + #xfe220712 + #x22064244 + #x4e20ff + #x31ff3308 + #x22101114 + #x4e20ff + #x31ff3308 + #x44ff1114 + #x20ff220f + #x3309004e + #x14fd1113 + #x220e4444 + #x4e20ff + #x11123309 + #x42ff4404 + #x20ff220c + #x3309004e + #x14ff1110 + #x42ff4406 + #x20ff220b + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x3309004e + #x4409110f + #x220a42ff + #x4e20ff + #x110f3309 + #x42ff4409 + #x20ff220a + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x30 + #x0 + ) + :layer7 (new 'static 'array uint32 684 + #x452301f8 + #xcdab8967 + #x210030ef + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x21005d66 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #x21004622 + #x14000166 + #xf002822 + #x21000d44 + #x8000166 + #xc000122 + #xf002522 + #x21000d44 + #x7000166 + #x20fd22 + #x25220c00 + #xd440f00 + #x1662100 + #x2220700 + #x25220c00 + #xd440f00 + #x1662100 + #xff220600 + #xc000220 + #xf002522 + #x21550d44 + #x6000166 + #xc000322 + #xf002522 + #x21550d44 + #x5000266 + #xc000322 + #xf002522 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xf002544 + #x20551144 + #x3220566 + #x25440c00 + #x11440f00 + #x5662055 + #xc000322 + #xe002544 + #x1145ff44 + #x5662055 + #x7000522 + #xe002844 + #x20551244 + #x5220566 + #x28440700 + #xff440d00 + #x20551245 + #x5220566 + #x28440700 + #x13440d00 + #x5662055 + #x7000522 + #xc002844 + #x1345ff44 + #x7660c55 + #x5660b00 + #x7000522 + #xc002844 + #xc551444 + #xb000766 + #x5220566 + #x28440700 + #xff440a00 + #xc551500 + #x7001f66 + #xa002844 + #x1500ff44 + #x1f660c55 + #x28440700 + #xff440a00 + #xc551500 + #xe001f66 + #xa002144 + #x1500ff44 + #x1f660c55 + #x21440e00 + #xff440a00 + #xc551500 + #xe001f66 + #xa002144 + #x1500ff44 + #x1f660c55 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #x2c551500 + #x21440e00 + #xff440a00 + #xa551500 + #xe332100 + #xa002144 + #x1400ff44 + #x21000b55 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x21440e33 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #xa551400 + #x2100ff22 + #x7220633 + #xa002144 + #x1400ff77 + #xff220a55 + #x6332100 + #x21440722 + #xff770a00 + #x9551500 + #x2100ff22 + #x7220633 + #xa002144 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002144 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x3000255 + #x21000322 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #x1500ff77 + #x700ff55 + #x21000122 + #x7220633 + #xa002166 + #xf00ff77 + #xfd660355 + #x7005565 + #x21000122 + #xff220633 + #x21660626 + #x10770a00 + #x7660600 + #x21000122 + #xff220633 + #x21660626 + #x2771800 + #x7660600 + #x21000122 + #xfd220633 + #x4000020 + #x18002166 + #x6000277 + #x1220766 + #x6332100 + #x20fd22 + #x21660400 + #x2771800 + #x7660600 + #x21000122 + #xfd220633 + #x4000020 + #x18002166 + #x6000277 + #x1220766 + #x6332100 + #x20fd22 + #x21660400 + #x2771800 + #x7660600 + #x21000122 + #x4000933 + #x18002166 + #xd000277 + #x21000266 + #x4000933 + #x18002166 + #xff000277 + #x2660c06 + #x9332100 + #x21660400 + #x2771800 + #xc06ff00 + #x21000266 + #x4000933 + #x18002166 + #xff000277 + #xff660e06 + #x9332160 + #x21660400 + #x3771800 + #xff660e00 + #x3331560 + #x9330766 + #x21660400 + #xfe771b00 + #x660d0600 + #x331460ff + #x660336ff + #x66040011 + #x771b0021 + #xd0070fe + #x1460ff66 + #x11660433 + #x21660400 + #xfe771c00 + #x660c0600 + #x331360ff + #x661b36ff + #x771c0021 + #xc0070fe + #x1360ff66 + #x1b36ff33 + #x1d002166 + #x600fe77 + #x60ff660b + #x36ff3313 + #x21661b + #x70fe771d + #xff660b00 + #xff331360 + #x21661b36 + #xfe771e00 + #x660a0600 + #x331360ff + #x661b36ff + #x771e0021 + #xa0070fe + #x1360ff66 + #x1b36ff33 + #x1f002166 + #xff000177 + #xff660806 + #xff331360 + #x21661b36 + #xfd771f00 + #x8060070 + #x1360ff66 + #x1b36ff33 + #xe002266 + #xf00ff44 + #x600fe77 + #x60ff6608 + #x36ff3313 + #x22661b + #xfe440e + #xff770f07 + #x13660976 + #x1b36ff33 + #xe002266 + #xff000144 + #xff770e07 + #x13660976 + #x1b36ff33 + #xe002266 + #xff000144 + #xff770e07 + #x13660976 + #x1b36ff33 + #x10002266 + #xe47ff44 + #x976ff77 + #x3330f66 + #x1b06ff00 + #x10002266 + #xe47ff44 + #x976ff77 + #x3330f66 + #xc06ff00 + #xffaa0266 + #x22660aa6 + #xff441000 + #xff770e47 + #xf660976 + #x22aa2033 + #xff441000 + #xff770e47 + #xf660976 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xf660946 + #x22aa2033 + #xff442000 + #xe660946 + #x203aff33 + #x200022aa + #x646ff44 + #xe000266 + #x22aa2133 + #xff442000 + #x2660646 + #x21330e00 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x200022aa + #x646ff44 + #x3200ff66 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x3a442100 + #x210022aa + #x22aa3a44 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #x22aa5c00 + #xffaa3100 + #xff7728a7 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #x2b002270 + #xff0005aa + #xff772807 + #xb002270 + #x14000aaa + #xff0005aa + #xff772807 + #xb002270 + #x14000aaa + #xff0005aa + #xff772807 + #x19002270 + #x5aa1155 + #x2807ff00 + #x2270ff77 + #xff551900 + #x5aa105a + #x2807ff00 + #x2270ff77 + #xf551a00 + #xff2206aa + #xff772827 + #x1a002270 + #xd5aff55 + #x6a2ffaa + #x2827ff22 + #x2270ff77 + #xff551a00 + #xff221552 + #xff772827 + #x1b002270 + #xff221555 + #xff772827 + #x1b002270 + #x1452ff55 + #x2827ff22 + #x2270ff77 + #x14551c00 + #x2827ff22 + #x2270ff77 + #xff551c00 + #xff221352 + #xff772827 + #x1d002270 + #xff221355 + #xff772827 + #x1c002270 + #x1352ff55 + #x2827ff22 + #x2270ff77 + #x14551c00 + #x2827ff22 + #x2270ff77 + #xff551b00 + #xff221452 + #xff772827 + #x1b002270 + #x4221655 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #xff661600 + #xff550265 + #x4221652 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x2661700 + #x4221755 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #xfd661700 + #x17525565 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x1855ff66 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x1862ff66 + #xff770422 + #xff001570 + #xff770b07 + #x18002270 + #x4221966 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x4661300 + #x4221977 + #x1570ff77 + #xb07ff00 + #x2270ff77 + #x4661300 + #x4221977 + #x4670ff77 + #x4661300 + #x4221977 + #x70fe77 + #x50ff5523 + #x66130020 + #x22197704 + #x70fe7704 + #xff552300 + #x13002050 + #x19770466 + #xfe770422 + #x55230070 + #x2050ff + #x77046613 + #x77042219 + #x230070fe + #x2050ff55 + #x4661300 + #x4221977 + #x70fe77 + #x50ff5523 + #x77180020 + #x77042219 + #x230070fe + #x2050ff55 + #x19771800 + #xfe770422 + #x55230070 + #x2050ff + #x22197718 + #x70fe7704 + #xff552300 + #x18002050 + #x4221977 + #x70fe77 + #x50ff5523 + #x77180020 + #x62219 + #x50ff5523 + #x77180020 + #x440c2213 + #x50ff5523 + #x77180020 + #x440c2213 + #x50ff5523 + #x77120020 + #x22134405 + #x5523440c + #x2050ff + #x44057712 + #x440c2213 + #x50ff5523 + #x770d0020 + #x2213440a + #x5523440c + #x2050ff + #x440a770d + #x440c2213 + #x50ff5523 + #x770d0020 + #x2213440a + #x5523440c + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x440a770d + #x24ff2211 + #x5523440d + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x770d0020 + #x5523442b + #x2050ff + #x442b770d + #x50ff5523 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x4007f + #x0 + #x0 + #x0 + ) + :layer8 (new 'static 'array uint32 960 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x25007f00 + #xa02ff00 + #x520ff22 + #x410ff11 + #x607ff00 + #x774ff77 + #xff005544 + #xff220a02 + #xff110521 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff000410 + #xff770607 + #x55440774 + #xb02ff00 + #xff110522 + #xff330413 + #xff770637 + #x55440774 + #xa02ff00 + #x521ff22 + #x413ff11 + #x637ff33 + #x774ff77 + #xff005544 + #xff220a02 + #xff110520 + #xff330413 + #xff770637 + #x55440774 + #xa02ff00 + #x520ff22 + #x413ff11 + #x637ff33 + #x774ff77 + #xff005544 + #xff220a02 + #x5110520 + #x637ff33 + #x774ff77 + #xff005544 + #x6220802 + #x1141fe44 + #x37ff3305 + #x74ff7706 + #x554407 + #x220702ff + #x440620ff + #x61141fe + #xff770633 + #x55440774 + #x602ff00 + #x20fe22 + #x40fe4406 + #xff330613 + #xff770537 + #x55440774 + #x602ff00 + #x6000122 + #x743ff44 + #x537ff33 + #x474ff77 + #x4434fd44 + #xff005544 + #xff220502 + #xff770300 + #x16440474 + #xff005633 + #xfe220402 + #x77030020 + #x440474ff + #x331543ff + #x2ff0056 + #x20fd2203 + #x77040000 + #x33154405 + #x2ff0056 + #x12203 + #x770407ff + #x440474ff + #x331443ff + #x2ff0056 + #x12203 + #x770507ff + #x43ff4404 + #x563314 + #x220302ff + #x77060001 + #x440474ff + #x563314 + #x220302ff + #x60700fe + #x474ff77 + #x56331444 + #x302ff00 + #x720fe22 + #x74ff7706 + #x33144404 + #x2ff0056 + #x66ff2204 + #x74ff7706 + #x33144404 + #x2ff0056 + #x26fe2203 + #xff770666 + #x14440474 + #xff005633 + #x1220302 + #x567ff66 + #x474ff77 + #x1343ff44 + #xff005633 + #x2220302 + #xff770566 + #x13440574 + #xff005633 + #x2220302 + #xff770566 + #x13440574 + #xff005633 + #x2220302 + #x467ff66 + #x13440677 + #xff005633 + #x3220302 + #xff770366 + #x3440674 + #x56330f00 + #x202ff00 + #x326ff22 + #x7770366 + #xf000344 + #xff005633 + #xff220202 + #x3660326 + #x3440777 + #x56330f00 + #x202ff00 + #x326ff22 + #x7000366 + #xff000444 + #x56330d03 + #x202ff00 + #x326ff22 + #x7000366 + #xff110344 + #xb000210 + #xff005633 + #xff550205 + #x3660356 + #xff440300 + #xfe110941 + #x330a0010 + #x5ff0056 + #x56ff5502 + #x36603 + #x41ff4403 + #xff110a + #x56330a + #x550205ff + #x660356ff + #x44030003 + #x110a41ff + #x90310fe + #xff005633 + #xff550205 + #x3660356 + #xff440300 + #xfe110a41 + #x33090310 + #x5ff0056 + #x56ff5502 + #x36603 + #x71ff7703 + #x10fe110a + #x56330903 + #x205ff00 + #x356ff55 + #x3000366 + #xa71ff77 + #x310fe11 + #x563309 + #x550205ff + #x660356ff + #x77030003 + #x110a71ff + #x90310fe + #xff005633 + #xff550205 + #x3660356 + #xff770300 + #xff110a71 + #x56330a00 + #x205ff00 + #x356ff55 + #x4000266 + #x971ff77 + #x10fe11 + #x56330a + #x550205ff + #x660656ff + #xff7707 + #x21104 + #x56330b + #x550205ff + #x660656ff + #xff7707 + #x3ff1104 + #x56330d + #x550205ff + #x660756ff + #x57706 + #x330d03ff + #x5ff0056 + #x56ff5502 + #x67ff6607 + #x57705 + #x330d03ff + #x5ff0056 + #x56ff5502 + #x77056608 + #x110400ff + #x330d13ff + #x5ff0056 + #x56ff5502 + #x67ff6608 + #xff7704 + #x13ff1104 + #x56330d + #x550205ff + #x660856ff + #x770367ff + #x110570ff + #x330d13ff + #x5ff0056 + #x56ff5502 + #x67ff6608 + #x71ff7703 + #x330d1106 + #x5ff0056 + #x66065504 + #x30060fe + #x601ff77 + #xc13ff11 + #xff005633 + #xfe550405 + #x66040600 + #x77030001 + #x13ff1107 + #x56330c + #x550505ff + #x30600fe + #x3000166 + #xff110777 + #x56330c13 + #x505ff00 + #x600fe55 + #x16603 + #x11077703 + #x330c13ff + #x5ff0056 + #x6ff5506 + #x16603 + #x11077703 + #x330c13ff + #x5ff0056 + #x65506 + #x11077703 + #x330c13ff + #x5ff0056 + #x55507 + #x11077703 + #x330c13ff + #x5ff0056 + #x45507 + #x11077704 + #x330c13ff + #x5ff0056 + #x35508 + #x11077704 + #x330c13ff + #x5ff0056 + #x1550a + #x1ff7704 + #x13ff1106 + #x56330c + #x550b05ff + #x770400ff + #x110600ff + #x330c13ff + #x5ff0056 + #xff550b + #xff7704 + #x13ff1106 + #x56330c + #x550b05ff + #x770450ff + #x11050001 + #x330c13ff + #x5ff0056 + #x7704550c + #x1ff0001 + #x13ff1104 + #x56330c + #x550c05ff + #x75fc7703 + #x4505555 + #xc13ff11 + #xff005633 + #x3550c05 + #x5575fc77 + #x565055 + #x75ff7712 + #x7703550c + #x555575fc + #x12005650 + #xc75ff77 + #xfc770355 + #x50555575 + #x77120056 + #x550c75ff + #x75fc7703 + #x56505555 + #xff771200 + #x3550c75 + #x5575fc77 + #x565055 + #x75ff7712 + #x7703550c + #x555575fc + #x12005650 + #xc75ff77 + #xfc770355 + #x50555575 + #x77120056 + #x550c75ff + #x75fc7703 + #x56505555 + #xff771200 + #x3550c75 + #x5575fc77 + #x565055 + #x75ff7712 + #x4408550c + #x77120055 + #x550c75ff + #x554408 + #x75ff7712 + #x4408550c + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77120055 + #x470ff + #x440f04ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x77050055 + #x370ff + #x33044408 + #x440f34ff + #x60ff660b + #x33050048 + #x44080004 + #x34ff3304 + #x660b440f + #x4860ff + #x43305 + #x44408 + #x440f04ff + #x60ff660b + #x33050048 + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff660b + #x433303 + #x43305 + #x44408 + #x440f04ff + #x660b46ff + #x330363ff + #x33050043 + #x44080004 + #x4ff0004 + #x660b4410 + #x330363ff + #x3ff003f + #x43308 + #x44408 + #x441004ff + #x63ff660a + #x3f3304 + #x330803ff + #x44080004 + #x4ff0004 + #x660a4410 + #x3f3305 + #x330803ff + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x4ff0004 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x54ff5504 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x44080004 + #x54ff5504 + #x46ff440f + #x63ff6609 + #x3f3305 + #x330803ff + #x5506000b + #x440f54ff + #x660946ff + #x330563ff + #x40ff4407 + #x3ff0036 + #xb3308 + #x54ff5506 + #x46ff440f + #x63ff6609 + #x44073305 + #x3640ff + #x330803ff + #x5506000b + #x440f54ff + #x660946ff + #x330563ff + #x40ff4407 + #x3ff0036 + #xb3308 + #x50ff5506 + #x220b0003 + #x660a26ff + #x44073305 + #x3640ff + #x330803ff + #x5506000b + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330803ff + #x5506000b + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x63ff660a + #x44073304 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x60ff6605 + #x33050003 + #x40ff4407 + #x3ff0036 + #xc3307 + #x50ff5506 + #x220b0003 + #x660526ff + #x360ff + #x44073305 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x26ff220b + #x60ff6605 + #x440d0003 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x22097701 + #x660526ff + #x360ff + #x40ff440d + #x3ff0036 + #xc3307 + #x50ff5506 + #x77050003 + #x220572ff + #x660426ff + #x360ff + #x40ff440d + #x3ff0036 + #xc3307 + #x50ff5506 + #x77060003 + #x26ff2205 + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x5506000c + #x350ff + #x72ff7706 + #x26ff2204 + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55062209 + #x350ff + #x72ff7706 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x50ff5506 + #x77060003 + #x220572ff + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55062209 + #x350ff + #x72ff7706 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x50ff5506 + #x77060003 + #x220572ff + #x60ff6604 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x17ff1105 + #x72ff7705 + #x66042205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x11055505 + #x770617ff + #x26ff2205 + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x17ff1105 + #x22067706 + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77051107 + #x220572ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77051108 + #x66032205 + #x360ff + #x40ff440d + #x3ff0036 + #x13307 + #x220902ff + #x11085505 + #x770417ff + #x220472ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x77041109 + #x220472ff + #x60ff6603 + #x440d0003 + #x3640ff + #x330703ff + #x2ff0001 + #x55052209 + #x7703110a + #x220472ff + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x110b5505 + #x72ff7702 + #x26ff2203 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11045505 + #x313313fd + #x12ff1106 + #x26ff2203 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11045505 + #x11063302 + #x220312ff + #x660326ff + #x4960ff + #x330703ff + #x2ff0001 + #x55052209 + #x13ff1103 + #x11053303 + #x26ff2204 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11020005 + #x11043306 + #x26ff2204 + #x60ff6603 + #x3ff0049 + #x13307 + #x220902ff + #x11010005 + #x330613ff + #x110231ff + #x220412ff + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x33071101 + #x110231ff + #x220412ff + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x1102330a + #x66042205 + #x4960ff + #x330703ff + #x2ff0001 + #x20ff2203 + #x330a000a + #x22051102 + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x1102330a + #x66042205 + #x4960ff + #x330703ff + #x2ff0001 + #x20ff2203 + #x330a000a + #x22051102 + #x60ff6604 + #x3ff0049 + #x13307 + #x220302ff + #xa20ff + #x31fc330a + #x4121111 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x4660233 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x6636fd33 + #x4220466 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #xfd330b00 + #x4666636 + #xff660422 + #xe004360 + #xff000133 + #xff220302 + #xb000a20 + #x6636fc33 + #x22036266 + #x60ff6604 + #x330e0043 + #x2ff0001 + #x20ff2203 + #x330b000a + #x666636fc + #x4220362 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #xfd330b00 + #x3666636 + #x426ff22 + #x4360ff66 + #x1330e00 + #x302ff00 + #xa20ff22 + #x1330b00 + #x362ff66 + #x426ff22 + #x4360ff66 + #xff330800 + #xff000630 + #xff220302 + #x2000a20 + #x663ff33 + #x6636fd33 + #xff220462 + #xff660426 + #x8004360 + #x630ff33 + #x302ff00 + #xd20ff22 + #x2660100 + #x2660433 + #x2211fd22 + #xff660522 + #x8004360 + #x630ff33 + #x302ff00 + #xd20ff22 + #x2660100 + #xf9660333 + #x21222262 + #x5221211 + #x4360ff66 + #xff330800 + #xff000630 + #xff220302 + #x6000220 + #x1000377 + #x3330266 + #x1220366 + #x516ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x3770600 + #xfd660100 + #x3363363 + #xff220166 + #xff110221 + #xff660516 + #x8004360 + #x734ff33 + #xff220344 + #x6000220 + #xff000277 + #x1660806 + #x5110422 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x606ff00 + #x4220366 + #x416ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x426ff22 + #x362ff66 + #x512ff22 + #x316ff11 + #x4360ff66 + #xff330800 + #x3440734 + #x220ff22 + #x2770600 + #x426ff22 + #x262ff66 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x821ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xd770600 + #xff110822 + #x8004610 + #x734ff33 + #xff220344 + #x6000220 + #x8220d77 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #xc770600 + #x827ff22 + #x4610ff11 + #xff330800 + #x3440734 + #x220ff22 + #x8770600 + #x7227fa22 + #x71772222 + #x10ff1107 + #x77070060 + #x77fa2207 + #x77222272 + #xff110777 + #xb006010 + #x2272f577 + #x77772722 + #x77772722 + #xff110671 + #x16006010 + #xff110677 + #x16006010 + #xff110677 + #x16006010 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x16006877 + #x7f007f77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x3d007f00 + #x0 + #x0 + ) + :layer9 (new 'static 'array uint32 888 + #x452301f8 + #xcdab8967 + #x1f0057ef + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #x1f005f22 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x3d221f00 + #x1306ff00 + #x1f000c66 + #xff003d22 + #xc661306 + #x1a221f00 + #xff332200 + #xc661336 + #xff221e00 + #x22001a20 + #x1336ff33 + #x1e000c66 + #x1a20ff22 + #xff332200 + #xc661336 + #x1b221e00 + #xff332200 + #x4661336 + #x1e000755 + #x22001b22 + #x1336ff33 + #x6550566 + #x1b221e00 + #xff332200 + #x6661336 + #x1d000555 + #x1b20ff22 + #xff332200 + #x7661336 + #x1d000455 + #x22001c22 + #x1336ff33 + #xff550766 + #x1c000350 + #x1c20ff22 + #xff332200 + #x8661336 + #x250ff55 + #xff221b00 + #x22001d20 + #x1336ff33 + #x2550966 + #x1e221b00 + #xff332200 + #xa661336 + #x1a000155 + #xff001d22 + #xff220202 + #xff331f23 + #xa661336 + #x50fe55 + #x20ff2218 + #x2ff001e + #x23ff2202 + #x36ff331f + #x65ff6612 + #x50ff550b + #x20ff2217 + #x2ff001f + #x23ff2202 + #x36ff331f + #x65ff6612 + #x2217550c + #x2ff0020 + #x23ff2202 + #x36ff331f + #x65ff6612 + #x52ff550c + #x20ff2214 + #x2ff0021 + #x33202203 + #x65ff6612 + #x52ff550d + #x20ff2212 + #x2ff0022 + #x33202203 + #x65ff6612 + #x52ff550e + #x20ff2210 + #x2ff0023 + #x23ff2203 + #x6612331f + #x550f65ff + #x220e52ff + #x2ff0025 + #x331e2205 + #x65ff6612 + #x220b5510 + #x2720ff + #x220702ff + #x331b23ff + #x65ff6612 + #x22095510 + #x2920ff + #x220702ff + #x6612331c + #x551065ff + #x220752ff + #x2a20ff + #x220702ff + #x36ff331c + #x5ff6611 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x36ff331c + #x5ff6611 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x6610331d + #x100560fe + #x3350ff55 + #x602ff00 + #x1d23ff22 + #xf36ff33 + #x560fe66 + #x50ff5510 + #x2ff0033 + #x23ff2206 + #x36ff331d + #xfe660f + #xff551005 + #xff003350 + #x1e220702 + #xfe660f33 + #x55100500 + #x2ff0034 + #x331f2207 + #x660c36ff + #x50060fd + #x345510 + #x220702ff + #x36ff3321 + #x60fd660a + #x55100500 + #x2ff0034 + #x33212207 + #x660a36ff + #x50060fd + #x50ff550f + #x2ff0034 + #x23ff2207 + #x36ff3320 + #x1660a + #x550f05ff + #x3450ff + #x220802ff + #x333323fc + #x18550335 + #xa36ff33 + #xff000166 + #x35550f05 + #x802ff00 + #x3323fd22 + #xff550435 + #xa331703 + #x60fc66 + #x550f0500 + #x2ff0035 + #x25ff2208 + #xff5506 + #x660a3317 + #x60fc + #xff550e05 + #xff003550 + #xff220802 + #xfe550625 + #x33160300 + #x2660a + #x550e05ff + #x2ff0036 + #x55072208 + #x160300fe + #x2660a33 + #xd05ff00 + #x3650ff55 + #x702ff00 + #x725ff22 + #x50fe55 + #x66093316 + #x260ff + #x550d05ff + #x2ff0037 + #x25ff2207 + #xfe5508 + #x9331503 + #x260ff66 + #xd05ff00 + #xff003755 + #x9220702 + #x50fd55 + #x9331403 + #xff000366 + #xff550c05 + #xff003750 + #xff220602 + #x1550a25 + #x1303ff00 + #x3660933 + #xc05ff00 + #xff003855 + #xff220602 + #xfc550a25 + #x3000050 + #x66083312 + #x360ff + #x550c05ff + #x2ff0038 + #x25ff2206 + #x2550b + #x66083312 + #x360ff + #x550b05ff + #x3850ff + #x220602ff + #x2550c + #x331103ff + #x46608 + #x550a05ff + #x3950ff + #x220602ff + #x50ff550c + #x3ff0002 + #x36ff3310 + #x4b6607 + #x220602ff + #x3550d + #x330f03ff + #x660636ff + #x4b60ff + #x220502ff + #x550d25ff + #x350ff + #x330f03ff + #x60ff6606 + #x2ff004b + #x25ff2205 + #x4550e + #x330d03ff + #x660636ff + #x2ff004c + #x25ff2205 + #x50ff550e + #x330d0004 + #x660536ff + #x4c60ff + #x220502ff + #x550f25ff + #x330c0005 + #x60ff6606 + #x2ff004c + #x25ff2205 + #x50ff550f + #x330a0005 + #x660600ff + #x440f0007 + #x2ff0035 + #x25ff2205 + #x55510 + #x330803ff + #xf30ff + #x35440f + #x220502ff + #x551025ff + #x1f50ff + #x35440f + #x220502ff + #x551125ff + #x1e50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220502ff + #x551325ff + #x1c50ff + #x35440f + #x220602ff + #x50ff5513 + #xaff0013 + #xa0ffaa03 + #x440f0002 + #x2ff0035 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #x35440f + #x220602ff + #x50ff5513 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2ff0035 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #xc440f + #x20ff2206 + #x2ff0020 + #x55132206 + #x650ff + #xaa100aff + #x2a0ff + #xc440f + #x20ff2206 + #x2ff0020 + #x25ff2206 + #x50ff5512 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206000c + #x2020ff + #x220702ff + #x50ff5512 + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220702ff + #x551125ff + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11012208 + #x50ff550f + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220802ff + #x550f1101 + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11012208 + #x50ff550f + #xaff0006 + #xa0ffaa10 + #x440f0002 + #x2206110c + #x2020ff + #x220802ff + #x550f1101 + #x650ff + #xaa100aff + #x2a0ff + #x110c440f + #x20ff2206 + #x2ff0020 + #x11022208 + #x550d15ff + #x650ff + #xaa100aff + #x2a0ff + #x44097705 + #x220202ff + #x22061108 + #x2020ff + #x220602ff + #x110521ff + #x50ff550c + #xaff0006 + #xa0ffaa10 + #x77050002 + #x440874ff + #x220202ff + #x22061108 + #x2220ff + #x110c01ff + #x550a15ff + #x650ff + #xaa100aff + #x7709a7ff + #x2ff4408 + #x11082202 + #x20ff2206 + #x1ff0022 + #x550a110d + #x650ff + #xaa100aff + #x7709a7ff + #x2ff4408 + #x11082202 + #x20ff2206 + #x1ff0022 + #x15ff110d + #x50ff5509 + #xaff0006 + #xa7ffaa10 + #x44087709 + #x220202ff + #x22061108 + #x2220ff + #x110e01ff + #x50ff5509 + #xaff0006 + #xddffaa10 + #x44087709 + #x220202ff + #x22061108 + #x2220ff + #x110e01ff + #x550815ff + #x650ff + #xaa0f0aff + #x9ddadfe + #xff440877 + #xff221202 + #xff002220 + #x8110f01 + #x650ff55 + #xf0aff00 + #x9dd01aa + #xff440877 + #xff221202 + #xff002220 + #xff110f01 + #xff550715 + #xff000650 + #xfdaa0e0a + #x9d7ddad + #xff440877 + #xff221202 + #xff002220 + #xff110f01 + #xff550715 + #xff000650 + #xfeaa0e0a + #x770addad + #x2ff0008 + #x20ff2212 + #x1ff0022 + #x55071110 + #x650ff + #xaa0e0aff + #xad7adfe + #xff000877 + #xff221202 + #xff002220 + #xff111001 + #xff550615 + #xff000650 + #xffaa0e0a + #x8770bdd + #x1202ff00 + #x2220ff22 + #x1501ff00 + #x5515fc11 + #x65055 + #xaa0d0aff + #xbd7adfe + #xff000877 + #xff221202 + #xff002220 + #xff111801 + #xff000650 + #xfeaa0d0a + #x7707d7dd + #x2ff000c + #x20ff2212 + #x1ff0022 + #x10ff1118 + #xaff0006 + #xadfdaa0c + #x7706dddd + #xc70ff + #x221202ff + #x2220ff + #x111a01ff + #xaa0c0006 + #xd7ffdd02 + #x55017705 + #x2ff0011 + #x20ff220c + #x1ff0022 + #x5111b + #xaa0a0aff + #xdd0322ff + #x75fc7704 + #x10505555 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #x9000611 + #x22a2fdaa + #xffdd022d + #xff7702d7 + #x10550375 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #x8000611 + #x6a2ffaa + #x5770222 + #xff000f55 + #xff220c02 + #xff002220 + #x6111b01 + #x70aff00 + #xfd2207aa + #x5757727 + #xff000f55 + #xff220c02 + #xff002220 + #x7111b01 + #x9aa0600 + #x675ff22 + #xe50ff55 + #xc02ff00 + #x2220ff22 + #x1b01ff00 + #xff000711 + #xffaa040a + #xff2209a2 + #xff551625 + #xff220c52 + #xff002220 + #xff111a01 + #x4000810 + #x17220aaa + #xc52ff55 + #x2220ff22 + #x1a01ff00 + #x3000911 + #x9a2ffaa + #xff551822 + #xff220c52 + #xff002220 + #xff111901 + #xff000910 + #x9aa020a + #x1825ff22 + #xc52ff55 + #x2220ff22 + #x1901ff00 + #xa10ff11 + #xffaa0100 + #xff2209a2 + #xff551825 + #xff220c52 + #xff002220 + #xff111901 + #xff000b10 + #xff220a02 + #xff551825 + #xff220c52 + #xff002220 + #xff111901 + #xb000b10 + #x1925ff22 + #xb52ff55 + #x2220ff22 + #x1901ff00 + #xa10ff11 + #xb02ff00 + #x1a25ff22 + #xa52ff55 + #x2220ff22 + #x1901ff00 + #xc000b11 + #x1c25ff22 + #xff220955 + #xff002220 + #xa111901 + #xc02ff00 + #x2025ff22 + #xff002955 + #x2111901 + #x406ff00 + #xd000166 + #x2025ff22 + #xff002955 + #x9110301 + #xa41ff44 + #xff000211 + #xfe660406 + #x220d0200 + #x552025ff + #x440a002e + #x10fc110a + #x4060000 + #xe00ff66 + #x2025ff22 + #xa002e55 + #x941ff44 + #x10fc11 + #x66040600 + #x220d02ff + #x552125ff + #x440b002e + #x1110a + #x660406ff + #x82205 + #x550f05ff + #xf4534fe + #xc002e55 + #xfc110844 + #x6004414 + #x22046604 + #x20620fe + #xff000466 + #xfd550e05 + #xf443433 + #xd002e55 + #xfb110644 + #x40444414 + #x2660606 + #xff660522 + #xff000260 + #xfc550d05 + #x45343353 + #x2e550f + #x1103440f + #x46ff4404 + #x26610 + #x550d05ff + #x343353fc + #x2e550f45 + #xff441800 + #x2661146 + #x1550d00 + #x4434fe33 + #x2e550f + #x46ff4418 + #x60fc6611 + #xc050000 + #xfe330155 + #x550f4434 + #x4419002e + #x16612 + #x550c05ff + #x34fd3301 + #x550e4544 + #x4419002e + #x661146ff + #x60fd + #x53fa550b + #x44343333 + #x2e550e45 + #x12441a00 + #xff000166 + #xfa550a05 + #x34333353 + #x550e4444 + #x441a002e + #x661146ff + #x550a0002 + #x333353fa + #xe444434 + #x1b002e55 + #x2661144 + #x905ff00 + #x3353fa55 + #x44443433 + #x2e550e + #x46ff441b + #x60fc6610 + #x9050000 + #x3353fa55 + #x44443433 + #x2e550e + #x46ff441c + #x26610 + #x33025509 + #x444434f8 + #x44545545 + #x2e550945 + #xff441d00 + #xfd660f46 + #x8000060 + #xff330355 + #x9440634 + #x1e002e55 + #xf46ff44 + #xff000166 + #xff550605 + #xff330353 + #x9440634 + #x1e002e55 + #xf46ff44 + #x6000266 + #x353ff55 + #x634ff33 + #x2e550944 + #xff441e00 + #xfd660f46 + #x6000060 + #xff330455 + #x9440634 + #x1e002e55 + #xf46ff44 + #x60fd66 + #xff550500 + #xff330453 + #xff440634 + #x2e550845 + #xff441e00 + #x1661046 + #x5550500 + #x634ff33 + #x845ff44 + #x1f002e55 + #xfd661044 + #x3050060 + #x553ff55 + #x534ff33 + #x8110144 + #x1f002e55 + #xfd661044 + #x3050060 + #xfc330655 + #x41444434 + #x15ff1103 + #x2e5508 + #x6611441f + #x5fc0001 + #x3535555 + #x6220233 + #x915ff11 + #x1f002e55 + #xfb661144 + #x55000060 + #xff330353 + #x6220232 + #x2e550a11 + #x11441f00 + #x260ff66 + #x3330400 + #xa110622 + #x1f002e55 + #xff661144 + #x3000260 + #x332ff33 + #xa110622 + #x1f002e55 + #x1046ff44 + #x260ff66 + #xff330200 + #xff220332 + #xa110621 + #x1f002e55 + #x1146ff44 + #x2000266 + #x332ff33 + #x521ff22 + #xa15ff11 + #x20002e55 + #x4661144 + #x302ff00 + #x621ff22 + #xa15ff11 + #x20002e55 + #x4661144 + #x302ff00 + #xff110722 + #x2e550a15 + #x11442000 + #xff000466 + #xff220202 + #xff110621 + #x2e550b15 + #xff442000 + #xff661146 + #xfc000260 + #x21222202 + #x550c1107 + #x4421002e + #x661046ff + #x260ff + #x222202fd + #x15ff1105 + #x2e550e + #x66114421 + #x10060fd + #x15ff1109 + #x2e550e + #x46ff4420 + #x60fd6611 + #x11090100 + #x550e15ff + #x4420002e + #x661146ff + #x10060fd + #x15ff1109 + #x2e550e + #x46ff441f + #x60fd6612 + #x11090100 + #x550e15ff + #x441e002e + #x60fd6614 + #x11090100 + #x550e15ff + #x66190048 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x10060fd + #x10ff1109 + #x66190057 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x6460ff + #x60ff6619 + #x66190064 + #x7f60ff + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x2a007f + #x0 + #x0 + ) + :layer10 (new 'static 'array uint32 108 + #x452301f8 + #xcdab8967 + #x7f117fef + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x7f117f11 + #x77117f11 + #x11 + #x0 + ) + :layer11 (new 'static 'array uint32 384 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d004100 + #x1d006166 + #x1d006166 + #x1d006166 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1d000533 + #xc004e66 + #x1000533 + #x1a6aff66 + #xc004e66 + #x1000533 + #xa6aafe66 + #x4e6619 + #x5330c + #xaa016601 + #x4e6619 + #x5330c + #xaa016601 + #x6618a6ff + #x330c004e + #x66010005 + #x6618aa02 + #x330c004e + #x5aff5506 + #xa6ffaa02 + #x4e6617 + #x5506330c + #xaa035aff + #x4e6617 + #x5506330c + #xaa035aff + #x4e6617 + #x5507330c + #xa6ffaa03 + #x4e6616 + #x5507330c + #xaa035aff + #x4e6616 + #x5508330c + #xa6ffaa03 + #x4e6615 + #x5508330c + #xaa035aff + #x4e6615 + #x5509330c + #xa6ffaa03 + #x4e6614 + #x5509330c + #xaa035aff + #x4e6614 + #x550a330c + #xa6ffaa03 + #x4e6613 + #x550a330c + #x16a65afe + #xc004e66 + #x17550b33 + #xc004e66 + #x17550b33 + #xb004e66 + #x4534fe33 + #x6617550a + #x330b004e + #x550a4401 + #x4e6617 + #x4402330a + #x6617550a + #x3309004e + #x440234ff + #x550945ff + #x4e6617 + #x34ff3309 + #x55094403 + #x4e6617 + #x4403330a + #x550845ff + #x4e6617 + #x34ff330a + #x55084403 + #x4e6617 + #x4403330b + #x66175508 + #x330b004e + #x84403 + #x4e6617 + #x34ff330b + #x84402 + #x11086616 + #x4510ff + #x4402330c + #x66150008 + #x110861ff + #x4510ff + #x4402330c + #x66150008 + #x10ff1109 + #x330c0045 + #x6614000b + #x110961ff + #x4510ff + #xb330c + #x61ff6613 + #x10ff110a + #x330c0045 + #x6613000b + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x6613005e + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x6613005e + #x110a61ff + #x5e10ff + #x61ff6613 + #x10ff110a + #x1ff0072 + #x14ff110a + #x40ff4404 + #x1ff006c + #x14ff110a + #x40ff4404 + #x1ff006c + #x4405110a + #x6c40ff + #x110901ff + #x440514ff + #x6c40ff + #x110801ff + #x440614ff + #x6c40ff + #x110701ff + #x440714ff + #x6c40ff + #x110601ff + #x440814ff + #x6c40ff + #x110501ff + #x440914ff + #x6c40ff + #x110401ff + #x440a14ff + #x6c40ff + #x110301ff + #x440b14ff + #x6c40ff + #x110201ff + #x440c14ff + #x6c40ff + #x111101fc + #xff440d14 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xf006e40 + #x6e40ff44 + #xff440f00 + #xd006e40 + #x5545fd44 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xffaa2300 + #xff660da6 + #xff550765 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xffaa2300 + #xff660da6 + #xff550765 + #x23004250 + #xda6ffaa + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xeaa2300 + #x765ff66 + #x4250ff55 + #xffaa2200 + #xff660ea6 + #xff550765 + #x22004250 + #xea6ffaa + #x765ff66 + #x4250ff55 + #xffaa2200 + #xff660ea6 + #xff550765 + #x22004250 + #xff660faa + #xff550765 + #x22004250 + #xfd660daa + #x7353363 + #x4250ff55 + #xdaa2200 + #x6330366 + #x4250ff55 + #xcaa2300 + #xff330566 + #xff550335 + #x23004250 + #xba6ffaa + #xff330666 + #xff550235 + #x24004250 + #x9a6ffaa + #xa63ff66 + #x25004333 + #xff6609aa + #x43330a63 + #x8aa2600 + #xa63ff66 + #x26004333 + #x7a6ffaa + #x43330b66 + #xffaa2700 + #xb6606a6 + #x28004333 + #xff6605aa + #x43330b63 + #xffaa2800 + #xff6604a3 + #x43330b63 + #xfeaa2800 + #x660333a3 + #x43330c + #x3301aa28 + #x660236ff + #x43330c + #xa3ffaa27 + #x36fd3302 + #x330c6666 + #xaa270043 + #x3303a3ff + #xc6366fe + #x27004333 + #xff3305aa + #x43330c63 + #xffaa2600 + #x433313a3 + #xffaa2600 + #x433313a3 + #x14aa2600 + #x25004333 + #x14a3ffaa + #x25004333 + #x14a3ffaa + #x25004333 + #x433315aa + #xffaa2400 + #x433315a3 + #x16aa2400 + #x23004333 + #x16a3ffaa + #x23004333 + #x433317aa + #xffaa2200 + #x433317a3 + #x18aa2200 + #x21004333 + #x433319aa + #xffaa2000 + #x433319a3 + #xffaa1f00 + #x62331aa3 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x62331c00 + #x7f331c00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x9007f00 + #x0 + #x0 + #x0 + ) + :layer12 (new 'static 'array uint32 712 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d007f00 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #x1d12ff11 + #x2f20ff22 + #xff772200 + #xff110b71 + #xff221d12 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xb71ff77 + #xff221e11 + #x22002f20 + #xa71ff77 + #x1e12ff11 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772200 + #x23110671 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772300 + #x23110571 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1702ff00 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1702ff00 + #x2f20ff22 + #xff772400 + #xff000f70 + #xff221702 + #x24002f20 + #xf70ff77 + #x1302ff00 + #x221ff22 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x13020060 + #x221ff22 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x13020060 + #xff110322 + #x24002f10 + #xd76ff77 + #x60fd66 + #xff221202 + #xff110321 + #x24002f10 + #xd76ff77 + #x60fd66 + #x4221202 + #x2f10ff11 + #xff772400 + #xfd660d76 + #x11020060 + #xff110522 + #x1d002f10 + #x573ff77 + #xfd660e33 + #x10020060 + #x521ff22 + #x2f10ff11 + #x6771d00 + #xfd660e33 + #x10020060 + #xff110622 + #x1c002f10 + #x673ff77 + #xfd660e33 + #xf020060 + #x621ff22 + #x2910ff11 + #xe441300 + #xe330777 + #x60fd66 + #x7220f02 + #x2910ff11 + #xff441300 + #xff770c47 + #xe330773 + #x60fd66 + #xff220e02 + #xff110721 + #x14002910 + #xff770b44 + #xe330873 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441400 + #x9770a47 + #xff660e33 + #xff000860 + #xff110f01 + #x15002910 + #xff770944 + #xe330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441500 + #xa770847 + #xff660e33 + #xff000860 + #xff110f01 + #x15002910 + #x747ff44 + #x973ff77 + #xff660f33 + #xff000860 + #xff110f01 + #x16002910 + #xff770644 + #xff330973 + #xff660f36 + #xff000860 + #xff110f01 + #x16002910 + #x547ff44 + #x973ff77 + #xff661033 + #xff000860 + #xff110f01 + #x17002910 + #x547ff44 + #xff330977 + #xff660f36 + #xff000860 + #xff110f01 + #x18002910 + #xff770444 + #x10330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x4441800 + #xff330977 + #xff661036 + #xff000860 + #xff110f01 + #x18002910 + #xff770344 + #x11330973 + #x860ff66 + #xf01ff00 + #x2910ff11 + #xff441800 + #x9770247 + #x1136ff33 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x1441900 + #x973ff77 + #xff661233 + #xff000860 + #xff110f01 + #x1b002910 + #x13330944 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x8441b00 + #x1336ff33 + #x860ff66 + #xf01ff00 + #x2910ff11 + #x8441b00 + #xff661033 + #x7550465 + #xf01ff00 + #x2910ff11 + #x7441b00 + #x1036ff33 + #x7550566 + #xf01ff00 + #x2910ff11 + #x5441b00 + #x6336fe33 + #x65ff6610 + #x75505 + #x110f01ff + #x2910ff + #x3305441b + #x55066612 + #x1ff0007 + #x10ff110f + #x441b0029 + #x36ff3304 + #x65ff6611 + #x75506 + #x110f01ff + #x2910ff + #x3304441b + #x55076612 + #x1ff0007 + #x10ff110f + #x441b0029 + #x66123303 + #x75508 + #x110f01ff + #x2910ff + #x6616441a + #x75509 + #x110f01ff + #x2910ff + #x6615441a + #x550965ff + #x1ff0007 + #x10ff110f + #x441a0029 + #x550a6615 + #x1ff0007 + #x10ff110f + #x441a0029 + #x65ff6614 + #x7550a + #x110f01ff + #x2910ff + #x6614441a + #x7550b + #x30ff3310 + #x441a0029 + #x550c6613 + #x33100007 + #x2930ff + #x6612441a + #x550b65ff + #x33104408 + #x2930ff + #x6612441a + #x54ff550b + #x33104408 + #x2930ff + #x6611441a + #x550b65ff + #x33104409 + #x2930ff + #x660f441a + #xb6561fe + #x954ff55 + #xff331044 + #x19002930 + #x2642fe44 + #x11fe660e + #x1b550b15 + #x2940ff44 + #x1441900 + #xaa6afe22 + #x61fd660b + #x550a1111 + #x441b54ff + #x2940ff + #x45f84416 + #x22225255 + #xaa6aaaa + #xff110266 + #x1c550915 + #x2940ff44 + #x1441600 + #x2252fd55 + #x9aa0222 + #x7110466 + #x1d54ff55 + #x2940ff44 + #x2441500 + #x2252fd55 + #xffaa0222 + #xff6607a6 + #xff110461 + #xff550515 + #xff441e54 + #x14002940 + #x245ff44 + #x3220255 + #x66607aa + #x1f550511 + #x2940ff44 + #xff441300 + #x2550345 + #x22aff22 + #x5a6ffaa + #x661ff66 + #x315ff11 + #x1f54ff55 + #x2940ff44 + #x4441300 + #x2220355 + #x86606aa + #x20550311 + #x2940ff44 + #x3441300 + #xfd220455 + #x526aa2a + #x861ff66 + #x215ff11 + #xff442055 + #x13002940 + #xff550244 + #xfe220552 + #x660522a2 + #x5501110a + #x442054ff + #x2940ff + #x55024413 + #x26ff2208 + #x61ff6603 + #x15fe110a + #xff442155 + #x13002940 + #xa550144 + #xc660322 + #x2154ff11 + #x2940ff44 + #xc441300 + #x6626fd22 + #x21110e66 + #x2940ff44 + #xd441300 + #x6166fe22 + #x14ff110e + #x40ff4420 + #x44130029 + #x21ff220d + #x44201110 + #x2940ff + #x220d4413 + #x111021ff + #x441f14ff + #x2940ff + #x42ff4413 + #x21ff220c + #x441f1111 + #x2940ff + #x220c4414 + #x111121ff + #x441e14ff + #x2940ff + #x42ff4414 + #x21ff220b + #x441e1112 + #x2940ff + #x220b4415 + #x111221ff + #x441d14ff + #x2940ff + #x42ff4415 + #x21ff220a + #x441d1113 + #x2940ff + #x220a4416 + #x111321ff + #x441c14ff + #x2940ff + #x220a4416 + #x111421ff + #x40ff441c + #x44160029 + #x220942ff + #x111421ff + #x441b14ff + #x2940ff + #x42ff4416 + #x21ff2209 + #x441b1115 + #x2940ff + #x22094417 + #x111521ff + #x441a14ff + #x2940ff + #xc4419 + #x111101ff + #x40ff441a + #x44190029 + #x1111000d + #x441914ff + #x2940ff + #xd4419 + #x111101ff + #x40ff4419 + #x44190029 + #x1111000e + #x441814ff + #x2940ff + #xe4419 + #x111101ff + #x40ff4418 + #x44190029 + #x1111000f + #x441714ff + #x2940ff + #xf4419 + #x111101ff + #x40ff4417 + #x44190029 + #x11110010 + #x441614ff + #x2940ff + #x104419 + #x111101ff + #x40ff4416 + #x44190029 + #x11110011 + #x441514ff + #x2940ff + #x114419 + #x111101ff + #x40ff4415 + #x44190029 + #x11110012 + #x441414ff + #x2940ff + #x124419 + #x111101ff + #x40ff4414 + #x44190029 + #x11110013 + #x441314ff + #x2940ff + #x134419 + #x111101ff + #x40ff4413 + #x44190029 + #x1111aa14 + #x441214ff + #x2940ff + #xaa144419 + #x1111a1ff + #x40ff4412 + #x44190029 + #x1111aa15 + #x441114ff + #x2940ff + #xaa154419 + #x1111a1ff + #x40ff4411 + #x44190029 + #x1111aa16 + #x441014ff + #x2940ff + #xaa164419 + #x111161ff + #x40ff4410 + #x44190029 + #x66ffaa16 + #x14ff1111 + #x40ff440f + #x44190029 + #x66feaa16 + #xf111161 + #x2940ff44 + #x2441600 + #x1aa1655 + #xff111166 + #xff440e14 + #x15002940 + #x245ff44 + #x1aa1655 + #x1161ff66 + #xff440e11 + #x15002940 + #x16550344 + #x116602aa + #xff440e11 + #x14002940 + #x245ff44 + #x165aff55 + #xff6602aa + #xe111061 + #x2940ff44 + #xff441400 + #x17550245 + #x106603aa + #x14003911 + #xff550244 + #x3aa175a + #xf61ff66 + #x13003911 + #x245ff44 + #x175aff55 + #xf6604aa + #x13003911 + #x18550344 + #xff6604aa + #x39110e61 + #x3441300 + #x5aa1855 + #x39110e66 + #xff441200 + #xff550245 + #x5aa185a + #xd61ff66 + #x12003911 + #x19550344 + #xff6605aa + #x4b110d61 + #x305ff00 + #x5aa1955 + #xd61ff66 + #xff004b11 + #xff550205 + #x5aa195a + #xd61ff66 + #xff004b11 + #xff550205 + #x6aa195a + #x4b110d66 + #x205ff00 + #x195aff55 + #xd6606aa + #xff004b11 + #xff550205 + #x6aa195a + #x4b110d66 + #x205ff00 + #x195aff55 + #xff6606aa + #x4b110c61 + #x205ff00 + #x195aff55 + #xff6606aa + #x4b110c61 + #x205ff00 + #x195aff55 + #x5a6ffaa + #xc61ff66 + #xff004b11 + #xff550205 + #xffaa195a + #xff6605a6 + #x4b110c61 + #x205ff00 + #x195aff55 + #x5a6ffaa + #xc61ff66 + #xff004b11 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #xff005860 + #xff550205 + #xffaa195a + #xff6605a6 + #x7f007f60 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x2600 + #x0 + #x0 + ) + :layer13 (new 'static 'array uint32 1200 + #x452301f8 + #xcdab8967 + #x16110bef + #xb660544 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x66054416 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #x5441611 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44161113 + #x220b6605 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x16111366 + #xb660544 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x66054416 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #x5441611 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44161113 + #x220b6605 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x441c1113 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xb441c11 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x220b441c + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x441c1113 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xb441c11 + #xff111622 + #xff770e17 + #xfe111871 + #x11136616 + #x220b441c + #x17ff1116 + #x71ff770e + #x16fe1118 + #x1c111366 + #x16220b44 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44091113 + #x441177ff + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xfd440811 + #xd747747 + #x6646fd44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44081113 + #x440d7702 + #x220b6602 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x7111366 + #x247ff44 + #xb74ff77 + #x246ff44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x44071113 + #x440b7704 + #x220b6603 + #x17ff1116 + #x71ff770e + #x16fe1118 + #x6111366 + #x447ff44 + #x974ff77 + #x346ff44 + #x16220b66 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33041113 + #x77064401 + #x66044409 + #x1116220b + #x770e17ff + #x111871ff + #x136616fe + #xfe330411 + #x77064734 + #x440774ff + #x660446ff + #x72ff7701 + #x11162208 + #x770e17ff + #x111871ff + #x136616fe + #x8330511 + #x5440777 + #xff770166 + #x16220872 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33051113 + #x770737ff + #x440574ff + #x660546ff + #x72ff7701 + #x11162208 + #x770e17ff + #x111871ff + #x136616fe + #xff330511 + #x5770837 + #x2660644 + #xb220877 + #x7717fe11 + #x17ff1108 + #x71ff770e + #x16fe1118 + #x5111366 + #x837ff33 + #x374ff77 + #x646ff44 + #xff770266 + #xb220772 + #xff770111 + #xff110771 + #xff770e17 + #xfe111871 + #x11136616 + #x77093306 + #x66074403 + #x72ff7703 + #x110a2206 + #x777717fc + #xff110771 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3306 + #x74fc7708 + #x7464444 + #xff770466 + #xa220572 + #x8770211 + #xe17ff11 + #x1871ff77 + #x6616fe11 + #x33071113 + #x74fd7708 + #x66074444 + #x770567ff + #x110e51ff + #x777717fc + #xff110871 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3307 + #x44fe7708 + #x5660746 + #x5575fe77 + #x7702110e + #x17ff1109 + #x71ff770e + #x16fe1118 + #x8111366 + #xff770833 + #x5660844 + #x5575fd77 + #xfc110c51 + #x71777717 + #x17ff1109 + #x71ff770e + #x16fe1118 + #x8111366 + #x737ff33 + #xfe660977 + #x77024467 + #x11085503 + #x47fd4403 + #x110a7777 + #x770e17ff + #x111871ff + #x136616fe + #xff330811 + #x9770737 + #x4464fb66 + #x4757747 + #x3110755 + #x7747fd44 + #xff110a71 + #xff770e17 + #xfe111871 + #x11136616 + #x37ff3308 + #x76ff7706 + #x44016609 + #x757747fd + #x51ff5504 + #x44041106 + #x110b77ff + #x770e17ff + #x111871ff + #x136616fe + #xff330811 + #x9770637 + #x4464fd66 + #x4770244 + #x651ff55 + #xff440511 + #xff110a41 + #xffdd031d + #xff7709d7 + #xfe111871 + #x11136616 + #x37ff3308 + #x76ff7705 + #x44016609 + #x770247ff + #x33fe5504 + #x5110531 + #xa41ff44 + #x31dff11 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770537ff + #x64fd6609 + #x77034444 + #x33015504 + #x44051105 + #x110a41ff + #xdd031dff + #x7709d7ff + #x111871ff + #x136616fe + #xff330811 + #xff770437 + #x1660976 + #x346ff44 + #xfc550377 + #x31333353 + #x44051104 + #x110a41ff + #xd7ffdd04 + #x71ff7709 + #x16fe1118 + #x8111366 + #x437ff33 + #x1660a77 + #x366ff44 + #x3550377 + #xff110333 + #xff440514 + #x5110941 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770437ff + #x44fd660a + #x11036646 + #x33045503 + #x44061102 + #x110841ff + #xdd051dff + #x7709d7ff + #x111871ff + #x136616fe + #xff330811 + #xd770437 + #x6110566 + #x1131fd33 + #xff440614 + #x6110841 + #x9d7ffdd + #x1871ff77 + #x6616fe11 + #x33081113 + #x770437ff + #x1105660d + #x11ff3307 + #x41ff4407 + #x1dff1107 + #xd7ffdd06 + #x71ff7709 + #x16fe1118 + #x8111366 + #x437ff33 + #x5660d77 + #xff330711 + #xff440734 + #x7110741 + #x1b770add + #x8111366 + #x437ff33 + #x5660d77 + #x8330711 + #x641ff44 + #x71dff11 + #x1b770add + #x8111366 + #x437ff33 + #x5660d77 + #xff330611 + #xff440834 + #xff110441 + #xffdd081d + #xff7709d7 + #x13661b76 + #xff330811 + #xa550735 + #x6110566 + #xff440933 + #xff110441 + #xffdd081d + #x1c7709d7 + #x8111366 + #x735ff33 + #x5660a55 + #xff330511 + #xff440934 + #xff110441 + #x9dd081d + #x1c76ff77 + #x8111366 + #x735ff33 + #x5660a55 + #x10330511 + #x74dff44 + #x9d7ffdd + #x13661d77 + #xff330811 + #xa550735 + #x4110566 + #x1034ff33 + #x74dff44 + #xff7709dd + #x13661d76 + #xff330811 + #xa550735 + #x4110566 + #x1034ff33 + #x64dff44 + #x9d7ffdd + #x13661e77 + #xff330811 + #xa550735 + #xff110a66 + #xff441014 + #x9dd064d + #x1e76ff77 + #x8111366 + #x735ff33 + #x5440455 + #xff110a66 + #xff440f14 + #xadd064d + #x13661f77 + #xff330811 + #x4550735 + #x7660544 + #x216ff11 + #x6440f66 + #xad7ffdd + #x13661f77 + #xff330811 + #x4550735 + #x7660544 + #x216ff11 + #xd64ff66 + #x64dff44 + #xff770bdd + #x13661e76 + #xff330811 + #x4550735 + #x7660544 + #x316ff11 + #x6440d66 + #xcd7ffdd + #x13661e77 + #xff330811 + #x4550735 + #x7660544 + #x316ff11 + #xb64ff66 + #x64dff44 + #xff770ddd + #x13661d76 + #xff330811 + #x4550735 + #x7660544 + #x416ff11 + #xa64ff66 + #x54dff44 + #xdd7ffdd + #x1d76ff77 + #x8111366 + #x735ff33 + #x5440455 + #xff110766 + #xa660516 + #xedd0644 + #x1d76ff77 + #x8111366 + #x635ff33 + #x454ff55 + #x7660544 + #x516ff11 + #x864ff66 + #x54dff44 + #xfd7ffdd + #x1c76ff77 + #x8111366 + #x635ff33 + #x5440555 + #xff110766 + #x8660616 + #x11dd0644 + #x13661c77 + #xff330811 + #xff550535 + #x5440554 + #x7110766 + #x664ff66 + #x54dff44 + #x11d7ffdd + #x13661c77 + #xff330811 + #xff550535 + #x5440554 + #xff110666 + #x6660816 + #x11dd0644 + #x1c76ff77 + #x8111366 + #x535ff33 + #x554ff55 + #x6660544 + #xff660911 + #xff440464 + #xffdd054d + #x1d7711d7 + #x9111366 + #x435ff33 + #x5440655 + #xff110566 + #xff660916 + #x6440464 + #xff7711dd + #x13661d76 + #x3330a11 + #x654ff55 + #xa110b44 + #x36dff66 + #x54dff44 + #x10d7ffdd + #x1e76ff77 + #xa111366 + #x5535fc33 + #x44074555 + #x16ff110a + #xddfe660a + #x64402d4 + #xff7711dd + #x13661e76 + #xfe330b11 + #x44085455 + #x16ff110a + #x6dfa6609 + #x4444d4dd + #xffdd054d + #x1e7712d7 + #xb111366 + #x955ff33 + #xff110a44 + #x2660916 + #x64401dd + #xff7713dd + #x13661d76 + #xff330b11 + #xa440934 + #x916ff11 + #xfedd0266 + #xdd054dd4 + #x7713d7ff + #x661d76ff + #x330b1113 + #x440934ff + #x16ff110a + #x6dff6609 + #x7714dd09 + #x1113661e + #x440a330b + #x16ff110a + #x6dff660a + #xd7ffdd07 + #x76ff7713 + #x1113661e + #x37fe330a + #xa440977 + #xb16ff11 + #x14dd0766 + #x13661f77 + #x1330a11 + #x874ff77 + #xff110a44 + #x6660b16 + #x13d7ffdd + #x1f76ff77 + #x9111366 + #x237ff33 + #x8440877 + #xff770311 + #xff660976 + #x14dd051d + #x13662077 + #x3330911 + #x774ff77 + #x3110844 + #x771ff77 + #x4330211 + #x13d7ffdd + #x2076ff77 + #x8111366 + #x337ff33 + #x774ff77 + #x3110844 + #x771ff77 + #xff330211 + #x13dd043d + #x13662177 + #x5330811 + #x8440777 + #xff770311 + #x2110771 + #x431ff33 + #x11d7ffdd + #x2176ff77 + #x8111366 + #xff770533 + #x8440674 + #xff770311 + #x2110771 + #x1d31fe33 + #x7711dd04 + #x11136622 + #x77063308 + #x11084406 + #x71ff7703 + #x33021107 + #x41d31fe + #xfd7ffdd + #x2276ff77 + #x8111366 + #x5770733 + #x3110844 + #x771ff77 + #xfe220211 + #xdd051d21 + #x6623770f + #x33081113 + #x74ff7707 + #x11064404 + #x440314ff + #x22021109 + #x111121fd + #xd7ffdd04 + #x76ff770d + #x11136623 + #x77083308 + #x64344fe + #x1131fc33 + #x44031411 + #x22021109 + #x111121fc + #xddd041d + #x13662477 + #x8330811 + #x774ff77 + #x1131fc33 + #x44031411 + #x22021109 + #x110221ff + #xd7ffdd04 + #x76ff770b + #x11136624 + #x73ff7711 + #x31fc3307 + #x3141111 + #x2110944 + #x221ff22 + #x41dff11 + #x25770bdd + #x11111366 + #xfc330877 + #x14111131 + #x11114403 + #xd7ffdd04 + #x76ff7709 + #x11136625 + #x73ff7710 + #x31fc3308 + #x3141111 + #x6110944 + #x511ff55 + #x267709dd + #x10111366 + #xfc330977 + #x14111131 + #x11094403 + #x11ff5506 + #xd7ffdd05 + #x76ff7707 + #x11136626 + #x73ff770f + #x31fc3309 + #x3141111 + #x6110944 + #x1d11fe55 + #x7707dd05 + #x11136627 + #x330a770f + #x111031ff + #x11025506 + #xd7ffdd04 + #x76ff7705 + #x11136627 + #x73ff770e + #x36ff330a + #x61ff6607 + #x55061107 + #x1dff1102 + #x7705dd04 + #x11136628 + #x330b770e + #x660736ff + #x110761ff + #x11035506 + #xd1fedd03 + #xff770317 + #x13662876 + #xff770d11 + #xff330b73 + #xff660736 + #x6110761 + #xff110355 + #x1dd021d + #x29770311 + #xd111366 + #xff330c77 + #xff660736 + #x6110761 + #x1110455 + #x11d1fddd + #xff770211 + #x13662976 + #xff770c11 + #xff330c73 + #xff660736 + #x6110761 + #xfe110455 + #x1102d11d + #x777717fd + #x1113662a + #x73ff770c + #x36ff330c + #x61ff6607 + #x55061107 + #x77fe110a + #x13662a76 + #xff770c11 + #xff330c73 + #xff660736 + #x6110761 + #xff110a55 + #x13662b17 + #xff770c11 + #xff330c73 + #xff660736 + #xff111961 + #x13662b16 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #x2c110944 + #xc111366 + #xc73ff77 + #x736ff33 + #x561ff66 + #x8440911 + #x2c16ff11 + #xc111366 + #xc73ff77 + #x736ff33 + #x561ff66 + #x8440911 + #x13662d11 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #xff110744 + #x13662d16 + #xff770c11 + #xff330c73 + #xff660736 + #x9110561 + #x2e110744 + #xc111366 + #xc73ff77 + #xff660833 + #x9110561 + #xff110644 + #x13662e16 + #xff770c11 + #xff330673 + #x8550435 + #x561ff66 + #x6440911 + #x13662f11 + #xff770c11 + #xff330673 + #xff550335 + #xff660857 + #x9110561 + #x2f110644 + #xc111366 + #x673ff77 + #x335ff33 + #x7657fe55 + #x61ff6607 + #x44091105 + #x662f1106 + #x770c1113 + #x330673ff + #x550335ff + #x66077701 + #x110561ff + #x11064409 + #x1113662f + #x55024415 + #x777757fc + #xff660676 + #x9110561 + #x2f110644 + #x15111366 + #x3550244 + #xff660677 + #x9110561 + #x2f110644 + #x15111366 + #x3550244 + #x4550177 + #x561ff66 + #x6440911 + #x13662f11 + #x2441511 + #x7757fd55 + #xb550277 + #xfd440d11 + #x2f111141 + #x15111366 + #xfe550344 + #x55027577 + #x440d110b + #x222242fd + #x1113662f + #x55034415 + #x550357ff + #x440d110b + #x222242fc + #x13662e26 + #x8441511 + #xd110b55 + #x242ff44 + #x13662e22 + #x8441511 + #xd110b55 + #x242ff44 + #x2d26ff22 + #x15111366 + #xb550844 + #xff440d11 + #x2d220342 + #x15111366 + #xb550844 + #xff440d11 + #xff220342 + #x13662c26 + #x8441511 + #xd110b55 + #x442ff44 + #x13662c22 + #x8441511 + #xd110b55 + #x442ff44 + #x2b26ff22 + #x15111366 + #xb550844 + #xff440d11 + #xff220442 + #x13662b26 + #x8441511 + #xd110b55 + #x542ff44 + #x13662b22 + #x8441511 + #xd110b55 + #x542ff44 + #x13662b22 + #xff441511 + #xfd110b41 + #x4333313 + #x5440e11 + #x2a26ff22 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff440e11 + #xff220442 + #x13662a26 + #xff441511 + #xfd110441 + #x3333313 + #x3313fd11 + #xf110433 + #xff220444 + #x13662a26 + #xff441511 + #xfd110441 + #x3333313 + #x3313fd11 + #xf110433 + #x342ff44 + #x2a26ff22 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff441011 + #x2a110341 + #x15111366 + #x441ff44 + #x3313fd11 + #xfd110333 + #x4333313 + #xff441011 + #xff110341 + #x13662916 + #xff441511 + #xfd110441 + #x3222212 + #x3313fd11 + #x10110433 + #x441ff44 + #x13662911 + #xff441511 + #xfd110441 + #x3222212 + #x3313fd11 + #x10110433 + #x441ff44 + #x2816ff11 + #x15111366 + #x441ff44 + #x2212fd11 + #xfd110322 + #x4333313 + #xff441011 + #x28110541 + #xc111366 + #xfd110e77 + #x3222212 + #x3313fd11 + #x10110433 + #x541ff44 + #x2716ff11 + #xc111366 + #xfd110e77 + #x3222212 + #x3313fd11 + #x10110433 + #x641ff44 + #x13662711 + #x12770c11 + #x1161fa66 + #x33331311 + #x44101104 + #x110641ff + #x662616ff + #x770c1113 + #x11016613 + #x333313fd + #x44101104 + #x110741ff + #x11136626 + #x6613770c + #x131161fb + #x11043333 + #x41ff4410 + #x16ff1107 + #x11136625 + #x6614770c + #x44101108 + #x110841ff + #x11136625 + #x6614770c + #x110761ff + #x41ff4410 + #x16ff1108 + #x11136624 + #x6615770c + #x44101107 + #x110941ff + #x11136624 + #x6615770c + #x110661ff + #x41ff4410 + #x16ff1109 + #x11136623 + #x6616770c + #x44101106 + #x110a41ff + #x11136623 + #x6616770c + #x110561ff + #x41ff4410 + #x16ff110a + #x11136622 + #x6617770c + #x44101105 + #x110b41ff + #x11136622 + #x6617770c + #x112261ff + #x662116ff + #x77081113 + #x661b76ff + #x66211123 + #x77091113 + #x1123661b + #x662016ff + #x77091113 + #x661a76ff + #x770a1159 + #x1159661a + #x661a770a + #x770a1159 + #x1159661a + #x6616770a + #x667677fc + #x8115966 + #x1776ff77 + #x7677fc66 + #x11596666 + #x66187708 + #x667677fc + #x7115966 + #x1876ff77 + #x7677fc66 + #x11596666 + #x76ff7707 + #x77fc6618 + #x1c666676 + #x1144fc11 + #x11384111 + #x76ff7707 + #x77fc6618 + #x1b666676 + #xfc440111 + #x41441411 + #x772b1137 + #x111471ff + #x414414fb + #x11384414 + #x71ff772b + #x14f6110f + #x41141141 + #x44414414 + #x2b113844 + #xf71ff77 + #xfc440111 + #x11444411 + #x11384403 + #x771e220c + #x440574ff + #x110741ff + #x444414f9 + #x11444411 + #x11014403 + #x113544ff + #x771e220c + #x440574ff + #x110741ff + #x444414fb + #x44051441 + #x441441fd + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x41ff440c + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x41ff440c + #x220c1135 + #x74ff771e + #x41ff4405 + #x14ff1106 + #x11fe440d + #xc113344 + #x5771f22 + #x641ff44 + #xf14ff11 + #x3241ff44 + #x1f220c11 + #x474ff77 + #x341ff44 + #x32441411 + #x1f220c11 + #x1e74ff77 + #xc113244 + #x1e771f22 + #x3241ff44 + #x1f220c11 + #xfe441e77 + #x11311411 + #x771f220c + #x41fd441e + #x11304144 + #x771f220c + #x440d74ff + #x106466fe + #xc113044 + #xff771f22 + #x4440474 + #x1440311 + #xff440f66 + #xc113041 + #x4772022 + #x3110444 + #x6646fe44 + #x1131440f + #x7720220c + #x770344ff + #x44031104 + #x446646fb + #x44106666 + #x220c112d + #x11057725 + #x46ff4402 + #x64ff6603 + #x112d440f + #x7725220c + #x44031105 + #x64ff6603 + #x112d440f + #x7724220d + #x44021105 + #x660346ff + #x440e64ff + #x112d41ff + #x7724220d + #x44021105 + #x440f6604 + #x220d112e + #x11057724 + #x46ff4401 + #x64ff6603 + #x41ff440e + #x220d112e + #x11057724 + #x66044401 + #x41ff440f + #x2211112e + #x11057720 + #x34614fe + #xf64ff66 + #x11112f44 + #x6772022 + #xf660411 + #x11113044 + #x5772022 + #x316ff11 + #xe64ff66 + #x3041ff44 + #x20221111 + #xff110577 + #xff660316 + #xff440d11 + #x11113141 + #x6772022 + #xff660211 + #xff440d61 + #x11113241 + #x6772022 + #x6616fc11 + #x440a1166 + #x411441fd + #x22111133 + #x11077720 + #x116166fd + #x11ff4402 + #x41ff4406 + #x22111135 + #x11077720 + #x110216ff + #x11ff4401 + #x11fd4404 + #x11354144 + #x77202211 + #x14fd110b + #x44041144 + #x414411fd + #x22111135 + #x110e7720 + #x11fd4404 + #x11354144 + #x77202211 + #x4404110e + #x22111138 + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x2211114c + #x114c7720 + #x77202211 + #x1138 + ) + :layer14 (new 'static 'array uint32 448 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x29007f00 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #x10005522 + #x1772ff77 + #x11005522 + #x55221777 + #xff771100 + #x55221672 + #x16771200 + #x12005522 + #x3220377 + #xd42ff44 + #x12005522 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x240ff44 + #xff660800 + #x12005660 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xfc005260 + #x67666606 + #x70ff7707 + #x4404000c + #x240ff + #x60ff6608 + #x6fc0052 + #x7676666 + #xc70ff77 + #xff440800 + #xff660746 + #xfc005260 + #x67666606 + #x70ff7707 + #x4408000c + #x660746ff + #x5260ff + #x666606f9 + #x76777767 + #xf6602 + #x46ff4408 + #x60ff6607 + #x6ff0052 + #x77016602 + #xf6603 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x66084408 + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #x4408000f + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x330a6608 + #x6608000d + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #xd330a + #x67ff6608 + #x70ff7714 + #x6ff003c + #x330a6608 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x470ff + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6870ff + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x7f441c + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x38007f + #x0 + #x0 + ) + :layer15 (new 'static 'array uint32 512 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #xff001700 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #xff551205 + #xff006a50 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x47553605 + #x3605ff00 + #xff004755 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #xff002633 + #x4553605 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000455 + #x56331a03 + #x4550700 + #x1a03ff00 + #x7005633 + #xff000466 + #x56331a03 + #x19660e00 + #x10005633 + #x56331766 + #xff661100 + #x56331563 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x56330900 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xb661200 + #x1c330900 + #xff441e00 + #x12001940 + #x9000b66 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #x1e001c33 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #xa003033 + #x1940ff44 + #xff660d00 + #x9000f60 + #x26003033 + #xb46ff44 + #xf60ff66 + #x30330900 + #xa442800 + #xf60ff66 + #x30330900 + #x9442900 + #xf60ff66 + #x30330900 + #x8442a00 + #xf60ff66 + #x30330900 + #x7442b00 + #xf60ff66 + #x30330900 + #x6442c00 + #xf60ff66 + #x30330900 + #xff442c00 + #xff660546 + #x9000f60 + #x2d003033 + #xff660544 + #x9000f60 + #x2d003033 + #x9001644 + #x2d003033 + #x9001644 + #x2d003033 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #x9001644 + #xff002733 + #x2d770707 + #xc770944 + #x27330900 + #x707ff00 + #x2c74ff77 + #xc770944 + #x27330900 + #x707ff00 + #x2b74ff77 + #xc770a44 + #x27330900 + #x807ff00 + #xff442a77 + #xc770a47 + #x27330900 + #x807ff00 + #xb442a77 + #x9000c77 + #xff002733 + #x28770907 + #xb47ff44 + #x9000c77 + #xff002733 + #x8772907 + #xc770c44 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x2907ff00 + #xff440777 + #xc770c47 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #x9000c77 + #xff002733 + #xc773f07 + #x27330900 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xf000c77 + #x2030ff33 + #x3f07ff00 + #xff003e77 + #x3e773f07 + #x3f07ff00 + #xff003e77 + #x3e773f07 + #x3f07ff00 + #x7f007f77 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1d00 + ) + :layer16 (new 'static 'array uint32 448 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x29007f00 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #xff006422 + #x64221902 + #x1902ff00 + #x10005522 + #x1772ff77 + #x11005522 + #x55221777 + #xff771100 + #x55221672 + #x16771200 + #x12005522 + #x3220377 + #xd42ff44 + #x12005522 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x6340ff44 + #x2771200 + #xff440400 + #x12006340 + #x4000277 + #x240ff44 + #xff660800 + #x12005660 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x12660206 + #x4000277 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xff005260 + #x7660206 + #xc70ff77 + #xff440400 + #x8000240 + #x5260ff66 + #x206ff00 + #xff770766 + #x4000c70 + #x240ff44 + #xff660800 + #xfc005260 + #x67666606 + #x70ff7707 + #x4404000c + #x240ff + #x60ff6608 + #x6fc0052 + #x7676666 + #xc70ff77 + #xff440800 + #xff660746 + #xfc005260 + #x67666606 + #x70ff7707 + #x4408000c + #x660746ff + #x5260ff + #x666606f9 + #x76777767 + #xf6602 + #x46ff4408 + #x60ff6607 + #x6ff0052 + #x77016602 + #xf6603 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x46ff4408 + #x60ff6607 + #x7ff0003 + #x70ff770f + #x6ff003c + #xf6608 + #x66084408 + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #x4408000f + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x186608 + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x63ff6607 + #xd330a + #x60ff6608 + #x7ff0003 + #x70ff770f + #x6ff003c + #x330a6608 + #x6608000d + #x360ff + #x770f07ff + #x3c70ff + #x660806ff + #xd330a + #x67ff6608 + #x70ff7714 + #x6ff003c + #x330a6608 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x33070049 + #x6608000d + #x771467ff + #x4970ff + #xd3307 + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x77080049 + #xb70ff + #x67ff6608 + #x70ff7714 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x70ff7710 + #x44050035 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x44050041 + #x70ff7716 + #x7ff0018 + #x417705 + #x77164405 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x1870ff + #x770507ff + #x77080055 + #x470ff + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x57771a + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6c70ff + #x67705 + #x70ff7704 + #x7705006c + #x77040006 + #x6870ff + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x62441c + #x7f441c + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x38007f + #x0 + #x0 + ) + :layer17 (new 'static 'array uint32 692 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x35002c00 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x4840ff44 + #xff443500 + #x35004840 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x3530ff33 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x3530ff33 + #x3d40ff44 + #xff330900 + #xff443530 + #x9003d40 + #x4430fd33 + #x4770647 + #x747ff44 + #x1d74ff77 + #x3d40ff44 + #xff330900 + #x1b771937 + #x3d40ff44 + #xff330900 + #xff772837 + #xff440b74 + #x9003d40 + #x2937ff33 + #xff440b77 + #x9003d40 + #x2937ff33 + #xa74ff77 + #x3d40ff44 + #xff330900 + #xa772a37 + #x3d40ff44 + #xff330900 + #xff772a37 + #xff440974 + #x9003d40 + #x2a37ff33 + #x974ff77 + #x3d40ff44 + #xff330900 + #xff772a37 + #xff440974 + #x9003d40 + #x2a37ff33 + #x974ff77 + #x3d40ff44 + #xff330900 + #xa772a37 + #x3d40ff44 + #xff330900 + #xff772937 + #xff440a74 + #xa003d40 + #xb772933 + #x3d40ff44 + #x28330a00 + #xb74ff77 + #x3d40ff44 + #x28330a00 + #xff440c77 + #xa003d40 + #xff772733 + #xff440c74 + #xa003d40 + #xd772733 + #x3d40ff44 + #xff330a00 + #xff772537 + #xff440d74 + #xa003d40 + #x2537ff33 + #xff440e77 + #xa003d40 + #x2437ff33 + #xe74ff77 + #x3d40ff44 + #xff330a00 + #xf772437 + #x3d40ff44 + #x9330b00 + #xff661977 + #xff440574 + #x21771947 + #xb05ff00 + #x9330a55 + #x6661977 + #x21771a44 + #xb05ff00 + #xff330a55 + #x19770837 + #xff440566 + #x21771a47 + #xb05ff00 + #xff330a55 + #xff770437 + #xff661c76 + #x1b440464 + #xff002177 + #xa550b05 + #x437ff33 + #x1d76ff77 + #xff440366 + #x21771b47 + #x1c05ff00 + #x1d56ff55 + #x264ff66 + #x21771c44 + #x1c05ff00 + #x1e56ff55 + #xff440166 + #x21771c47 + #x1c05ff00 + #x1e56ff55 + #x4464fe66 + #x21771d + #x551c05ff + #x661256ff + #x440364ff + #x660646ff + #x771d47ff + #x5ff0021 + #x56ff551c + #x64ff6608 + #x46ff4403 + #x44066602 + #x67ff6606 + #x21771d + #x551c05ff + #x660656ff + #x46ff4411 + #x67ff6605 + #x21771d + #x551c05ff + #x660556ff + #x441164ff + #x660646ff + #x21771d + #x551c05ff + #x660456ff + #x441364ff + #x771d6606 + #x5ff0021 + #x56ff551c + #x44146604 + #x660546ff + #x21771d + #x551c05ff + #x660356ff + #x441564ff + #x67ff6605 + #x21771c + #x551c05ff + #x660356ff + #x46ff4416 + #x67ff6604 + #x21771c + #x551c05ff + #x660256ff + #x441764ff + #x67ff6604 + #x21771c + #x551c05ff + #x660256ff + #x441764ff + #x660446ff + #x21771c + #x551c05ff + #x660256ff + #x46ff4418 + #x771c6604 + #x5ff0021 + #x56ff551c + #x44186602 + #x660446ff + #x21771c + #x551c05ff + #x660256ff + #x46ff4418 + #x67ff6604 + #x21771b + #x551c05ff + #x660256ff + #x46ff4418 + #x67ff6604 + #x21771b + #x551c05ff + #x666656fc + #xff441864 + #xff660446 + #x21771b67 + #x1c05ff00 + #x6656fc55 + #x44186466 + #x660446ff + #x771b67ff + #x5ff0021 + #x56fc551c + #x18646666 + #x546ff44 + #x21771b66 + #x1c05ff00 + #x6656fd55 + #xff441966 + #x1b660546 + #xff002177 + #xfd551c05 + #x19666656 + #x546ff44 + #x21771b66 + #xc05ff00 + #x456ff55 + #xff442666 + #xff660546 + #x21771a67 + #xc05ff00 + #x456ff55 + #xff442666 + #xff660546 + #x2f771a67 + #x406ff00 + #xff442666 + #x1a660646 + #xff002f77 + #x26660406 + #x646ff44 + #x2f771a66 + #x406ff00 + #xff442666 + #xff660646 + #x2f771967 + #x406ff00 + #xff442666 + #xff660646 + #x2f771967 + #x406ff00 + #xff442666 + #x19660746 + #xff002f77 + #x26660406 + #x746ff44 + #x2f771966 + #x406ff00 + #xff442666 + #x19660746 + #xff002f77 + #x26660406 + #x746ff44 + #x1867ff66 + #xff002f77 + #x26660406 + #x846ff44 + #x2f771866 + #x406ff00 + #xff442666 + #xff660846 + #x2f771767 + #x406ff00 + #xff442666 + #xff660846 + #x2f771767 + #x406ff00 + #xff442666 + #x17660946 + #xff002f77 + #x26660406 + #x946ff44 + #x2f771766 + #x406ff00 + #xff442666 + #xff660946 + #x2f771667 + #x406ff00 + #xff442666 + #xff660946 + #x2f771667 + #x406ff00 + #xff442666 + #x16660a46 + #xff002f77 + #x26660406 + #xa46ff44 + #x2f771666 + #x406ff00 + #xff442666 + #x16660a46 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xa46ff44 + #x1567ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x2f771566 + #x406ff00 + #xff442666 + #x15660b46 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xb46ff44 + #x1467ff66 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x2f771466 + #x406ff00 + #xff442666 + #x14660c46 + #xff002f77 + #x26660406 + #xc46ff44 + #x1367ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x2f771366 + #x406ff00 + #xff442666 + #x13660d46 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002f77 + #x26660406 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xd46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x26660926 + #xff660e44 + #x26771267 + #x202ff00 + #x926ff22 + #xe442666 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xe46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xe46ff44 + #x1267ff66 + #xff002677 + #xff220202 + #x25660926 + #xff660f44 + #x26771267 + #xe02ff00 + #x2224ff22 + #xf46ff44 + #x1267ff66 + #xff002677 + #xff220e02 + #xff442224 + #xff660f46 + #x26771267 + #xe02ff00 + #x2224ff22 + #xff661044 + #x26771267 + #xe02ff00 + #x2124ff22 + #x1046ff44 + #x1267ff66 + #xff002677 + #xff220e02 + #xff442124 + #xff660546 + #x17550565 + #xff002677 + #xff220e02 + #x6442124 + #x565ff66 + #x26771755 + #xe02ff00 + #x2124ff22 + #xff660644 + #x17550565 + #xff002677 + #xff220e02 + #xff442024 + #xff660646 + #x17550565 + #xff002677 + #xff220e02 + #xff442024 + #xff660646 + #x17550565 + #xff002677 + #xff220e02 + #x7442024 + #x565ff66 + #x26771755 + #xe02ff00 + #x2024ff22 + #xff660744 + #x17550565 + #xff002677 + #xff220e02 + #x7442024 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xe02ff00 + #x1f24ff22 + #x746ff44 + #x565ff66 + #x26771755 + #xc02ff00 + #x2124ff22 + #xff660844 + #x17550565 + #xff002677 + #xff220c02 + #x8442124 + #x565ff66 + #x26771755 + #xc02ff00 + #x2124ff22 + #xff660844 + #x17550565 + #xff002677 + #xff220c02 + #x8442124 + #x17550666 + #xff002677 + #xff220c02 + #x8442124 + #x17550666 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #xff660744 + #x17550665 + #xff002677 + #x1f220f02 + #x7660744 + #x26771755 + #xf02ff00 + #x7441f22 + #x17550766 + #xff002677 + #x1f220f02 + #x7660744 + #x26771755 + #xf02ff00 + #xff441e22 + #xff660646 + #x3e550765 + #xf02ff00 + #x7441e22 + #x765ff66 + #xff003e55 + #x1e220f02 + #x8660744 + #xff003e55 + #x1e220f02 + #x8660744 + #xff003e55 + #x1e220f02 + #xff660644 + #x3e550865 + #xf02ff00 + #x6441e22 + #x3e550966 + #xf02ff00 + #x6441e22 + #x3e550966 + #xf02ff00 + #x5441e22 + #x965ff66 + #xff003e55 + #x6220f02 + #x6646fb44 + #x12664664 + #xa660544 + #xff003e55 + #x5220f02 + #xff660544 + #x5441164 + #x3e550a66 + #xf02ff00 + #xff440422 + #xff660546 + #xff441064 + #xff660446 + #x3e550a65 + #xf02ff00 + #x7440422 + #xff441066 + #xff660446 + #x3e550a65 + #xf02ff00 + #xff440322 + #x10660746 + #xb660544 + #x13004855 + #xff440566 + #xff660e46 + #x48550b65 + #xff662900 + #x48550b65 + #xc662900 + #x29004855 + #x48550c66 + #xd662800 + #x27004855 + #xd65ff66 + #x26004855 + #xe65ff66 + #x25004855 + #xf65ff66 + #x24004855 + #x1065ff66 + #x23004855 + #x1165ff66 + #x22004855 + #x48551366 + #xff661d00 + #x48551765 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x48552e65 + #xff660600 + #x7f552e65 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x1b00 + #x0 + #x0 + ) + :layer18 (new 'static 'array uint32 1168 + #x452301f8 + #xcdab8967 + #x80037ef + #x7510ff11 + #xff110800 + #x8007510 + #x7510ff11 + #xff110800 + #x8007510 + #x7510ff11 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440704 + #x10660646 + #xff110800 + #xff005310 + #xff440204 + #x5000540 + #x8001066 + #x5310ff11 + #x204ff00 + #x540ff44 + #x9660500 + #x12770100 + #xff550111 + #xff004c50 + #xff440204 + #x5000540 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #x5000540 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #xff550111 + #x18000650 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x1111277 + #x650ff55 + #xff221800 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x9111277 + #xff221855 + #xff002b20 + #xff440204 + #xff000740 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x204ff00 + #x740ff44 + #x206ff00 + #x1000966 + #x9111277 + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #x9660206 + #x12770100 + #x18550911 + #x2b20ff22 + #x201ff00 + #x710ff11 + #x206ff00 + #xff000266 + #x12770707 + #x18550911 + #x2b20ff22 + #x201ff00 + #x710ff11 + #x506ff00 + #x767ff66 + #x9111277 + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002b20 + #xff110201 + #xff000710 + #xff660506 + #x2770767 + #xfd110daa + #x8a5aa1a + #xff221855 + #xff002720 + #xff550205 + #xff110251 + #x3550315 + #x506ff00 + #x667ff66 + #x27aff77 + #xfd110daa + #x8a5aa1a + #x2220455 + #xff221044 + #xff002720 + #x2550305 + #x3550411 + #x506ff00 + #x667ff66 + #xdaa0377 + #xaa1afc11 + #x5507a5aa + #x44022204 + #x220f42ff + #x2720ff + #x550305ff + #x55041102 + #x6ff0003 + #x60ff6605 + #xaa040005 + #x1aff110d + #xa5ffaa02 + #x22035506 + #x440324ff + #x20ff220f + #x5ff0027 + #x11025503 + #x35504 + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x5ff0038 + #x3550b + #x660506ff + #x560ff + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5fc0021 + #x4777755 + #x1770155 + #x4001155 + #xff110daa + #xffaa021a + #xff0007a0 + #x15440604 + #x2170ff77 + #x5505fc00 + #x55047777 + #x55017701 + #xaa040011 + #x1aff110d + #xa0ffaa02 + #x4ff0007 + #x77154406 + #x2170ff + #x775505fc + #x1550477 + #x11550177 + #xdaa0400 + #x21aff11 + #x7a0ffaa + #x604ff00 + #xff771544 + #xfc002170 + #x77775505 + #x77015504 + #x115501 + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x11550b + #x110daa04 + #xaa021aff + #x7a0ff + #x440604ff + #x70ff7715 + #x5ff0021 + #x33025503 + #x115504 + #x110daa04 + #xaa021aff + #x7a0ff + #x440804ff + #x771247ff + #x2170ff + #x550305ff + #x55043302 + #xaa040011 + #x11023304 + #x330413ff + #xaa023aff + #x7a0ff + #x440804ff + #x771247ff + #x2170ff + #x550305ff + #x55043302 + #xaa040011 + #x3aff330d + #xa0ffaa02 + #x4ff0007 + #x47ff4408 + #x70ff7712 + #x5ff0021 + #x33025503 + #xe5504 + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x5ff0021 + #x53ff5502 + #x35ff3302 + #xe5503 + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x771247ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x771247ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x47ff4408 + #x70ff7712 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x940ff + #x770707ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x40ff4408 + #x7ff0009 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x5331b + #x440804ff + #x940ff + #x770707ff + #x2570ff + #x330203ff + #x1230ff + #x331b03ff + #x4ff0005 + #x40ff4408 + #x7ff0009 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff0025 + #x30ff3302 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #xaff0025 + #xa0ffaa02 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x4ff0025 + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x551105ff + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x4ff000b + #x40ff4402 + #x3ff0012 + #x1331b + #x550605ff + #x55072202 + #x7ff0005 + #x70ff7707 + #x3ff000a + #x30ff330c + #x55090009 + #xe50ff + #x331b03ff + #x5ff0001 + #x22025506 + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1331b + #x550505ff + #x220252ff + #x55507 + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x360ff + #x50ff5509 + #x3ff000e + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x220362ff + #x51ff5509 + #x44fe1104 + #xff220742 + #xc331b23 + #xc20ff22 + #x707ff00 + #xa70ff77 + #xc03ff00 + #x436ff33 + #x362ff66 + #xff550922 + #xfe110451 + #x22074244 + #x331b23ff + #x20ff220c + #x7ff000c + #x70ff7707 + #x3ff000a + #x36ff330c + #x62ff6604 + #x55092203 + #x110451ff + #x74244fe + #x1b23ff22 + #xff220c33 + #xff000c20 + #xff770707 + #xff000a70 + #xff330c03 + #xff660436 + #x9220362 + #x451ff55 + #x4244fe11 + #x23ff2207 + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x660436ff + #x220362ff + #x51ff5509 + #x44fe1104 + #xff220742 + #xc331b23 + #xc20ff22 + #x707ff00 + #xa70ff77 + #xc03ff00 + #x436ff33 + #x362ff66 + #xff550922 + #xfe110451 + #x22074244 + #x331b23ff + #x20ff220c + #x7ff000c + #x70ff7707 + #x3ff000a + #x36ff330c + #x62ff6604 + #x55092203 + #x110451ff + #x74244fe + #x1b23ff22 + #xff220c33 + #xff000c20 + #xff770707 + #xff000a70 + #xff330c03 + #xff660436 + #x9220362 + #x451ff55 + #x4244fe11 + #x23ff2207 + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x220c331b + #xc20ff + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #xa70ff + #x330c03ff + #x930ff + #x50ff5509 + #x3ff000e + #x1a331b + #x770707ff + #x1170ff + #x30ff3306 + #xbff000b + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xbff000e + #xb0ffbb02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x10ff1103 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x4ff0011 + #x40ff4402 + #xaff000e + #xa0ffaa02 + #x3ff0012 + #x1a331b + #x770707ff + #x1170ff + #x440204ff + #xe40ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5502000f + #x55054402 + #x850ff + #xaa020aff + #x12a0ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x5504000f + #x550550ff + #x660c56ff + #x1260ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x550b000f + #x660c56ff + #x1260ff + #x331b03ff + #x7ff001a + #x70ff7707 + #x550b000f + #x660c56ff + #x1560ff + #x60ff6616 + #x7ff001c + #x70ff7707 + #x5507000f + #x5502cdff + #x660c56ff + #x1560ff + #x60ff6616 + #x7ff001c + #x70ff7707 + #x550b000f + #x660c56ff + #x1560ff + #x62fd6615 + #x182222 + #x70ff770b + #x550b000f + #x660c56ff + #x1560ff + #x62ff6615 + #x20ff220c + #x770b000c + #xf70ff + #x56ff550b + #x60ff660c + #x66150015 + #x220e62ff + #x770b000b + #xf70ff + #x56ff550b + #x60ff660c + #x66150015 + #x220f62ff + #x920ff + #x70ff770b + #x550b000f + #x660c56ff + #x1560ff + #x62ff6615 + #x82211 + #x70ff770b + #x5502000f + #x55052202 + #x660c56ff + #x1560ff + #x62ff6615 + #x20ff2212 + #x1ff0002 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66150023 + #x221662ff + #x110221ff + #x70ff770b + #x5502000f + #x55052202 + #x2350ff + #x62ff6615 + #x21ff2216 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xd60ff + #x21ff2207 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xe60ff + #x21ff2206 + #x770b1102 + #xf70ff + #x22025502 + #x50ff5505 + #x66160023 + #xf60ff + #x21ff2205 + #x770b1102 + #xf70ff + #x50ff550b + #x66160023 + #x1060ff + #x220302ff + #x110221ff + #x70ff770b + #x550b000f + #x2350ff + #x60ff6616 + #x770b0019 + #xf70ff + #x50ff550b + #x66160023 + #x3660ff + #x50ff550b + #x66160023 + #x3660ff + #x50ff550b + #x66160023 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x66160067 + #x6760ff + #x60ff6616 + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x7f007f + #x2e007f + #x0 + #x0 + ) + :layer19 (new 'static 'array uint32 668 + #x452301f8 + #xcdab8967 + #x7f007fef + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4b007f00 + #xff330a00 + #xa007330 + #x7330ff33 + #xff330a00 + #xa007330 + #x7330ff33 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x64770e37 + #xff330a00 + #x5e770e37 + #xa660500 + #xe37ff33 + #x6005e77 + #xe330a66 + #x6005e77 + #x963ff66 + #xd37ff33 + #x7005e77 + #xd330a66 + #x7005e77 + #xff330a66 + #x5e770c37 + #xff660700 + #xc330a63 + #x7005e77 + #xa63ff66 + #xb37ff33 + #x7005e77 + #xb63ff66 + #x5e770b33 + #xff660700 + #xff330b63 + #x56770a37 + #x604ff00 + #xff660744 + #xa330c63 + #xff005677 + #xff440604 + #xff660646 + #xff330c63 + #x56770937 + #x704ff00 + #xff660644 + #xff330c63 + #x56770937 + #x704ff00 + #x546ff44 + #xc63ff66 + #x937ff33 + #xff005677 + #x5440804 + #xc63ff66 + #x930ff33 + #xff005677 + #xff440804 + #xff660446 + #xff330c63 + #x56770930 + #x804ff00 + #x446ff44 + #xc63ff66 + #x907ff33 + #xff005677 + #x4440904 + #xb63ff66 + #xa30ff33 + #xff005677 + #x4440904 + #xb63ff66 + #xa07ff33 + #xff005677 + #x4440904 + #xa63ff66 + #xb30ff33 + #xff006677 + #xff330a03 + #x66770b07 + #x903ff00 + #xc30ff33 + #xff006677 + #xff330903 + #x66770c07 + #x803ff00 + #xd30ff33 + #xff006677 + #xff330803 + #x1c770d07 + #xff551800 + #xff002f50 + #xff330703 + #x1c770e30 + #xff551800 + #xff002f50 + #xff330703 + #x1c770e07 + #xff551800 + #xff002f50 + #xff330603 + #x1c770f30 + #xff551800 + #xff003750 + #x1c770f07 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #x1c771100 + #xff551800 + #x11003650 + #x18001c77 + #x3650ff55 + #xff770a00 + #x1c660576 + #xff551800 + #xa003650 + #x576ff77 + #x18001c66 + #x3650ff55 + #x7770900 + #x18001c66 + #x3650ff55 + #x8770800 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #x9770700 + #x18001c66 + #x3650ff55 + #xff770600 + #x1c660976 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #xff003750 + #x1c660f06 + #xff551800 + #x2e660856 + #xf06ff00 + #x18001c66 + #x856ff55 + #xff002e66 + #x1c660f06 + #xfc551400 + #x55556556 + #x2e6609 + #x660f06ff + #x5513001c + #x666650fb + #x66095665 + #x6ff002e + #x1c660f + #xff5513 + #xa660d + #x550f05ff + #x1150ff + #x660f06ff + #x5512001c + #xd0600fe + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x1150ff55 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff001150 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x651ff55 + #x910ff11 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #x1c660f06 + #xff551200 + #xa660e06 + #xf05ff00 + #x651ff55 + #x910ff11 + #xf06ff00 + #x12001c66 + #xe06ff55 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #x3660506 + #x2110ff11 + #x4550d00 + #xe06ff44 + #xff000a66 + #xff550f05 + #xff110651 + #xff000910 + #xff660406 + #xff110361 + #xd002110 + #xff440455 + #xff660e06 + #xff330a00 + #xff550e35 + #xff110651 + #xff000910 + #xff660306 + #xff110461 + #xd002110 + #xfe440455 + #x660d0600 + #x330a00ff + #x550e35ff + #x111c51ff + #x2110ff + #x4404550d + #xd0600fe + #xa00ff66 + #xe35ff33 + #x1c51ff55 + #x2110ff11 + #x4550d00 + #x600fe44 + #xff660d + #x35ff330a + #x51ff550e + #x10ff111c + #x550e0021 + #xfe4403 + #xff660d06 + #xff330a00 + #xff550435 + #xff550915 + #xff111b51 + #xe002110 + #xfe440355 + #x660d0600 + #x330a00ff + #x30fc + #xff110201 + #x1b550915 + #x2110ff11 + #xff550e00 + #xfe440254 + #x660d0600 + #x330a00ff + #x30fc + #xff110301 + #x1b550815 + #x2110ff11 + #x2550f00 + #x600fe44 + #xff660d + #x30fc330a + #x4010000 + #x1b550811 + #x2110ff11 + #x2550f00 + #x600fe44 + #xff660d + #x30fc330a + #x4010000 + #xff550711 + #xff111b51 + #xf002110 + #xfe440255 + #x660d0600 + #x330a00ff + #x30fc + #x7110401 + #x1b51ff55 + #x2110ff11 + #x3550f00 + #xd06ff00 + #xa00ff66 + #x30fc33 + #x11040100 + #x1fc0003 + #x1c551511 + #x2110ff11 + #x3550f00 + #xd06ff00 + #xa00ff66 + #x30fc33 + #x11040100 + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33090002 + #x220232ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x220332ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x220332ff + #x110421ff + #x11200003 + #x2b10ff + #x76ff7709 + #x60ff660a + #x33080002 + #x21ff2205 + #x31103 + #x10ff1120 + #x7709002b + #x660a76ff + #x260ff + #x22063308 + #x31103 + #x10ff1120 + #x770a002b + #x60ff660a + #x33070002 + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770a1107 + #x660976ff + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770b1107 + #x60ff6609 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110701ff + #x770a17ff + #x660876ff + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x770b1108 + #x60ff6608 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110901ff + #x76ff770a + #x60ff6607 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110a01ff + #x6607770a + #x330a60ff + #x220732ff + #x520ff + #x10ff1120 + #x1ff0022 + #x17ff110a + #x76ff7709 + #x60ff6606 + #x32ff330a + #x20ff2207 + #x11200005 + #x2210ff + #x110b01ff + #x76ff7709 + #x60ff6606 + #x32ff330a + #x20ff2207 + #x1ff0009 + #x10ff111b + #x1ff0022 + #x7709110b + #x60ff6607 + #x32ff330a + #x20ff2207 + #x1ff0009 + #x10ff111b + #x1ff0022 + #x7708110b + #x660776ff + #x330a60ff + #x220732ff + #x920ff + #x111b01ff + #x2210ff + #x110b01ff + #x76ff7708 + #x60ff6607 + #x153308 + #x111b01ff + #x2210ff + #x110b01ff + #x66087708 + #x330860ff + #x1ff0015 + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x153308 + #x111b01ff + #x2210ff + #x110b01ff + #x66082208 + #x330860ff + #x40ff4404 + #x1ff000f + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x34ff3307 + #x40ff4404 + #x1ff000f + #x10ff111b + #x1ff0022 + #x2208110b + #x60ff6608 + #x44053307 + #xf40ff + #x111b01ff + #x2210ff + #x110b01ff + #x20ff2209 + #x33060007 + #x440534ff + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x220912ff + #x720ff + #x44063306 + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x220912ff + #x720ff + #x44073305 + #xf40ff + #x111b01ff + #x2210ff + #x110a01ff + #x24ff220a + #x43fe440b + #xff440734 + #xff000f40 + #xff111b01 + #xff002210 + #xff110901 + #xff220a12 + #xff440c24 + #xff440734 + #xff000f40 + #xff111b01 + #xff002210 + #xff110901 + #xff220a12 + #xff441524 + #xff000f40 + #xff111b01 + #xff002210 + #xb110901 + #x1524ff22 + #xf40ff44 + #x1b01ff00 + #x2210ff11 + #x901ff00 + #xff220b11 + #xff441524 + #xff000f40 + #xff111b01 + #xff002210 + #xff110801 + #xff220b12 + #xff441524 + #xff000f40 + #xff111b01 + #xe002a10 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #x1524ff22 + #x5840ff44 + #xff220e00 + #xff441524 + #xe005840 + #xff441622 + #xd005840 + #x1624ff22 + #x5840ff44 + #xff220d00 + #xff441624 + #xc005840 + #xff441822 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #xff006340 + #xff441904 + #x7f007f40 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x7f007f00 + #x4300 + #x0 + ) + ) + ) diff --git a/test/decompiler/reference/jak2/engine/ui/bigmap-h_REF.gc b/test/decompiler/reference/jak2/engine/ui/bigmap-h_REF.gc index 85e176f5c..0746a0083 100644 --- a/test/decompiler/reference/jak2/engine/ui/bigmap-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/ui/bigmap-h_REF.gc @@ -123,27 +123,27 @@ ;; definition of type bigmap-compressed-layers (deftype bigmap-compressed-layers (structure) - ((data uint32 20 :offset-assert 0) - (layer0 uint32 :offset 0) - (layer1 uint32 :offset 4) - (layer2 uint32 :offset 8) - (layer3 uint32 :offset 12) - (layer4 uint32 :offset 16) - (layer5 uint32 :offset 20) - (layer6 uint32 :offset 24) - (layer7 uint32 :offset 28) - (layer8 uint32 :offset 32) - (layer9 uint32 :offset 36) - (layer10 uint32 :offset 40) - (layer11 uint32 :offset 44) - (layer12 uint32 :offset 48) - (layer13 uint32 :offset 52) - (layer14 uint32 :offset 56) - (layer15 uint32 :offset 60) - (layer16 uint32 :offset 64) - (layer17 uint32 :offset 68) - (layer18 uint32 :offset 72) - (layer19 uint32 :offset 76) + ((data (pointer uint32) 20 :offset-assert 0) + (layer0 (pointer uint32) :offset 0) + (layer1 (pointer uint32) :offset 4) + (layer2 (pointer uint32) :offset 8) + (layer3 (pointer uint32) :offset 12) + (layer4 (pointer uint32) :offset 16) + (layer5 (pointer uint32) :offset 20) + (layer6 (pointer uint32) :offset 24) + (layer7 (pointer uint32) :offset 28) + (layer8 (pointer uint32) :offset 32) + (layer9 (pointer uint32) :offset 36) + (layer10 (pointer uint32) :offset 40) + (layer11 (pointer uint32) :offset 44) + (layer12 (pointer uint32) :offset 48) + (layer13 (pointer uint32) :offset 52) + (layer14 (pointer uint32) :offset 56) + (layer15 (pointer uint32) :offset 60) + (layer16 (pointer uint32) :offset 64) + (layer17 (pointer uint32) :offset 68) + (layer18 (pointer uint32) :offset 72) + (layer19 (pointer uint32) :offset 76) ) :method-count-assert 9 :size-assert #x50 diff --git a/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc b/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc index 7575d3c12..640f2c5b4 100644 --- a/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc +++ b/test/decompiler/reference/jak2/levels/common/elec-gate_REF.gc @@ -151,9 +151,9 @@ :bolt-spec (new 'static 'lightning-spec :name #f :flags (lightning-spec-flags lsf2) - :start-color #x80ffffff - :end-color #x80000000 - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -170,9 +170,9 @@ :name #f :flags (lightning-spec-flags lsf2) :rand-func #x3 - :start-color #x80ffffff - :end-color #x80ffffff - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -1124,9 +1124,9 @@ :bolt-spec (new 'static 'lightning-spec :name #f :flags (lightning-spec-flags lsf2) - :start-color #x80ffffff - :end-color #x80000000 - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300 @@ -1143,9 +1143,9 @@ :name #f :flags (lightning-spec-flags lsf2) :rand-func #x3 - :start-color #x80ffffff - :end-color #x80ffffff - :fade-to-color #x58f00bf + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) :fade-start-factor 0.2 :fade-time 120.0 :texture #xc08300