From e65c61f3e26e796deada224636bb6da1c798f506 Mon Sep 17 00:00:00 2001 From: Tyler Wilding Date: Mon, 17 Jan 2022 11:51:26 -0500 Subject: [PATCH] tests: add a bunch of missing ref tests (#1082) * scripts: add a script to point out missing ref test files * tests: add a bunch of files to ref tests we were missing --- decompiler/config/all-types.gc | 24 +- .../jak1_ntsc_black_label/type_casts.jsonc | 15 + goal_src/levels/demo/static-screen.gc | 248 +- scripts/find-missing-ref-tests.py | 27 + .../engine/draw/drawable-tree_REF.gc | 98 + .../reference/engine/draw/drawable_REF.gc | 2211 +++ .../reference/engine/entity/entity_REF.gc | 1912 ++ .../engine/gfx/ocean/ocean-frames_REF.gc | 16395 ++++++++++++++++ .../engine/gfx/ocean/ocean-tables_REF.gc | 11589 +++++++++++ .../reference/engine/gfx/sky/sky_REF.gc | 202 + .../engine/sparticle/sparticle-h_REF.gc | 153 + .../sparticle/sparticle-launcher-h_REF.gc | 218 + .../sparticle/sparticle-launcher_REF.gc | 1362 ++ .../engine/sparticle/sparticle_REF.gc | 741 + .../engine/target/target-handler_REF.gc | 1125 ++ .../engine/ui/progress/progress_REF.gc | 2750 +++ .../reference/engine/util/glist-h_REF.gc | 125 + .../reference/kernel/gkernel_REF.gc | 1 + .../levels/demo/static-screen_REF.gc | 193 + .../levels/misty/babak-with-cannon_REF.gc | 532 + .../reference/levels/misty/mistycannon_REF.gc | 2133 ++ .../reference/levels/ogre/ogreboss_REF.gc | 50 +- test/offline/config.jsonc | 17 + 23 files changed, 41912 insertions(+), 209 deletions(-) create mode 100644 scripts/find-missing-ref-tests.py create mode 100644 test/decompiler/reference/engine/draw/drawable-tree_REF.gc create mode 100644 test/decompiler/reference/engine/draw/drawable_REF.gc create mode 100644 test/decompiler/reference/engine/entity/entity_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/ocean/ocean-frames_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/ocean/ocean-tables_REF.gc create mode 100644 test/decompiler/reference/engine/gfx/sky/sky_REF.gc create mode 100644 test/decompiler/reference/engine/sparticle/sparticle-h_REF.gc create mode 100644 test/decompiler/reference/engine/sparticle/sparticle-launcher-h_REF.gc create mode 100644 test/decompiler/reference/engine/sparticle/sparticle-launcher_REF.gc create mode 100644 test/decompiler/reference/engine/sparticle/sparticle_REF.gc create mode 100644 test/decompiler/reference/engine/target/target-handler_REF.gc create mode 100644 test/decompiler/reference/engine/ui/progress/progress_REF.gc create mode 100644 test/decompiler/reference/engine/util/glist-h_REF.gc create mode 100644 test/decompiler/reference/levels/demo/static-screen_REF.gc create mode 100644 test/decompiler/reference/levels/misty/babak-with-cannon_REF.gc create mode 100644 test/decompiler/reference/levels/misty/mistycannon_REF.gc diff --git a/decompiler/config/all-types.gc b/decompiler/config/all-types.gc index 2d1cbfdb2d..57ac8fd6a4 100644 --- a/decompiler/config/all-types.gc +++ b/decompiler/config/all-types.gc @@ -9047,16 +9047,18 @@ :flag-assert #x900000002 ) -; (deftype shadow-edge (structure) -; ((ind-0 uint16 :offset-assert 0) -; (ind-1 uint16 :offset-assert 2) -; (tri-0 uint16 :offset-assert 4) -; (tri-1 uint16 :offset-assert 6) -; ) -; :method-count-assert 9 -; :size-assert #x4 -; :flag-assert #x900000004 -; ) +;; Defined twice, the second definition won? +;; the fields here are wrong and need to be corrected assuming that is the case +;; (deftype shadow-edge (structure) +;; ((ind-0 uint16 :offset-assert 0) +;; (ind-1 uint16 :offset-assert 2) +;; (tri-0 uint16 :offset-assert 4) +;; (tri-1 uint16 :offset-assert 6) +;; ) +;; :method-count-assert 9 +;; :size-assert #x4 +;; :flag-assert #x900000008 +;; ) (deftype shadow-tri (structure) ((ind-0 uint8 :offset-assert 0) @@ -14971,7 +14973,7 @@ (param1 float :offset-assert 24) (param2 float :offset-assert 28) (param3 int32 :offset-assert 32) - (value-to-modify pointer :offset-assert 36) + (value-to-modify pointer :offset-assert 36) ;; pointer to - symbol | ? ) :method-count-assert 9 :size-assert #x28 diff --git a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc index 4f44c1130a..bb693b5bcd 100644 --- a/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc +++ b/decompiler/config/jak1_ntsc_black_label/type_casts.jsonc @@ -7756,5 +7756,20 @@ [31, "s3", "process-drawable"] ], + "(method 29 progress)": [ + [290, "a0", "(pointer symbol)"], + [299, "v1", "(pointer symbol)"], + [308, "a0", "(pointer symbol)"], + [317, "v1", "(pointer symbol)"], + [326, "a0", "(pointer symbol)"], + [589, "a0", "(pointer symbol)"], + [599, "v1", "(pointer symbol)"], + [608, "a1", "(pointer symbol)"], + [617, "v1", "(pointer symbol)"], + [626, "a1", "(pointer symbol)"], + [894, "a0", "(pointer symbol)"], + [921, "a0", "(pointer symbol)"] + ], + "placeholder-do-not-add-below": [] } diff --git a/goal_src/levels/demo/static-screen.gc b/goal_src/levels/demo/static-screen.gc index 6339a68585..e7c936e0cb 100644 --- a/goal_src/levels/demo/static-screen.gc +++ b/goal_src/levels/demo/static-screen.gc @@ -5,8 +5,8 @@ ;; name in dgo: static-screen ;; dgos: DEM, L1, TIT +;; DECOMP BEGINS -;; definition of type static-screen (deftype static-screen (process) ((part sparticle-launch-control 1 :offset-assert 112) (state-time uint64 :offset-assert 120) @@ -20,50 +20,40 @@ ) ) -;; definition for method 7 of type static-screen -;; INFO: Return type mismatch process vs static-screen. + (defmethod relocate static-screen ((obj static-screen) (arg0 int)) (let ((v1-0 *kernel-context*)) - (set! (-> v1-0 relocating-process) obj) - (set! (-> v1-0 relocating-min) (the-as int (&-> obj type))) - (set! - (-> v1-0 relocating-max) - (the-as - int - (+ (+ (-> obj allocated-length) -4 (-> process size)) (the-as int obj)) - ) + (set! (-> v1-0 relocating-process) obj) + (set! (-> v1-0 relocating-min) (the-as int (&-> obj type))) + (set! (-> v1-0 relocating-max) + (the-as int (+ (+ (-> obj allocated-length) -4 (-> process size)) (the-as int obj))) + ) + (set! (-> v1-0 relocating-offset) arg0) ) - (set! (-> v1-0 relocating-offset) arg0) - ) (dotimes (v1-2 1) - (if (nonzero? (-> obj part v1-2)) - (&+! (-> obj part v1-2) arg0) + (if (nonzero? (-> obj part v1-2)) + (&+! (-> obj part v1-2) arg0) + ) ) - ) (the-as static-screen ((method-of-type process relocate) obj arg0)) ) -;; definition for method 10 of type static-screen (defmethod deactivate static-screen ((obj static-screen)) (dotimes (s5-0 1) - (if (nonzero? (-> obj part s5-0)) - (kill-and-free-particles (-> obj part s5-0)) + (if (nonzero? (-> obj part s5-0)) + (kill-and-free-particles (-> obj part s5-0)) + ) ) - ) ((method-of-type process deactivate) obj) (none) ) -;; failed to figure out what this is: -(set! - (-> *part-id-table* 2966) - (new 'static 'sparticle-launcher - :init-specs - (new 'static 'inline-array sp-field-init-spec 12 - (sp-tex spt-texture (new 'static 'texture-id :page #x5c6)) +(defpart 2966 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x5c6)) (sp-flt spt-num 1.0) (sp-flt spt-y (meters 1.18)) - (sp-flt spt-scale-x (meters 15.0)) + (sp-flt spt-scale-x (meters 15)) (sp-flt spt-scale-y (meters 6.5)) (sp-flt spt-r 128.0) (sp-flt spt-g 128.0) @@ -71,21 +61,15 @@ (sp-flt spt-a 128.0) (sp-int spt-timer -1) (sp-cpuinfo-flags bit2 bit9 bit13) - (sp-end) ) - ) ) -;; failed to figure out what this is: -(set! - (-> *part-id-table* 2967) - (new 'static 'sparticle-launcher - :init-specs - (new 'static 'inline-array sp-field-init-spec 12 - (sp-tex spt-texture (new 'static 'texture-id :index #x1 :page #x5c6)) +(defpart 2967 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x1 :page #x5c6)) (sp-flt spt-num 1.0) (sp-flt spt-y (meters -1.264)) - (sp-flt spt-scale-x (meters 15.0)) + (sp-flt spt-scale-x (meters 15)) (sp-flt spt-scale-y (meters 3.25)) (sp-flt spt-r 128.0) (sp-flt spt-g 128.0) @@ -93,21 +77,15 @@ (sp-flt spt-a 128.0) (sp-int spt-timer -1) (sp-cpuinfo-flags bit2 bit9 bit13) - (sp-end) ) - ) ) -;; failed to figure out what this is: -(set! - (-> *part-id-table* 2968) - (new 'static 'sparticle-launcher - :init-specs - (new 'static 'inline-array sp-field-init-spec 12 - (sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #x5c6)) +(defpart 2968 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #x5c6)) (sp-flt spt-num 1.0) (sp-flt spt-y (meters -2.482)) - (sp-flt spt-scale-x (meters 15.0)) + (sp-flt spt-scale-x (meters 15)) (sp-flt spt-scale-y (meters 1.625)) (sp-flt spt-r 128.0) (sp-flt spt-g 128.0) @@ -115,159 +93,83 @@ (sp-flt spt-a 128.0) (sp-int spt-timer -1) (sp-cpuinfo-flags bit2 bit9 bit13) - (sp-end) ) - ) ) -;; failed to figure out what this is: -(set! - (-> *part-group-id-table* 707) - (new 'static 'sparticle-launch-group - :length 3 - :duration #xbb8 - :linger-duration #x5dc - :flags (sp-group-flag screen-space) - :name "group-part-screen1" - :launcher - (new 'static 'inline-array sparticle-group-item 3 - (sp-item 2966 :flags (launch-asap)) - (sp-item 2967 :flags (launch-asap)) - (sp-item 2968 :flags (launch-asap)) - ) - :bounds (new 'static 'sphere :w 4096.0) - ) +(defpartgroup group-part-screen1 + :id 707 + :flags (screen-space) + :bounds (static-bspherem 0 0 0 1) + :parts + ((sp-item 2966 :flags (launch-asap)) (sp-item 2967 :flags (launch-asap)) (sp-item 2968 :flags (launch-asap))) ) -;; failed to figure out what this is: (defstate idle (static-screen) :virtual #t :enter (behavior ((arg0 int) (arg1 int) (arg2 symbol)) - (set! (-> *setting-control* current bg-a) 1.0) - (set! (-> *setting-control* default bg-a) 0.0) - (push-setting! *setting-control* self 'common-page 'set 0.0 (ash 1 (+ arg0 1))) - (none) - ) + (set! (-> *setting-control* current bg-a) 1.0) + (set! (-> *setting-control* default bg-a) 0.0) + (push-setting! *setting-control* self 'common-page 'set 0.0 (ash 1 (+ arg0 1))) + (none) + ) :trans (behavior () - (hide-hud-quick) - (spawn (-> self part 0) *zero-vector*) - 0 - (none) - ) + (hide-hud-quick) + (spawn (-> self part 0) *zero-vector*) + 0 + (none) + ) :code (behavior ((arg0 int) (arg1 int) (arg2 symbol)) - (local-vars (v1-6 symbol)) - (set! (-> self state-time) (the-as uint (-> *display* base-frame-counter))) - (until v1-6 - (suspend) - (set! - v1-6 - (or - (and - (> arg1 0) - (>= - (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) - arg1 - ) - ) - (and - arg2 - (>= - (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) - 300 - ) - (logtest? - (-> *cpad-list* cpads 0 button0-rel 0) - (pad-buttons select start triangle circle x square) - ) - ) + (local-vars (v1-6 symbol)) + (set! (-> self state-time) (the-as uint (-> *display* base-frame-counter))) + (until v1-6 + (suspend) + (set! v1-6 + (or (and (> arg1 0) (>= (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) arg1)) + (and arg2 + (>= (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) 300) + (cpad-pressed? 0 select start triangle circle x square) + ) + ) + ) ) - ) - ) - (set! (-> *setting-control* default bg-a) 1.0) - (while - (!= (-> *setting-control* current bg-a) (-> *setting-control* default bg-a)) + (set! (-> *setting-control* default bg-a) 1.0) + (while (!= (-> *setting-control* current bg-a) (-> *setting-control* default bg-a)) + (suspend) + ) + (clear-pending-settings-from-process *setting-control* self 'common-page) (suspend) + 0 + (none) ) - (clear-pending-settings-from-process *setting-control* self 'common-page) - (suspend) - 0 - (none) - ) ) -;; definition for function static-screen-init-by-other -;; INFO: Return type mismatch int vs none. -(defbehavior - static-screen-init-by-other static-screen - ((arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int) (arg5 symbol)) +(defbehavior static-screen-init-by-other static-screen ((arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int) (arg5 symbol)) (let ((s3-0 (lookup-part-group-by-name "group-part-screen1"))) - (when - (and - s3-0 - (nonzero? s3-0) - (type-type? (-> s3-0 type) sparticle-launch-group) - ) - (set! - (-> *part-id-table* 2966 init-specs 0 initial-valuef) - (the-as float arg1) - ) - (set! - (-> *part-id-table* 2967 init-specs 0 initial-valuef) - (the-as float arg2) - ) - (set! - (-> *part-id-table* 2968 init-specs 0 initial-valuef) - (the-as float arg3) - ) - (set! - (-> self part 0) - (create-launch-control (the-as sparticle-launch-group s3-0) self) - ) - (go-virtual idle arg0 arg4 arg5) + (when (and s3-0 (nonzero? s3-0) (type-type? (-> s3-0 type) sparticle-launch-group)) + (set! (-> *part-id-table* 2966 init-specs 0 initial-valuef) (the-as float arg1)) + (set! (-> *part-id-table* 2967 init-specs 0 initial-valuef) (the-as float arg2)) + (set! (-> *part-id-table* 2968 init-specs 0 initial-valuef) (the-as float arg3)) + (set! (-> self part 0) (create-launch-control (the-as sparticle-launch-group s3-0) self)) + (go-virtual idle arg0 arg4 arg5) + ) ) - ) 0 (none) ) -;; definition for function static-screen-spawn -;; Used lq/sq -(defun - static-screen-spawn - ((arg0 int) - (arg1 int) - (arg2 int) - (arg3 int) - (arg4 int) - (arg5 symbol) - (arg6 target) - ) +(defun static-screen-spawn ((arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int) (arg5 symbol) (arg6 target)) (local-vars (sv-16 process)) (set! sv-16 (get-process *default-dead-pool* static-screen #x4000)) (when sv-16 - (let ((t9-1 (method-of-type static-screen activate))) - (t9-1 - (the-as static-screen sv-16) - arg6 - 'static-screen - (the-as pointer #x70004000) - ) + (let ((t9-1 (method-of-type static-screen activate))) + (t9-1 (the-as static-screen sv-16) arg6 'static-screen (the-as pointer #x70004000)) + ) + (run-now-in-process sv-16 static-screen-init-by-other arg0 arg1 arg2 arg3 arg4 arg5) + (-> sv-16 ppointer) ) - (run-now-in-process - sv-16 - static-screen-init-by-other - arg0 - arg1 - arg2 - arg3 - arg4 - arg5 - ) - (-> sv-16 ppointer) - ) ) diff --git a/scripts/find-missing-ref-tests.py b/scripts/find-missing-ref-tests.py new file mode 100644 index 0000000000..d74a22a0bd --- /dev/null +++ b/scripts/find-missing-ref-tests.py @@ -0,0 +1,27 @@ +# Find files that are added to gsrc, but not to ref tests +from jak1_file_list import file_list +import os + +src_path = "" +for f in file_list: + if f[2] != 3: + continue + if f[4] == "kernel": + continue + src_path = f[4] + gsrc_exists = False + gsrc_path = "./goal_src/{}/{}.gc".format(src_path, f[0]) + if os.path.exists(gsrc_path): + with open(gsrc_path, "r") as gsrc_file: + lines = gsrc_file.readlines() + line_count = len(lines) + if line_count > 100: + gsrc_exists = True + + # now check if there is a ref test file + if gsrc_exists: + ref_path = "./test/decompiler/reference/{}/{}_REF.gc".format(src_path, f[0]) + if not os.path.exists(ref_path): + print("No Ref Test for - {}".format(f[0])) + print(gsrc_path) + print(ref_path) diff --git a/test/decompiler/reference/engine/draw/drawable-tree_REF.gc b/test/decompiler/reference/engine/draw/drawable-tree_REF.gc new file mode 100644 index 0000000000..9a09c4818a --- /dev/null +++ b/test/decompiler/reference/engine/draw/drawable-tree_REF.gc @@ -0,0 +1,98 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for method 10 of type drawable-tree-array +;; INFO: Return type mismatch int vs none. +(defmethod draw drawable-tree-array ((obj drawable-tree-array) (arg0 drawable-tree-array) (arg1 display-frame)) + (let ((v1-1 (-> (the-as terrain-context #x70000000) bsp lev-index))) + (case (-> *level* level v1-1 display?) + (('special 'special-vis #f) + ) + (else + (dotimes (s3-0 (-> obj length)) + (draw (-> obj trees s3-0) (-> arg0 trees s3-0) arg1) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 14 of type drawable-tree-array +;; INFO: Return type mismatch int vs none. +(defmethod collect-stats drawable-tree-array ((obj drawable-tree-array)) + (dotimes (s5-0 (-> obj length)) + (collect-stats (-> obj trees s5-0)) + ) + 0 + (none) + ) + +;; definition for method 15 of type drawable-tree-array +;; INFO: Return type mismatch int vs none. +(defmethod debug-draw drawable-tree-array ((obj drawable-tree-array) (arg0 drawable) (arg1 display-frame)) + (dotimes (s3-0 (-> obj length)) + (debug-draw (-> obj trees s3-0) (-> (the-as drawable-tree-array arg0) trees s3-0) arg1) + ) + 0 + (none) + ) + +;; definition for method 16 of type drawable-tree +;; WARN: Unsupported inline assembly instruction kind - [sra t4, t4, 1] +(defmethod unpack-vis drawable-tree ((obj drawable-tree) (arg0 (pointer int8)) (arg1 (pointer int8))) + (local-vars (t5-1 int)) + (let* ((v1-0 (the-as drawable-inline-array-node (-> obj data 0))) + (a3-1 (/ (-> v1-0 data 0 id) 8)) + (t0-0 (-> v1-0 length)) + (v1-1 (&+ arg0 a3-1)) + (a3-3 (/ (+ t0-0 7) 8)) + ) + (dotimes (t0-1 a3-3) + (let ((t1-0 (-> arg1 0))) + (set! arg1 (&-> arg1 1)) + (set! (-> v1-1 0) t1-0) + ) + (set! v1-1 (&-> v1-1 1)) + ) + ) + (let ((v1-5 (+ (-> obj length) -1))) + (when (nonzero? v1-5) + (dotimes (a3-5 v1-5) + (let* ((t0-4 (-> obj data a3-5)) + (t2-0 (-> obj data (+ a3-5 1))) + (t1-5 (/ (-> (the-as drawable-inline-array-node t0-4) data 0 id) 8)) + (t2-2 (/ (-> (the-as drawable-inline-array-node t2-0) data 0 id) 8)) + (t0-5 (-> (the-as drawable-inline-array-node t0-4) length)) + (t1-6 (&+ arg0 t1-5)) + (t2-3 (&+ arg0 t2-2)) + ) + (while #t + (let ((t3-0 (-> t1-6 0))) + (set! t1-6 (&-> t1-6 1)) + (let ((t4-0 128)) + (label cfg-7) + (b! (zero? (logand t3-0 t4-0)) cfg-9 :delay (set! t5-1 (-> arg1 0))) + (set! arg1 (&-> arg1 1)) + (set! (-> t2-3 0) t5-1) + (label cfg-9) + (+! t0-5 -1) + (b! (zero? t0-5) cfg-12 :delay (.sra t4-0 t4-0 1)) + (b! (nonzero? t4-0) cfg-7 :delay (set! t2-3 (&-> t2-3 1))) + ) + ) + ) + ) + (label cfg-12) + (nop!) + 0 + ) + ) + ) + arg1 + ) + + + + diff --git a/test/decompiler/reference/engine/draw/drawable_REF.gc b/test/decompiler/reference/engine/draw/drawable_REF.gc new file mode 100644 index 0000000000..65c86214e1 --- /dev/null +++ b/test/decompiler/reference/engine/draw/drawable_REF.gc @@ -0,0 +1,2211 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for function sphere-cull +;; WARN: Bad vector register dependency: vf16 +;; WARN: Bad vector register dependency: vf17 +;; WARN: Bad vector register dependency: vf18 +;; WARN: Bad vector register dependency: vf19 +(defun sphere-cull ((arg0 vector)) + (local-vars (r0-0 uint128) (v1-0 uint128) (v1-1 uint128) (v1-2 uint128)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf10 :class vf) + (vf16 :class vf) + (vf17 :class vf) + (vf18 :class vf) + (vf19 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (.lvf vf10 (&-> arg0 quad)) + (.mul.x.vf acc vf16 vf10) + (.add.mul.y.vf acc vf17 vf10 acc) + (.add.mul.z.vf acc vf18 vf10 acc) + (.sub.mul.w.vf vf9 vf19 vf0 acc) + (.add.w.vf vf9 vf9 vf10) + (.mov v1-0 vf9) + (.pcgtw v1-1 r0-0 v1-0) + (.ppach v1-2 r0-0 v1-1) + (zero? (the-as int v1-2)) + ) + ) + +;; definition for function guard-band-cull +;; WARN: Bad vector register dependency: vf20 +;; WARN: Bad vector register dependency: vf21 +;; WARN: Bad vector register dependency: vf22 +;; WARN: Bad vector register dependency: vf23 +(defun guard-band-cull ((arg0 vector)) + (local-vars (r0-0 uint128) (v1-0 uint128) (v1-1 uint128) (v1-2 uint128)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf10 :class vf) + (vf20 :class vf) + (vf21 :class vf) + (vf22 :class vf) + (vf23 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (.lvf vf10 (&-> arg0 quad)) + (.mul.x.vf acc vf20 vf10) + (.add.mul.y.vf acc vf21 vf10 acc) + (.add.mul.z.vf acc vf22 vf10 acc) + (.sub.mul.w.vf vf9 vf23 vf0 acc) + (.sub.w.vf vf9 vf9 vf10) + (.mov v1-0 vf9) + (.pcgtw v1-1 r0-0 v1-0) + (.ppach v1-2 r0-0 v1-1) + (nonzero? (the-as int v1-2)) + ) + ) + +;; definition for function sphere-in-view-frustum? +(defun sphere-in-view-frustum? ((arg0 sphere)) + (local-vars (r0-0 uint128) (v1-1 uint128) (v1-2 uint128) (v1-3 uint128)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 *math-camera*)) + (.lvf vf6 (&-> arg0 quad)) + (.lvf vf1 (&-> v1-0 plane 0 quad)) + (.lvf vf2 (&-> v1-0 plane 1 quad)) + (.lvf vf3 (&-> v1-0 plane 2 quad)) + (.lvf vf4 (&-> v1-0 plane 3 quad)) + ) + (.mul.x.vf acc vf1 vf6) + (.add.mul.y.vf acc vf2 vf6 acc) + (.add.mul.z.vf acc vf3 vf6 acc) + (.sub.mul.w.vf vf5 vf4 vf0 acc) + (.add.w.vf vf5 vf5 vf6) + (.mov v1-1 vf5) + (.pcgtw v1-2 r0-0 v1-1) + (.ppach v1-3 r0-0 v1-2) + (zero? (the-as int v1-3)) + ) + ) + +;; definition for function line-in-view-frustum? +(defun line-in-view-frustum? ((arg0 vector) (arg1 vector)) + (local-vars + (r0-0 uint128) + (v1-1 uint128) + (v1-2 uint128) + (v1-3 uint128) + (a0-1 uint128) + (a0-2 uint128) + (a0-3 uint128) + ) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf10 :class vf) + (vf16 :class vf) + (vf17 :class vf) + (vf18 :class vf) + (vf19 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 *math-camera*)) + (.lvf vf9 (&-> arg0 quad)) + (.lvf vf10 (&-> arg1 quad)) + (.lvf vf16 (&-> v1-0 plane 0 quad)) + (.lvf vf17 (&-> v1-0 plane 1 quad)) + (.lvf vf18 (&-> v1-0 plane 2 quad)) + (.lvf vf19 (&-> v1-0 plane 3 quad)) + ) + (.mul.x.vf acc vf16 vf9) + (.add.mul.y.vf acc vf17 vf9 acc) + (.add.mul.z.vf acc vf18 vf9 acc) + (.sub.mul.w.vf vf9 vf19 vf0 acc) + (.mul.x.vf acc vf16 vf10) + (.add.mul.y.vf acc vf17 vf10 acc) + (.add.mul.z.vf acc vf18 vf10 acc) + (.sub.mul.w.vf vf10 vf19 vf0 acc) + (.mov v1-1 vf9) + (.pcgtw v1-2 r0-0 v1-1) + (.ppach v1-3 r0-0 v1-2) + (.mov a0-1 vf10) + (.pcgtw a0-2 r0-0 a0-1) + (.ppach a0-3 r0-0 a0-2) + (zero? (logand (the-as int v1-3) (the-as int a0-3))) + ) + ) + +;; definition for function vis-cull +;; WARN: Type Propagation failed: Failed type prop at op 3 ((set! v1 (l.b (+ v1 #x38b0)))): Could not get type of load: (set! v1 (l.b (+ v1 #x38b0))). +;; WARN: Type Propagation failed: Type analysis failed +;; WARN: Unsupported inline assembly instruction kind - [sra a1, a0, 3] +;; WARN: Unsupported inline assembly instruction kind - [addiu a0, a0, 56] +(defun vis-cull ((a0-0 int)) + (local-vars (v0-0 none) (v1-0 int) (v1-1 int) (v1-2 none) (v1-3 none) (a0-1 none) (a0-2 none) (a1-0 int)) + (set! v1-0 #x70000000) + (.sra a1-0 a0-0 3) + (set! v1-1 (+ a1-0 v1-0)) + (set! v1-2 (the-as none (l.b (+ v1-1 #x38b0)))) + (set! a0-1 (the-as none (logand a0-0 7))) + (.addiu a0-2 a0-1 56) + (set! v1-3 (the-as none (sll v1-2 a0-2))) + (set! v0-0 (the-as none (<0.si v1-3))) + (ret-value v0-0) + ) + +;; definition for function error-sphere +;; INFO: Return type mismatch int vs none. +(defun error-sphere ((arg0 drawable-error) (arg1 string)) + (when *artist-error-spheres* + (when (vis-cull (-> arg0 id)) + (when (sphere-cull (-> arg0 bsphere)) + (add-debug-sphere + #t + (bucket-id debug-draw0) + (-> arg0 bsphere) + (-> arg0 bsphere w) + (new 'static 'rgba :r #x80 :a #x80) + ) + (add-debug-text-3d #t (bucket-id debug-draw1) arg1 (-> arg0 bsphere) (font-color white) (the-as vector2h #f)) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 9 of type drawable +(defmethod login drawable ((obj drawable)) + obj + ) + +;; definition for method 10 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod draw drawable ((obj drawable) (arg0 drawable) (arg1 display-frame)) + 0 + (none) + ) + +;; definition for method 11 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod collide-with-box drawable ((obj drawable) (arg0 int) (arg1 collide-list)) + 0 + (none) + ) + +;; definition for method 12 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod collide-y-probe drawable ((obj drawable) (arg0 int) (arg1 collide-list)) + 0 + (none) + ) + +;; definition for method 13 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod collide-ray drawable ((obj drawable) (arg0 int) (arg1 collide-list)) + 0 + (none) + ) + +;; definition for method 17 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod collect-ambients drawable ((obj drawable) (arg0 sphere) (arg1 int) (arg2 ambient-list)) + 0 + (none) + ) + +;; definition for method 14 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod collect-stats drawable ((obj drawable)) + 0 + (none) + ) + +;; definition for method 15 of type drawable +;; INFO: Return type mismatch int vs none. +(defmethod debug-draw drawable ((obj drawable) (arg0 drawable) (arg1 display-frame)) + 0 + (none) + ) + +;; definition for method 10 of type drawable-error +;; INFO: Return type mismatch drawable-error vs none. +(defmethod draw drawable-error ((obj drawable-error) (arg0 drawable-error) (arg1 display-frame)) + (error-sphere arg0 (-> arg0 name)) + (none) + ) + +;; definition for method 16 of type drawable +(defmethod unpack-vis drawable ((obj drawable) (arg0 (pointer int8)) (arg1 (pointer int8))) + arg1 + ) + +;; definition for symbol *edit-instance*, type string +(define *edit-instance* (the-as string #f)) + +;; this part is debug only +(when *debug-segment* +;; definition for symbol *instance-mem-usage*, type memory-usage-block +(define *instance-mem-usage* (new 'debug 'memory-usage-block)) + +) +;; definition (debug) for function find-instance-by-name +(defun-debug find-instance-by-name ((arg0 string)) + (dotimes (s5-0 (-> *level* length)) + (let ((v1-3 (-> *level* level s5-0))) + (when (= (-> v1-3 status) 'active) + (let ((s4-0 (-> v1-3 bsp drawable-trees))) + (dotimes (s3-0 (-> s4-0 length)) + (let ((v1-7 (-> s4-0 trees s3-0))) + (case (-> v1-7 type) + ((drawable-tree-instance-shrub) + (let ((s2-0 (-> (the-as drawable-tree-instance-shrub v1-7) info prototype-inline-array-shrub))) + (dotimes (s1-0 (-> s2-0 length)) + (if (string= arg0 (the-as string (-> s2-0 data s1-0 name))) + (return (-> s2-0 data s1-0)) + ) + ) + ) + ) + ((drawable-tree-instance-tie) + (let ((s2-1 (-> (the-as drawable-tree-instance-tie v1-7) prototypes prototype-array-tie))) + (dotimes (s1-1 (-> s2-1 length)) + (if (string= arg0 (the-as string (-> s2-1 array-data s1-1 name))) + (return (-> s2-1 array-data s1-1)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as prototype-bucket #f) + ) + +;; definition (debug) for function find-instance-by-index +(defun-debug find-instance-by-index ((arg0 type) (arg1 int) (arg2 bsp-header)) + (dotimes (v1-0 (-> *level* length)) + (let ((a3-3 (-> *level* level v1-0))) + (when (= (-> a3-3 status) 'active) + (let ((a3-4 (-> a3-3 bsp))) + (when (or (not arg2) (= a3-4 arg2)) + (let ((a3-5 (-> a3-4 drawable-trees))) + (dotimes (t0-5 (-> a3-5 length)) + (let ((t1-3 (-> a3-5 trees t0-5))) + (case (-> t1-3 type) + ((drawable-tree-instance-shrub) + (when (= arg0 (-> t1-3 type)) + (let ((v1-2 (-> (the-as drawable-tree-instance-shrub t1-3) info prototype-inline-array-shrub))) + (return (-> v1-2 data arg1)) + ) + ) + ) + ((drawable-tree-instance-tie) + (when (= arg0 (-> t1-3 type)) + (let ((v1-5 (-> (the-as drawable-tree-instance-tie t1-3) prototypes prototype-array-tie))) + (return (-> v1-5 array-data arg1)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as prototype-bucket #f) + ) + +;; definition (debug) for function prototype-bucket-type +(defun-debug prototype-bucket-type ((arg0 prototype-bucket)) + (case (-> arg0 geometry 1 type) + ((prototype-shrubbery shrubbery) + instance-shrubbery + ) + ((prototype-tie prototype-tie tie-fragment) + instance-tie + ) + ) + ) + +;; definition (debug) for function prototype-bucket-recalc-fields +(defun-debug prototype-bucket-recalc-fields ((arg0 prototype-bucket)) + (case (prototype-bucket-type arg0) + ((instance-shrubbery) + (set! (-> arg0 rdists x) (/ 1.0 (- (-> arg0 dists w) (-> arg0 dists x)))) + ) + (else + (set! (-> arg0 dists z) (+ (-> arg0 dists x) (* 0.33333334 (- (-> arg0 dists w) (-> arg0 dists x))))) + (set! (-> arg0 rdists x) (/ 1.0 (- (-> arg0 dists z) (-> arg0 dists x)))) + ) + ) + (set! (-> arg0 rdists z) (/ 1.0 (- (-> arg0 dists w) (-> arg0 dists z)))) + (set! (-> arg0 dists y) (* 0.5 (-> arg0 dists x))) + (set! (-> arg0 rdists y) (/ 1.0 (-> arg0 dists y))) + arg0 + ) + +;; definition (debug) for function draw-instance-info +;; INFO: Return type mismatch object vs none. +;; Used lq/sq +(defun-debug draw-instance-info ((arg0 string)) + (local-vars + (sv-16 int) + (sv-32 uint) + (sv-48 uint) + (sv-64 int) + (sv-80 int) + (sv-96 int) + (sv-112 int) + (sv-128 int) + (sv-144 int) + ) + (when (and *display-instance-info* *edit-instance*) + (let ((s5-0 (find-instance-by-name *edit-instance*))) + (when s5-0 + (let ((s2-0 (prototype-bucket-type s5-0))) + (let ((s4-0 0)) + 0 + (cond + ((= s2-0 instance-shrubbery) + (set! s4-0 595) + ) + ((= s2-0 instance-tie) + (reset! *instance-mem-usage*) + (dotimes (s4-1 4) + (when (nonzero? (-> s5-0 geometry s4-1)) + (let* ((a0-4 (-> s5-0 geometry s4-1)) + (t9-3 (method-of-object a0-4 mem-usage)) + (a1-0 *instance-mem-usage*) + (v1-16 s4-1) + ) + (t9-3 a0-4 a1-0 (logior (cond + ((= v1-16 1) + 4 + ) + ((= v1-16 2) + 8 + ) + ((= v1-16 3) + 16 + ) + (else + 0 + ) + ) + 2 + ) + ) + ) + ) + ) + (set! s4-0 (+ (calculate-total *instance-mem-usage*) 580)) + ) + ) + (mem-usage s5-0 (reset! *instance-mem-usage*) 0) + (let ((v1-26 (calculate-total *instance-mem-usage*))) + (format + arg0 + "~%~A ~A b @ #x~X ~,,2fK/~,,2fK~%" + s2-0 + (-> s5-0 name) + s5-0 + (* 0.0009765625 (the float v1-26)) + (* 0.0009765625 (the float s4-0)) + ) + ) + ) + (format arg0 "near: ~m mid: ~m far: ~m~%" (-> s5-0 dists x) (-> s5-0 dists z) (-> s5-0 dists w)) + (let ((s3-1 0) + (s4-2 0) + ) + (cond + ((= s2-0 instance-shrubbery) + (let ((f30-0 0.0)) + (format + arg0 + "usage: vis: ~D shurb: ~D trans-shrub ~D bill: ~D in level: ~D~%" + (-> s5-0 count 0) + (-> s5-0 count 1) + (-> s5-0 count 2) + (-> s5-0 count 3) + (-> s5-0 in-level) + ) + (format arg0 "~%frag# tris dverts strlen tex~%") + (let ((s1-1 (-> s5-0 geometry 1)) + (s2-1 (+ (-> s5-0 count 1) (-> s5-0 count 2))) + ) + (dotimes (s0-0 (-> (the-as drawable-group s1-1) length)) + (set! sv-16 (shrub-num-tris (the-as shrubbery (+ (+ (* s0-0 32) 32) (the-as int s1-1))))) + (set! sv-32 (-> (the-as prototype-shrubbery (+ (the-as uint s1-1) (* s0-0 32))) data 0 header data 2)) + (set! sv-48 (-> (the-as prototype-shrubbery (+ (the-as uint s1-1) (* s0-0 32))) data 0 header data 0)) + (format + arg0 + "~5D ~4D ~5D ~6f ~D~%" + s0-0 + sv-16 + sv-32 + (/ (* 2.0 (the float sv-16)) (the float (- sv-32 (the-as uint sv-16)))) + sv-48 + ) + (+! s3-1 sv-16) + (+! s4-2 sv-32) + (set! f30-0 + (+ 29.0 + (* 5.5 (the float (- sv-32 (the-as uint sv-16)))) + (* 22.0 (the float sv-48)) + (* 8.0 (the float sv-32)) + (* 53.0 (the float (/ (+ s2-1 9) (the-as uint 10)))) + (* (the float s2-1) (+ 15.0 (* 5.0 (the float sv-48)) (* 13.5 (the float sv-32)))) + f30-0 + ) + ) + ) + (format + arg0 + "total ~4D ~5D ~6f ~D speed: ~f~%" + s3-1 + s4-2 + (/ (* 2.0 (the float s3-1)) (the float (- s4-2 s3-1))) + (-> s5-0 utextures) + (/ f30-0 (* (the float s2-1) (the float s3-1))) + ) + ) + ) + ) + ((= s2-0 instance-tie) + (set! sv-144 0) + (let ((s1-2 0) + (s0-1 0) + (s2-2 0) + ) + (format arg0 "~%level visible frags tris dverts strlen tex ttris~%") + (set! sv-64 1) + (set! sv-80 3) + (while (>= sv-80 sv-64) + (let ((v1-65 (-> s5-0 geometry sv-64))) + (set! sv-96 0) + (set! sv-112 0) + (set! sv-128 0) + (dotimes (a0-23 (-> (the-as prototype-tie v1-65) length)) + (set! sv-96 (+ sv-96 (l.hu (+ (the-as uint v1-65) (* a0-23 64) 68)))) + (set! sv-112 (+ sv-112 (l.hu (+ (the-as uint v1-65) (* a0-23 64) 70)))) + (set! sv-128 (+ sv-128 (l.hu (+ (the-as uint v1-65) (* a0-23 64) 60)))) + ) + (set! sv-144 (+ sv-144 (-> s5-0 count sv-64))) + (format arg0 "~5D ~7D ~5D ~5D" sv-64 (-> s5-0 count sv-64) (-> (the-as prototype-tie v1-65) length) sv-96) + ) + (format + arg0 + " ~5D ~6f ~3D ~5D~%" + sv-112 + (/ (* 2.0 (the float sv-96)) (the float (- sv-112 sv-96))) + sv-128 + (* (the-as uint sv-96) (-> s5-0 count sv-64)) + ) + (+! s1-2 (* (the-as uint sv-96) (-> s5-0 count sv-64))) + (+! s0-1 (* (the-as uint sv-112) (-> s5-0 count sv-64))) + (+! s3-1 sv-96) + (+! s4-2 sv-112) + (+! s2-2 sv-128) + (set! sv-64 (+ sv-64 1)) + ) + (let ((t9-18 format) + (a0-39 arg0) + (a1-22 "total ~7D/~3D ~5D") + (a3-11 (-> s5-0 in-level)) + ) + (t9-18 a0-39 a1-22 sv-144 a3-11 s3-1) + ) + (format + arg0 + " ~5D ~6f ~3D ~5D~%" + s4-2 + (/ (* 2.0 (the float s1-2)) (the float (- s0-1 s1-2))) + s2-2 + s1-2 + ) + ) + ) + ) + ) + ) + ) + ) + ) + (none) + ) + +;; definition for function dma-add-process-drawable +;; INFO: Return type mismatch int vs none. +;; WARN: Expression building failed: Function dma-add-process-drawable has a return type of none, but the expression builder found a return statement. +(defun dma-add-process-drawable ((arg0 process-drawable) (arg1 draw-control) (arg2 symbol) (arg3 dma-buffer)) + (local-vars (v1-37 float) (sv-16 process-drawable)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf15 :class vf) + (vf16 :class vf) + (vf17 :class vf) + (vf18 :class vf) + (vf19 :class vf) + (vf2 :class vf) + (vf20 :class vf) + (vf21 :class vf) + (vf22 :class vf) + (vf23 :class vf) + (vf24 :class vf) + (vf25 :class vf) + (vf26 :class vf) + (vf27 :class vf) + (vf28 :class vf) + (vf29 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (set! sv-16 arg0) + (logclear! (-> arg1 status) (draw-status drwf03)) + (when (zero? (logand (-> arg1 status) (draw-status drwf01 drwf02 drwf04))) + (let ((s4-0 (the-as vector (+ 48 (the-as int (the-as terrain-context #x70000000))))) + (s2-0 (the-as vu-lights (+ 64 (the-as int (the-as terrain-context #x70000000))))) + (s3-0 *time-of-day-context*) + ) + (.lvf vf16 (&-> arg1 origin quad)) + (.lvf vf17 (&-> arg1 bounds quad)) + (.mul.x.vf vf16 vf16 vf0 :mask #b1000) + (.add.vf vf16 vf16 vf17) + (.svf (&-> s4-0 quad) vf16) + (.lvf vf28 (&-> arg1 color-mult quad)) + (.lvf vf29 (&-> arg1 color-emissive quad)) + (when (sphere-in-view-frustum? (the-as sphere s4-0)) + (case (-> arg1 global-effect) + (((draw-effect title)) + (when (not (-> s3-0 title-updated)) + (set! (-> s3-0 title-updated) #t) + (let ((s0-0 (-> *math-camera* inv-camera-rot)) + (a1-1 (new 'stack-no-clear 'vector)) + (s1-0 (new 'stack-no-clear 'vector)) + ) + (set-vector! a1-1 0.612 0.5 -0.612 0.0) + (set-vector! s1-0 -0.696 0.174 0.696 0.0) + (vector-matrix*! (the-as vector (-> s3-0 title-light-group)) a1-1 s0-0) + (vector-matrix*! (the-as vector (-> s3-0 title-light-group dir1)) s1-0 s0-0) + ) + (set-vector! (-> *time-of-day-context* current-shadow) 0.612 -0.5 -0.612 1.0) + ) + (vu-lights<-light-group! s2-0 (-> s3-0 title-light-group)) + ) + (else + (let ((f28-0 (-> arg1 secondary-interp)) + (f30-0 (-> arg1 current-secondary-interp)) + (v1-17 (-> arg1 shadow-mask)) + (a0-10 (-> arg1 level-index)) + (s0-1 (-> s3-0 light-group (-> *target* draw light-index))) + (s1-1 (new 'stack-no-clear 'light-group)) + ) + (cond + ((= (-> arg1 light-index) 255) + ) + ((= a0-10 2) + (set! s0-1 (-> s3-0 light-group (-> arg1 light-index))) + ) + (else + (set! s0-1 (-> s3-0 moods a0-10 light-group (-> arg1 light-index))) + ) + ) + (when (not (or (= a0-10 2) (zero? v1-17))) + (let* ((a1-22 (-> s3-0 light-masks-0 a0-10)) + (a2-14 (-> s3-0 light-masks-1 a0-10)) + (f26-0 (-> s3-0 light-interp a0-10)) + (a0-13 (logand a1-22 v1-17)) + (v1-18 (logand a2-14 v1-17)) + ) + (cond + ((and (zero? a0-13) (zero? v1-18)) + ) + (else + (set! f28-0 (cond + ((and (nonzero? a0-13) (nonzero? v1-18)) + 1.0 + ) + ((zero? a0-13) + (quad-copy! (the-as pointer s1-1) (the-as pointer s0-1) 12) + (set! s0-1 s1-1) + (set! (-> s0-1 dir1 levels x) 0.0) + f26-0 + ) + (else + (quad-copy! (the-as pointer s1-1) (the-as pointer s0-1) 12) + (set! s0-1 s1-1) + (set! (-> s0-1 dir0 levels x) 0.0) + (- 1.0 f26-0) + ) + ) + ) + ) + ) + ) + ) + (if *teleport* + (set! f30-0 f28-0) + ) + (when (not (or (paused?) (= f28-0 f30-0))) + (let ((f0-15 (- f30-0 f28-0))) + (set! f30-0 (cond + ((< (fabs f0-15) 0.2) + f28-0 + ) + ((< f0-15 0.0) + (+ 0.2 f30-0) + ) + (else + (+ -0.2 f30-0) + ) + ) + ) + ) + (set! (-> arg1 current-secondary-interp) f30-0) + ) + (cond + ((= f30-0 0.0) + (vu-lights<-light-group! s2-0 s0-1) + ) + (else + (if (!= s0-1 s1-1) + (quad-copy! (the-as pointer s1-1) (the-as pointer s0-1) 12) + ) + (let ((f0-20 (- 1.0 f30-0))) + (set! (-> s1-1 dir0 levels x) (* (-> s1-1 dir0 levels x) f0-20)) + (set! (-> s1-1 dir0 levels y) (* (-> s1-1 dir0 levels y) f0-20)) + (set! (-> s1-1 dir1 levels x) (* (-> s1-1 dir1 levels x) f0-20)) + (set! (-> s1-1 dir1 levels y) (* (-> s1-1 dir1 levels y) f0-20)) + (set! (-> s1-1 dir2 levels x) (* (-> s1-1 dir2 levels x) f0-20)) + (set! (-> s1-1 dir2 levels y) (* (-> s1-1 dir2 levels y) f0-20)) + ) + (vu-lights<-light-group! s2-0 s1-1) + ) + ) + ) + (.lvf vf2 (&-> s2-0 color 0 quad)) + (.lvf vf3 (&-> s2-0 color 1 quad)) + (.lvf vf4 (&-> s2-0 color 2 quad)) + (.lvf vf5 (&-> s2-0 ambient quad)) + (.mul.vf vf5 vf5 vf28) + (.mul.vf vf2 vf2 vf28) + (.mul.vf vf3 vf3 vf28) + (.mul.vf vf4 vf4 vf28) + (.add.vf vf5 vf5 vf29) + (.svf (&-> s2-0 color 0 quad) vf2) + (.svf (&-> s2-0 color 1 quad) vf3) + (.svf (&-> s2-0 color 2 quad) vf4) + (.svf (&-> s2-0 ambient quad) vf5) + (.mov v1-37 vf5) + ) + ) + (if *display-lights* + (add-debug-lights + #t + (bucket-id debug-draw0) + (the-as (inline-array light) (-> s3-0 light-group)) + (-> arg1 origin) + ) + ) + (let ((at-0 *math-camera*)) + (.lvf vf16 (&-> at-0 plane 0 quad)) + (.lvf vf17 (&-> at-0 plane 1 quad)) + (.lvf vf18 (&-> at-0 plane 2 quad)) + (.lvf vf19 (&-> at-0 plane 3 quad)) + (.lvf vf20 (&-> at-0 guard-plane 0 quad)) + (.lvf vf21 (&-> at-0 guard-plane 1 quad)) + (.lvf vf22 (&-> at-0 guard-plane 2 quad)) + (.lvf vf23 (&-> at-0 guard-plane 3 quad)) + (.lvf vf24 (&-> at-0 camera-rot vector 0 quad)) + (.lvf vf25 (&-> at-0 camera-rot vector 1 quad)) + (.lvf vf26 (&-> at-0 camera-rot vector 2 quad)) + (.lvf vf27 (&-> at-0 camera-rot vector 3 quad)) + ) + (let ((v1-42 (the-as vector (+ 176 (the-as int (the-as terrain-context #x70000000)))))) + (.lvf vf15 (&-> s4-0 quad)) + (.mul.w.vf acc vf27 vf0) + (.add.mul.x.vf acc vf24 vf15 acc) + (.add.mul.y.vf acc vf25 vf15 acc) + (.add.mul.z.vf vf15 vf26 vf15 acc :mask #b111) + (.mul.vf vf28 vf15 vf15) + (.max.w.vf vf29 vf0 vf0) + (.add.y.vf acc vf28 vf28) + (.add.mul.z.vf vf28 vf29 vf28 acc :mask #b1) + (.sqrt.vf Q vf28 :ftf #b0) + (.sub.w.vf vf28 vf0 vf15 :mask #b1000) + (.wait.vf) + (.add.vf vf15 vf28 Q :mask #b1000) + (.svf (&-> v1-42 quad) vf15) + (when (< 0.0 (+ (-> v1-42 z) (-> arg1 bounds w))) + (let ((lod-to-use 0)) + (let ((cam-dist (-> v1-42 w))) + (when (nonzero? (-> arg1 lod-set max-lod)) + (cond + ((>= (-> arg1 force-lod) 0) + (set! lod-to-use (-> arg1 force-lod)) + (if (< (-> arg1 lod-set lod (-> arg1 lod-set max-lod) dist) cam-dist) + (return #f) + ) + ) + (else + (while (and (< lod-to-use (-> arg1 lod-set max-lod)) (< (-> arg1 lod-set lod lod-to-use dist) cam-dist)) + (+! lod-to-use 1) + ) + ) + ) + ) + (if (and (< (-> arg1 lod-set lod lod-to-use dist) cam-dist) (< (-> arg1 force-lod) 0)) + (return #f) + ) + (let ((v1-64 (-> arg1 sink-group level)) + (a0-26 (+ (-> arg1 sink-group merc-sink foreground-texture-page) 6)) + ) + (when (zero? (logand (-> arg1 status) (draw-status drwf06))) + (if (< cam-dist (-> v1-64 closest-object a0-26)) + (set! (-> v1-64 closest-object a0-26) cam-dist) + ) + (when (and (!= a0-26 6) (!= (-> arg1 level-index) 2)) + (let ((a1-45 (cond + ((< 102400.0 cam-dist) + (-> arg1 mgeo header masks 0) + ) + ((< 81920.0 cam-dist) + (-> arg1 mgeo header masks 1) + ) + (else + (-> arg1 mgeo header masks 2) + ) + ) + ) + ) + (logior! (-> v1-64 texture-mask a0-26) a1-45) + ) + ) + ) + ) + (if (or (guard-band-cull s4-0) (< cam-dist (* 1.2 (-> *math-camera* d)))) + (logior! (-> arg1 status) (draw-status drwf00)) + (logclear! (-> arg1 status) (draw-status drwf00)) + ) + (logior! (-> arg1 status) (draw-status drwf03)) + (if (logtest? (-> arg1 status) (draw-status drwf05)) + (return #f) + ) + (draw-bones arg1 arg3 cam-dist) + ) + (when (and (< lod-to-use (-> arg1 cur-lod)) (logtest? (-> arg1 status) (draw-status drwf07))) + (let ((v1-82 *matrix-engine*)) + (set! (-> v1-82 (-> v1-82 length)) (process->handle sv-16)) + (+! (-> v1-82 length) 1) + ) + ) + (lod-set! arg1 lod-to-use) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + ) + +;; definition for symbol *hud-lights*, type vu-lights +(define *hud-lights* (new 'global 'vu-lights)) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* direction 0) 1.0 0.0 0.0 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* direction 1) 0.0 1.0 0.0 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* direction 2) 0.0 0.0 1.0 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* color 0) 0.0 0.0 0.0 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* color 1) 0.0 0.0 0.0 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* color 2) 0.5 0.5 0.5 1.0) + +;; failed to figure out what this is: +(set-vector! (-> *hud-lights* ambient) 0.5 0.5 0.5 1.0) + +;; definition for function dma-add-process-drawable-hud +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defun dma-add-process-drawable-hud ((arg0 process-drawable) (arg1 draw-control) (arg2 symbol) (arg3 dma-buffer)) + (logclear! (-> arg1 status) (draw-status drwf03)) + (when (zero? (logand (-> arg1 status) (draw-status drwf01 drwf02 drwf04))) + (let ((v1-6 (the-as vu-lights (+ 64 #x70000000))) + (a0-3 *hud-lights*) + ) + (set! (-> v1-6 direction 0 quad) (-> a0-3 direction 0 quad)) + (set! (-> v1-6 direction 1 quad) (-> a0-3 direction 1 quad)) + (set! (-> v1-6 direction 2 quad) (-> a0-3 direction 2 quad)) + (set! (-> v1-6 color 0 quad) (-> a0-3 color 0 quad)) + (set! (-> v1-6 color 1 quad) (-> a0-3 color 1 quad)) + (set! (-> v1-6 color 2 quad) (-> a0-3 color 2 quad)) + (set! (-> v1-6 ambient quad) (-> a0-3 ambient quad)) + ) + (lod-set! arg1 0) + (logior! (-> arg1 status) (draw-status drwf03)) + (draw-bones-hud arg1 arg3) + ) + 0 + (none) + ) + +;; definition for function add-process-drawable +;; INFO: Return type mismatch symbol vs none. +(defun add-process-drawable ((arg0 process-drawable) (arg1 draw-control) (arg2 symbol) (arg3 dma-buffer)) + ((-> arg1 dma-add-func) arg0 arg1 arg2 arg3) + (none) + ) + +;; definition for function foreground-engine-execute +;; WARN: Type Propagation failed: Failed type prop at op 114 ((set! a0 (l.wu (+ v1 276)))): Could not get type of load: (set! a0 (l.wu (+ v1 276))). +;; WARN: Type Propagation failed: Type analysis failed +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [cache dxwbin v1, 0] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [cache dxwbin v1, 1] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +(defun foreground-engine-execute ((a0-0 engine) (a1-0 display-frame) (a2-0 int) (a3-0 int)) + (local-vars + (v0-0 profile-frame) + (v0-1 none) + (v0-2 int) + (v0-3 none) + (v0-4 profile-frame) + (v0-5 none) + (v0-6 none) + (v1-0 display) + (v1-1 int) + (v1-2 display-frame) + (v1-3 dma-buffer) + (v1-4 symbol) + (v1-6 display) + (v1-7 int) + (v1-8 display-frame) + (v1-9 type) + (v1-11 int) + (v1-12 int) + (v1-13 int) + (v1-14 pointer) + (v1-15 int) + (v1-16 type) + (v1-19 symbol) + (v1-20 display) + (v1-21 int) + (v1-22 display-frame) + (v1-23 type) + (v1-24 memory-usage-block) + (v1-25 vu1-renderer-mask) + (v1-26 vu1-renderer-mask) + (v1-28 merc-globals) + (v1-29 uint) + (v1-31 display) + (v1-32 int) + (v1-33 display-frame) + (v1-34 dma-buffer) + (v1-35 level-group) + (v1-36 int) + (v1-37 int) + (v1-39 none) + (v1-41 none) + (a0-1 display) + (a0-2 int) + (a0-3 int) + (a0-4 display) + (a0-5 int) + (a0-6 int) + (a0-7 profile-bar) + (a0-8 int) + (a0-9 int) + (a0-10 level-group) + (a0-11 dma-buffer) + (a0-12 engine) + (a0-14 display) + (a0-15 int) + (a0-16 int) + (a0-17 profile-bar) + (a0-19 display) + (a0-20 int) + (a0-21 int) + (a0-22 int) + (a0-23 int) + (a0-24 int) + (a0-25 none) + (a0-26 none) + (a0-27 none) + (a0-28 none) + (a1-1 symbol) + (a1-2 int) + (a1-3 dma-buffer) + (a1-4 symbol) + (a1-6 int) + (a1-7 int) + (a1-8 string) + (a1-9 int) + (a1-10 int) + (a1-11 int) + (a1-12 int) + (a1-13 int) + (a1-15 none) + (a1-16 none) + (a1-17 none) + (a1-18 none) + (a1-19 none) + (a1-20 none) + (a1-21 none) + (a1-22 none) + (a2-1 uint) + (a2-2 uint) + (a2-3 int) + (a2-4 display) + (a2-5 int) + (a2-6 display-frame) + (a2-7 dma-buffer) + (a2-8 pointer) + (a2-9 int) + (a2-10 none) + (a2-11 none) + (a2-12 none) + (a2-13 none) + (a2-14 none) + (a2-15 none) + (a2-16 none) + (a3-1 display) + (a3-2 int) + (a3-3 int) + (a3-4 none) + (a3-5 none) + (a3-6 none) + (s2-1 dma-buffer) + (s4-0 pointer) + (s4-1 pointer) + (t9-0 (function profile-bar symbol rgba profile-frame)) + (t9-1 (function dma-buffer dma-foreground-sink-group none)) + (t9-2 (function engine object int)) + (t9-3 (function none)) + (t9-4 (function profile-bar symbol rgba profile-frame)) + (t9-5 none) + ) + (when (begin + (when (begin + (when (begin + (set! v1-0 *display*) + (set! a0-1 *display*) + (set! a0-2 (-> a0-1 on-screen)) + (set! a0-3 (sll a0-2 5)) + (set! v1-1 (+ v1-0 a0-3)) + (set! v1-2 (dynamic-array-field-access v1-1 frames PLACEHOLDER frame)) + (set! v1-3 (-> v1-2 global-buf)) + (set! s4-0 (-> v1-3 base)) + (set! v1-4 *debug-segment*) + v1-4 + ) + (set! v1-6 *display*) + (set! a0-4 *display*) + (set! a0-5 (-> a0-4 on-screen)) + (set! a0-6 (sll a0-5 5)) + (set! v1-7 (+ v1-6 a0-6)) + (set! v1-8 (dynamic-array-field-access v1-7 frames PLACEHOLDER frame)) + (set! a0-7 (-> v1-8 profile-bar 0)) + (set! v1-9 (-> a0-7 type)) + (set! t9-0 (method-of-type v1-9 add-frame)) + (set! a1-1 'draw) + (set! a2-1 (the-as uint #x80400040)) + (call! a0-7 a1-1 a2-1) + (set! v1-10 v0-0) + ) + (set! v1-11 (sll a3-0 5)) + (set! v1-12 (+ v1-11 272)) + (set! a0-8 2608) + (set! a0-9 (*.si a0-8 a2-0)) + (set! v1-13 (+ v1-12 a0-9)) + (set! a0-10 *level*) + (set! a1-2 (+ v1-13 a0-10)) + (set! s2-1 (-> a1-0 global-buf)) + (set! v1-14 (-> s2-1 base)) + (.sync.l) + (.cache dxwbin v1-14 0) + (.sync.l) + (.cache dxwbin v1-14 1) + (.sync.l) + (set! v1-15 0) + (set! t9-1 bones-init) + (set! a0-11 s2-1) + (call! a0-11 a1-2) + (set! v1-16 (-> a0-0 type)) + (set! t9-2 (method-of-type v1-16 execute-connections)) + (set! a0-12 a0-0) + (set! a1-3 s2-1) + (call! a0-12 a1-3) + (set! v1-17 v0-2) + (set! t9-3 bones-wrapup) + (call!) + (set! v1-18 v0-3) + (set! v1-19 *debug-segment*) + v1-19 + ) + (set! v1-20 *display*) + (set! a0-14 *display*) + (set! a0-15 (-> a0-14 on-screen)) + (set! a0-16 (sll a0-15 5)) + (set! v1-21 (+ v1-20 a0-16)) + (set! v1-22 (dynamic-array-field-access v1-21 frames PLACEHOLDER frame)) + (set! a0-17 (-> v1-22 profile-bar 0)) + (set! v1-23 (-> a0-17 type)) + (set! t9-4 (method-of-type v1-23 add-frame)) + (set! a1-4 'draw) + (set! a2-2 (the-as uint #x808255be)) + (call! a0-17 a1-4 a2-2) + (set! a0-18 v0-4) + ) + (when (begin (set! v1-24 *dma-mem-usage*) (nonzero? v1-24)) + (set! a1-6 36) + (set! a2-3 (-> v1-24 length)) + (set! a1-7 (max.si a1-6 a2-3)) + (set! (-> v1-24 length) a1-7) + (set! a1-8 L171) + (set! (-> v1-24 data 35 name) a1-8) + (set! a1-9 (-> v1-24 data 35 count)) + (set! a1-10 (+ a1-9 1)) + (set! (-> v1-24 data 35 count) a1-10) + (set! a1-11 (-> v1-24 data 35 used)) + (set! a2-4 *display*) + (set! a3-1 *display*) + (set! a3-2 (-> a3-1 on-screen)) + (set! a3-3 (sll a3-2 5)) + (set! a2-5 (+ a2-4 a3-3)) + (set! a2-6 (dynamic-array-field-access a2-5 frames PLACEHOLDER frame)) + (set! a2-7 (-> a2-6 global-buf)) + (set! a2-8 (-> a2-7 base)) + (set! a2-9 (- a2-8 s4-0)) + (set! a1-12 (+ a1-11 a2-9)) + (set! (-> v1-24 data 35 used) a1-12) + (set! a1-13 (-> v1-24 data 35 used)) + (set! (-> v1-24 data 35 total) a1-13) + ) + (set! v1-25 *vu1-enable-user*) + (set! v1-26 (logand v1-25 512)) + (nonzero? v1-26) + ) + (when (begin (set! v1-28 *merc-globals*) (set! v1-29 (-> v1-28 first)) (nonzero? v1-29)) + (when (begin + (set! v1-31 *display*) + (set! a0-19 *display*) + (set! a0-20 (-> a0-19 on-screen)) + (set! a0-21 (sll a0-20 5)) + (set! v1-32 (+ v1-31 a0-21)) + (set! v1-33 (dynamic-array-field-access v1-32 frames PLACEHOLDER frame)) + (set! v1-34 (-> v1-33 global-buf)) + (set! s4-1 (-> v1-34 base)) + (set! v1-35 *level*) + (set! a0-22 2608) + (set! a0-23 (*.si a0-22 a2-0)) + (set! v1-36 (+ v1-35 a0-23)) + (set! a0-24 (sll a3-0 5)) + (set! v1-37 (+ v1-36 a0-24)) + (set! a0-25 (the-as none (l.wu (+ v1-37 276)))) + (set! t9-5 (the-as none generic-merc-add-to-cue)) + (call!) + (set! v1-38 (the-as none v0-5)) + (set! a0-26 (the-as none *dma-mem-usage*)) + (nonzero? a0-26) + ) + (set! a1-15 (the-as none 87)) + (set! a2-10 (the-as none (l.w (+ a0-26 4)))) + (set! a1-16 (the-as none (max.si a1-15 a2-10))) + (s.w! (+ a0-26 4) a1-16) + (set! a1-17 (the-as none L170)) + (s.w! (+ a0-26 1388) a1-17) + (set! a1-18 (the-as none (l.w (+ a0-26 1392)))) + (set! a1-19 (the-as none (+ a1-18 1))) + (s.w! (+ a0-26 1392) a1-19) + (set! a1-20 (the-as none (l.w (+ a0-26 1396)))) + (set! a2-11 (the-as none *display*)) + (set! a3-4 (the-as none *display*)) + (set! a3-5 (the-as none (l.w (+ a3-4 556)))) + (set! a3-6 (the-as none (sll a3-5 5))) + (set! a2-12 (the-as none (+ a2-11 a3-6))) + (set! a2-13 (the-as none (l.wu (+ a2-12 580)))) + (set! a2-14 (the-as none (l.wu (+ a2-13 36)))) + (set! a2-15 (the-as none (l.wu (+ a2-14 4)))) + (set! a2-16 (the-as none (- a2-15 s4-1))) + (set! a1-21 (the-as none (+ a1-20 a2-16))) + (s.w! (+ a0-26 1396) a1-21) + (set! a1-22 (the-as none (l.w (+ a0-26 1396)))) + (s.w! (+ a0-26 1400) a1-22) + ) + ) + ) + (when (begin (set! v1-39 (the-as none #t)) v1-39) + (set! v1-41 (the-as none *shadow-queue*)) + (set! a0-27 (the-as none (l.wu (+ v1-41 4)))) + (set! a0-28 (the-as none (+ a0-27 1))) + (s.w! (+ v1-41 4) a0-28) + ) + (set! v0-6 (the-as none 0)) + (ret-none) + ) + +;; definition (debug) for function main-debug-hook +(defun-debug main-debug-hook () + (when (not (or (= *master-mode* 'menu) (= *master-mode* 'progress))) + (execute-connections *debug-engine* #f) + (draw-instance-info *stdcon*) + ) + (none) + ) + +;; definition for symbol *debug-hook*, type (function none) +(define *debug-hook* main-debug-hook) + +;; definition for symbol *add-sphere*, type symbol +(define *add-sphere* #f) + +;; definition for symbol *generic-effect-mode*, type int +(define *generic-effect-mode* 0) + +;; definition for function real-main-draw-hook +;; INFO: Return type mismatch int vs none. +;; WARN: Unsupported inline assembly instruction kind - [mtc0 Perf, r0] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [sync.p] +;; WARN: Unsupported inline assembly instruction kind - [mtpc pcr0, r0] +;; WARN: Unsupported inline assembly instruction kind - [mtpc pcr1, r0] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [sync.p] +;; WARN: Unsupported inline assembly instruction kind - [mtc0 Perf, a0] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [sync.p] +;; WARN: Unsupported inline assembly instruction kind - [mtc0 Perf, r0] +;; WARN: Unsupported inline assembly instruction kind - [sync.l] +;; WARN: Unsupported inline assembly instruction kind - [sync.p] +;; WARN: Unsupported inline assembly instruction kind - [mfpc a0, pcr0] +;; WARN: Unsupported inline assembly instruction kind - [mfpc a0, pcr1] +(defun real-main-draw-hook () + (local-vars (r0-0 none) (a0-74 int) (a0-76 int)) + (when *slow-frame-rate* + (dotimes (v1-2 #xc3500) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + ) + ) + "Function to be executed to set up for engine dma" + (set! *vu1-enable-user* *vu1-enable-user-menu*) + (set! *texture-enable-user* *texture-enable-user-menu*) + (when *debug-segment* + (when (or *stats-memory* *stats-memory-short*) + (dotimes (gp-0 (-> *level* length)) + (let ((s5-0 (-> *level* level gp-0))) + (if (= (-> s5-0 status) 'active) + (print-mem-usage (compute-memory-usage s5-0 #f) s5-0 *stdcon*) + ) + ) + ) + ) + (reset! *dma-mem-usage*) + ) + (shrub-make-perspective-matrix (-> *math-camera* shrub-mat)) + (generic-init-buffers) + (when (logtest? *texture-enable-user* 1) + (dotimes (gp-1 (-> *level* length)) + (let ((a1-2 (-> *level* level gp-1))) + (if (= (-> a1-2 status) 'active) + (add-tex-to-dma! *texture-pool* a1-2 0) + ) + ) + ) + ) + (when (logtest? *texture-enable-user* 2) + (dotimes (gp-2 (-> *level* length)) + (let ((a1-3 (-> *level* level gp-2))) + (if (= (-> a1-3 status) 'active) + (add-tex-to-dma! *texture-pool* a1-3 1) + ) + ) + ) + ) + (when (logtest? *texture-enable-user* 4) + (dotimes (gp-3 (-> *level* length)) + (let ((a1-4 (-> *level* level gp-3))) + (if (= (-> a1-4 status) 'active) + (add-tex-to-dma! *texture-pool* a1-4 2) + ) + ) + ) + ) + (when (logtest? *texture-enable-user* 8) + (let ((s5-1 #f)) + (dotimes (gp-4 (-> *level* length)) + (let ((a1-5 (-> *level* level gp-4))) + (when (= (-> a1-5 status) 'active) + (add-tex-to-dma! *texture-pool* a1-5 3) + (when (not s5-1) + (upload-one-common! *texture-pool* (-> *level* level0)) + (set! s5-1 #t) + ) + ) + ) + ) + (when (not s5-1) + (upload-one-common! *texture-pool* (-> *level* level0)) + #t + ) + ) + ) + (when (logtest? *texture-enable-user* 16) + (dotimes (gp-5 (-> *level* length)) + (let ((a1-8 (-> *level* level gp-5))) + (if (= (-> a1-8 status) 'active) + (add-tex-to-dma! *texture-pool* a1-8 4) + ) + ) + ) + ) + (when (zero? (logand *vu1-enable-user* (vu1-renderer-mask sky))) + (let* ((s5-2 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-6 (-> s5-2 base)) + ) + (let* ((v1-114 s5-2) + (a0-27 (the-as object (-> v1-114 base))) + ) + (set! (-> (the-as dma-packet a0-27) dma) (new 'static 'dma-tag :qwc #x4 :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet a0-27) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet a0-27) vif1) (new 'static 'vif-tag :imm #x4 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> v1-114 base) (&+ (the-as pointer a0-27) 16)) + ) + (let* ((v1-115 s5-2) + (a0-29 (the-as object (-> v1-115 base))) + ) + (set! (-> (the-as gs-gif-tag a0-29) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x3)) + (set! (-> (the-as gs-gif-tag a0-29) regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id a+d) + :regs1 (gif-reg-id a+d) + :regs2 (gif-reg-id a+d) + :regs3 (gif-reg-id a+d) + :regs4 (gif-reg-id a+d) + :regs5 (gif-reg-id a+d) + :regs6 (gif-reg-id a+d) + :regs7 (gif-reg-id a+d) + :regs8 (gif-reg-id a+d) + :regs9 (gif-reg-id a+d) + :regs10 (gif-reg-id a+d) + :regs11 (gif-reg-id a+d) + :regs12 (gif-reg-id a+d) + :regs13 (gif-reg-id a+d) + :regs14 (gif-reg-id a+d) + :regs15 (gif-reg-id a+d) + ) + ) + (set! (-> v1-115 base) (&+ (the-as pointer a0-29) 16)) + ) + (let* ((v1-116 s5-2) + (a0-31 (-> v1-116 base)) + ) + (set! (-> (the-as (pointer gs-zbuf) a0-31) 0) (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24))) + (set! (-> (the-as (pointer gs-reg64) a0-31) 1) (gs-reg64 zbuf-1)) + (set! (-> (the-as (pointer gs-test) a0-31) 2) + (new 'static 'gs-test :ate #x1 :atst (gs-atest always) :zte #x1 :ztst (gs-ztest always)) + ) + (set! (-> (the-as (pointer gs-reg64) a0-31) 3) (gs-reg64 test-1)) + (set! (-> (the-as (pointer gs-alpha) a0-31) 4) (new 'static 'gs-alpha :b #x1 :d #x1)) + (set! (-> (the-as (pointer gs-reg64) a0-31) 5) (gs-reg64 alpha-1)) + (set! (-> v1-116 base) (&+ a0-31 48)) + ) + (screen-gradient + s5-2 + (-> *display* bg-clear-color 0) + (-> *display* bg-clear-color 1) + (-> *display* bg-clear-color 2) + (-> *display* bg-clear-color 3) + ) + (let ((a3-1 (-> s5-2 base))) + (let ((v1-121 (the-as object (-> s5-2 base)))) + (set! (-> (the-as dma-packet v1-121) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet v1-121) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet v1-121) vif1) (new 'static 'vif-tag)) + (set! (-> s5-2 base) (&+ (the-as pointer v1-121) 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id sky-draw) + gp-6 + (the-as (pointer dma-tag) a3-1) + ) + ) + ) + ) + (when (logtest? *vu1-enable-user* (vu1-renderer-mask sky)) + (cond + ((and (-> *time-of-day-context* sky) *sky-drawn*) + (render-sky-tng *time-of-day-context*) + ) + (else + (let* ((s5-3 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-7 (-> s5-3 base)) + ) + (let* ((v1-137 s5-3) + (a0-43 (-> v1-137 base)) + ) + (set! (-> (the-as (pointer int64) a0-43)) #x10000004) + (s.w! (+ a0-43 8) 0) + (let ((a1-23 #x50000004)) + (s.w! (+ a0-43 12) a1-23) + ) + (set! (-> v1-137 base) (&+ a0-43 16)) + ) + (let* ((v1-138 s5-3) + (a0-45 (-> v1-138 base)) + ) + (set! (-> (the-as (pointer uint64) a0-45)) (make-u128 0 (the-as uint #x3000000000008001))) + (let ((a1-26 (the-as uint #xeeeeeeeeeeeeeeee))) + (s.d! (+ a0-45 8) a1-26) + ) + (set! (-> v1-138 base) (&+ a0-45 16)) + ) + (let* ((v1-139 s5-3) + (a0-47 (-> v1-139 base)) + ) + (set! (-> (the-as (pointer int64) a0-47)) #x10001c0) + (let ((a1-28 78)) + (s.d! (+ a0-47 8) a1-28) + ) + (let ((a1-29 #x30003)) + (s.d! (+ a0-47 16) a1-29) + ) + (let ((a1-30 71)) + (s.d! (+ a0-47 24) a1-30) + ) + (let ((a1-31 68)) + (s.d! (+ a0-47 32) a1-31) + ) + (let ((a1-32 66)) + (s.d! (+ a0-47 40) a1-32) + ) + (set! (-> v1-139 base) (&+ a0-47 48)) + ) + (screen-gradient + s5-3 + (-> *time-of-day-context* erase-color) + (-> *time-of-day-context* erase-color) + (-> *time-of-day-context* erase-color) + (-> *time-of-day-context* erase-color) + ) + (let ((a3-3 (-> s5-3 base))) + (let ((v1-144 (-> s5-3 base))) + (set! (-> (the-as (pointer int64) v1-144)) #x20000000) + (s.w! (+ v1-144 8) 0) + (s.w! (+ v1-144 12) 0) + (set! (-> s5-3 base) (&+ v1-144 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id sky-draw) + gp-7 + (the-as (pointer dma-tag) a3-3) + ) + ) + ) + ) + ) + ) + (update-time-of-day *time-of-day-context*) + (dotimes (v1-150 (-> *level* length)) + (let ((a0-59 (-> *level* level v1-150))) + (when (= (-> a0-59 status) 'active) + (dotimes (a1-38 9) + (set! (-> a0-59 closest-object a1-38) 4095996000.0) + (set! (-> a0-59 texture-mask a1-38) (the-as uint 0)) + ) + ) + ) + ) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x40 :b #x40 :a #x80) + ) + ) + (update-ocean) + (draw-ocean) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :b #xff :a #x80) + ) + ) + (set! (-> *merc-global-array* count) (the-as uint 0)) + (set! *merc-globals* (the-as merc-globals (-> *merc-global-array* globals))) + (set! (-> *shadow-queue* cur-run) (the-as uint 0)) + 0 + (init-background) + (execute-connections *background-draw-engine* (-> *display* frames (-> *display* on-screen) frame)) + (let* ((v1-178 (-> *perf-stats* data 3)) + (a0-72 (-> v1-178 ctrl)) + ) + (+! (-> v1-178 count) 1) + (b! (zero? a0-72) cfg-77 :delay (nop!)) + (.mtc0 Perf r0-0) + (.sync.l) + (.sync.p) + (.mtpc pcr0 r0-0) + (.mtpc pcr1 r0-0) + (.sync.l) + (.sync.p) + (.mtc0 Perf a0-72) + ) + (.sync.l) + (.sync.p) + (label cfg-77) + 0 + (finish-background) + (let ((v1-181 (-> *perf-stats* data 3))) + (b! (zero? (-> v1-181 ctrl)) cfg-79 :delay (nop!)) + (.mtc0 Perf r0-0) + (.sync.l) + (.sync.p) + (.mfpc a0-74 pcr0) + (+! (-> v1-181 accum0) a0-74) + (.mfpc a0-76 pcr1) + (+! (-> v1-181 accum1) a0-76) + ) + (label cfg-79) + 0 + (update-wait-stats + (-> *perf-stats* data 3) + (-> *background-work* wait-to-vu0) + (the-as uint 0) + (the-as uint 0) + ) + (end-perf-stat-collection) + (when (not (paused?)) + (when *stats-poly* + (dotimes (gp-8 (-> *level* length)) + (let ((v1-193 (-> *level* level gp-8))) + (if (= (-> v1-193 status) 'active) + (collect-stats (-> v1-193 bsp)) + ) + ) + ) + (print-terrain-stats) + ) + (if *display-perf-stats* + (print-perf-stats) + ) + ) + (start-perf-stat-collection) + (foreground-engine-execute + (-> *level* level-default foreground-draw-engine 0) + (-> *display* frames (-> *display* on-screen) frame) + 2 + 0 + ) + (foreground-engine-execute + (-> *level* level-default foreground-draw-engine 1) + (-> *display* frames (-> *display* on-screen) frame) + 2 + 1 + ) + (let ((gp-9 (-> *display* frames (-> *display* on-screen) frame global-buf))) + (bones-mtx-calc-execute) + (generic-merc-execute-all) + (shadow-execute-all gp-9 *shadow-queue*) + ) + (-> *display* frames (-> *display* on-screen) frame global-buf) + (update-eyes) + (when (logtest? (vu1-renderer-mask sprite) *vu1-enable-user*) + (swap-fake-shadow-buffers) + (sprite-draw *display*) + ) + (when *debug-segment* + (debug-draw-actors *level* *display-actor-marks*) + (collide-shape-draw-debug-marks) + ) + (render-boundaries) + (send-events-for-touching-shapes *touching-list*) + (free-all-prim-nodes *touching-list*) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x40 :b #x40 :a #x80) + ) + ) + (actors-update *level*) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x80 :a #x80) + ) + ) + (when (not (paused?)) + (if *stats-collide* + (print-collide-stats) + ) + ) + 0 + (none) + ) + +;; definition for function main-draw-hook +(defun main-draw-hook () + (real-main-draw-hook) + (none) + ) + +;; definition for symbol *draw-hook*, type (function none) +(define *draw-hook* main-draw-hook) + +;; definition for function debug-init-buffer +;; INFO: Return type mismatch symbol vs none. +(defun debug-init-buffer ((arg0 bucket-id) (arg1 gs-zbuf) (arg2 gs-test)) + (let* ((t0-0 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (v1-3 (-> t0-0 base)) + ) + (let* ((a3-3 t0-0) + (t1-0 (the-as object (-> a3-3 base))) + ) + (set! (-> (the-as dma-packet t1-0) dma) (new 'static 'dma-tag :qwc #x3 :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet t1-0) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet t1-0) vif1) (new 'static 'vif-tag :imm #x3 :cmd (vif-cmd direct) :msk #x1)) + (set! (-> a3-3 base) (&+ (the-as pointer t1-0) 16)) + ) + (let* ((a3-4 t0-0) + (t1-2 (the-as object (-> a3-4 base))) + ) + (set! (-> (the-as gs-gif-tag t1-2) tag) (new 'static 'gif-tag64 :nloop #x1 :eop #x1 :nreg #x2)) + (set! (-> (the-as gs-gif-tag t1-2) regs) + (new 'static 'gif-tag-regs + :regs0 (gif-reg-id a+d) + :regs1 (gif-reg-id a+d) + :regs2 (gif-reg-id a+d) + :regs3 (gif-reg-id a+d) + :regs4 (gif-reg-id a+d) + :regs5 (gif-reg-id a+d) + :regs6 (gif-reg-id a+d) + :regs7 (gif-reg-id a+d) + :regs8 (gif-reg-id a+d) + :regs9 (gif-reg-id a+d) + :regs10 (gif-reg-id a+d) + :regs11 (gif-reg-id a+d) + :regs12 (gif-reg-id a+d) + :regs13 (gif-reg-id a+d) + :regs14 (gif-reg-id a+d) + :regs15 (gif-reg-id a+d) + ) + ) + (set! (-> a3-4 base) (&+ (the-as pointer t1-2) 16)) + ) + (let* ((a3-5 t0-0) + (t1-4 (-> a3-5 base)) + ) + (set! (-> (the-as (pointer gs-zbuf) t1-4) 0) arg1) + (set! (-> (the-as (pointer gs-reg64) t1-4) 1) (gs-reg64 zbuf-1)) + (set! (-> (the-as (pointer gs-test) t1-4) 2) arg2) + (set! (-> (the-as (pointer gs-reg64) t1-4) 3) (gs-reg64 test-1)) + (set! (-> a3-5 base) (&+ t1-4 32)) + ) + (let ((a3-6 (-> t0-0 base))) + (let ((a1-4 (the-as object (-> t0-0 base)))) + (set! (-> (the-as dma-packet a1-4) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet a1-4) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet a1-4) vif1) (new 'static 'vif-tag)) + (set! (-> t0-0 base) (&+ (the-as pointer a1-4) 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + arg0 + v1-3 + (the-as (pointer dma-tag) a3-6) + ) + ) + ) + (none) + ) + +;; definition for symbol *screen-shot*, type symbol +(define *screen-shot* #f) + +;; definition for function display-frame-start +;; INFO: Return type mismatch display vs none. +(defun display-frame-start ((disp display) (new-frame-idx int) (odd-even int)) + (set! (-> (the-as vif-bank #x10003c00) err me0) 1) + (let ((time-ratio + (the float (+ (/ (timer-count (the-as timer-bank #x10000800)) (the-as uint *ticks-per-frame*)) 1)) + ) + ) + (set-time-ratios *display* time-ratio) + (set! (-> disp old-base-frame-counter) (-> disp base-frame-counter)) + (set! (-> disp old-game-frame-counter) (-> disp game-frame-counter)) + (set! (-> disp old-real-frame-counter) (-> disp real-frame-counter)) + (set! (-> disp old-integral-frame-counter) (-> disp integral-frame-counter)) + (set! (-> disp old-real-integral-frame-counter) (-> disp real-integral-frame-counter)) + (set! (-> disp old-part-frame-counter) (-> disp part-frame-counter)) + (set! (-> disp old-actual-frame-counter) (-> disp actual-frame-counter)) + (set! (-> disp old-real-actual-frame-counter) (-> disp real-actual-frame-counter)) + (let ((scaled-seconds (* (the int time-ratio) (the int (-> disp time-factor))))) + (set-particle-frame-time (min 12 scaled-seconds)) + (when (not (paused?)) + (+! (-> disp base-frame-counter) scaled-seconds) + (+! (-> disp part-frame-counter) scaled-seconds) + (+! (-> disp integral-frame-counter) (the int time-ratio)) + (+! (-> disp actual-frame-counter) 1) + (if (not (movie?)) + (+! (-> disp game-frame-counter) scaled-seconds) + ) + ) + (+! (-> disp real-frame-counter) scaled-seconds) + ) + (+! (-> disp real-integral-frame-counter) (the int time-ratio)) + ) + (+! (-> disp real-actual-frame-counter) 1) + (timer-reset (the-as timer-bank #x10000800)) + (when *screen-shot* + (if *debug-segment* + (store-image odd-even) + ) + (set! *screen-shot* #f) + ) + (let ((new-frame (-> disp frames new-frame-idx frame))) + (when *debug-segment* + (dotimes (s2-0 2) + (reset (-> new-frame profile-bar s2-0)) + ) + ) + (if *sync-dma* + (sync-path 0 0) + ) + (let ((v1-56 (-> new-frame global-buf))) + (set! (-> v1-56 base) (-> v1-56 data)) + (set! (-> v1-56 end) (&-> v1-56 data-buffer (-> v1-56 allocated-length))) + ) + (when *debug-segment* + (let ((v1-59 (-> new-frame debug-buf))) + (set! (-> v1-59 base) (-> v1-59 data)) + (set! (-> v1-59 end) (&-> v1-59 data-buffer (-> v1-59 allocated-length))) + ) + ) + (let ((v1-60 (-> new-frame calc-buf))) + (set! (-> v1-60 base) (-> v1-60 data)) + (set! (-> v1-60 end) (&-> v1-60 data-buffer (-> v1-60 allocated-length))) + ) + (default-buffer-init *default-regs-buffer*) + (let* ((v1-61 (-> new-frame calc-buf)) + (a2-1 *default-regs-buffer*) + (a0-28 (the-as object (-> v1-61 base))) + ) + (set! (-> (the-as dma-packet a0-28) dma) + (new 'static 'dma-tag :id (dma-tag-id call) :addr (the-as int (-> a2-1 data))) + ) + (set! (-> (the-as dma-packet a0-28) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet a0-28) vif1) (new 'static 'vif-tag)) + (set! (-> v1-61 base) (&+ (the-as pointer a0-28) 16)) + ) + (*pre-draw-hook* (-> new-frame calc-buf)) + (when (not (paused?)) + (clear *stdcon1*) + (debug-reset-buffers) + ) + (set! (-> new-frame bucket-group) (dma-buffer-add-buckets (-> new-frame calc-buf) 69)) + ) + (debug-init-buffer + (bucket-id debug-draw1) + (new 'static 'gs-zbuf :zbp #x1c0 :psm (gs-psm ct24) :zmsk #x1) + (new 'static 'gs-test :zte #x1 :ztst (gs-ztest always)) + ) + (set-draw-env-offset (-> disp frames new-frame-idx draw) 2048 2048 odd-even) + (service-cpads) + (none) + ) + +;; definition for function display-frame-finish +(defun display-frame-finish ((disp display)) + (let* ((this-frame (-> disp frames (-> disp on-screen) frame)) + (this-calc-buf (-> this-frame calc-buf)) + ) + (tie-init-buffers this-calc-buf) + (merc-vu1-init-buffers) + (*post-draw-hook* (-> disp frames (-> disp on-screen) frame calc-buf)) + (dotimes (bucket-idx 69) + (let* ((this-global-buf (-> this-frame global-buf)) + (a2-0 (-> this-global-buf base)) + ) + (let* ((a0-3 this-global-buf) + (t0-0 *default-regs-buffer*) + (a1-0 (the-as object (-> a0-3 base))) + ) + (set! (-> (the-as dma-packet a1-0) dma) + (new 'static 'dma-tag :id (dma-tag-id call) :addr (the-as int (-> t0-0 data))) + ) + (set! (-> (the-as dma-packet a1-0) vif0) (new 'static 'vif-tag :irq #x1)) + (set! (-> (the-as dma-packet a1-0) vif1) (new 'static 'vif-tag)) + (set! (-> a0-3 base) (&+ (the-as pointer a1-0) 16)) + ) + (let ((a3-4 (-> this-global-buf base))) + (let ((a0-4 (the-as object (-> this-global-buf base)))) + (set! (-> (the-as dma-packet a0-4) dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> (the-as dma-packet a0-4) vif0) (new 'static 'vif-tag)) + (set! (-> (the-as dma-packet a0-4) vif1) (new 'static 'vif-tag)) + (set! (-> this-global-buf base) (&+ (the-as pointer a0-4) 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (the-as bucket-id bucket-idx) + a2-0 + (the-as (pointer dma-tag) a3-4) + ) + ) + ) + ) + (let* ((v1-14 this-calc-buf) + (a0-10 (the-as object (-> v1-14 base))) + ) + (set! (-> (the-as dma-packet a0-10) dma) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> (the-as dma-packet a0-10) vif0) (new 'static 'vif-tag :cmd (vif-cmd flushe) :msk #x1)) + (set! (-> (the-as dma-packet a0-10) vif1) (new 'static 'vif-tag :irq #x1)) + (set! (-> v1-14 base) (&+ (the-as pointer a0-10) 16)) + ) + (dma-buffer-patch-buckets (-> this-frame bucket-group) 69) + (let* ((v1-15 this-calc-buf) + (a0-13 (the-as object (-> v1-15 base))) + ) + (set! (-> (the-as dma-packet a0-13) dma) (new 'static 'dma-tag :id (dma-tag-id end))) + (set! (-> (the-as (pointer uint64) a0-13) 1) (the-as uint 0)) + (set! (-> v1-15 base) (&+ (the-as pointer a0-13) 16)) + ) + (flush-cache 0) + (when (not (paused?)) + (when *stats-buffer* + (let* ((global-buf (-> this-frame global-buf)) + (calc-current (-> this-calc-buf base)) + (calc-start (-> this-calc-buf data)) + (global-current (-> global-buf base)) + (global-start (-> global-buf data)) + (global-end (-> global-buf end)) + ) + (format *stdcon* "~0kvu1 buf = ~d~%" (&- calc-current (the-as uint calc-start))) + (format *stdcon* "~0kglobal buf = ~d~%" (&- global-current (the-as uint global-start))) + (format *stdcon* "~0kbase = #x~x~%" global-current) + (format *stdcon* "~0kend = #x~x~%" global-end) + ) + ) + ) + ) + disp + ) + +;; definition for function determine-pause-mode +(defun determine-pause-mode () + (when (and *debug-pause* (= *master-mode* 'pause)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons start r2)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons start r2)) + (while (and (= *master-mode* 'pause) (zero? (logand (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons start r2)))) + (sync-path 0 0) + (service-cpads) + ) + (toggle-pause) + ) + (when (or (not *progress-process*) (dummy-32 (-> *progress-process* 0))) + (if (or (cpad-pressed? 0 select r3 start) + (and (logtest? (-> *cpad-list* cpads 0 valid) 128) + (= *master-mode* 'game) + (>= (-> *display* base-frame-counter) (-> *game-info* blackout-time)) + (< #x49764 (-> *display* real-frame-counter)) + ) + (and (cpad-pressed? 0 r2) (paused?)) + *pause-lock* + ) + (toggle-pause) + ) + ) + (if (!= *master-mode* 'progress) + (deactivate-progress) + ) + 0 + ) + +;; definition for symbol *surrogate-dma-buffer*, type dma-buffer +(define *surrogate-dma-buffer* (the-as dma-buffer #f)) + +;; definition for function display-sync +(defun display-sync ((disp display)) + (sync-path 0 0) + (set! (-> disp frames (-> disp on-screen) frame run-time) (timer-count (the-as timer-bank #x10000800))) + (let ((frame-idx (-> disp on-screen)) + (syncv-result (syncv 0)) + ) + (set! *oddeven* syncv-result) + (when (-> *video-parms* set-video-mode) + (set-display2 *display* 0 512 (-> *video-parms* screen-sy) 2 49) + (set! (-> *video-parms* set-video-mode) #f) + (when (-> *video-parms* reset-video-mode) + (set! (-> *video-parms* reset-video-mode) #f) + (if (= (-> *setting-control* current video-mode) 'ntsc) + (set! *video-reset-parm* 2) + (set! *video-reset-parm* 3) + ) + (reset-graph 0 1 *video-reset-parm* 1) + ) + ) + (put-display-env (-> disp frames frame-idx display)) + (put-draw-env (the-as (pointer gif-tag) (-> disp frames frame-idx gif))) + (let ((dma-buf-to-send (-> disp frames frame-idx frame calc-buf))) + (if (nonzero? (dma-buffer-length dma-buf-to-send)) + (dma-buffer-send-chain (the-as dma-bank-source #x10009000) (cond + (*surrogate-dma-buffer* + *surrogate-dma-buffer* + ) + (else + (empty) + dma-buf-to-send + ) + ) + ) + ) + ) + (determine-pause-mode) + (let ((next-frame (+ frame-idx 1))) + (if (< 1 next-frame) + (set! next-frame 0) + ) + (set! (-> disp last-screen) (-> disp on-screen)) + (set! (-> disp on-screen) next-frame) + (display-frame-start disp next-frame syncv-result) + ) + ) + (none) + ) + +;; definition for function swap-display +(defun swap-display ((arg0 display)) + (display-frame-finish arg0) + (display-sync arg0) + (none) + ) + +;; definition (debug) for function marks-cam-restore +;; Used lq/sq +(defun-debug marks-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 1672489.2) + (set! (-> a0-0 y) 60862.703) + (set! (-> a0-0 z) -13051605.0) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.1783) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.9839) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) -0.0629) + (set! (-> a1-0 vector 1 y) 0.9979) + (set! (-> a1-0 vector 1 z) -0.0114) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) -0.9819) + (set! (-> a1-0 vector 2 y) -0.064) + (set! (-> a1-0 vector 2 z) -0.178) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (send-event *camera* 'set-fov 17294.205) + (clear *camera-old-level*) + (format *camera-old-level* "village3") + (set! *camera-old-cpu* 1219) + (set! *camera-old-vu* 9602) + (set! *camera-old-tfrag-bytes* 0) + (clear *camera-old-stat-string-tfrag*) + (clear *camera-old-stat-string-tfrag-near*) + (clear *camera-old-stat-string-total*) + (let ((v0-7 #t)) + (set! *display-camera-old-stats* v0-7) + v0-7 + ) + ) + +;; definition (debug) for function eddie-cam-restore +;; Used lq/sq +(defun-debug eddie-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) -427963.66) + (set! (-> a0-0 y) 24967.182) + (set! (-> a0-0 z) 339465.53) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.6026) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.7979) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) -0.1522) + (set! (-> a1-0 vector 1 y) 0.9816) + (set! (-> a1-0 vector 1 z) -0.1149) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) -0.7833) + (set! (-> a1-0 vector 2 y) -0.1908) + (set! (-> a1-0 vector 2 z) -0.5915) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + ) + +;; definition (debug) for function gregs-jungle-cam-restore +;; Used lq/sq +(defun-debug gregs-jungle-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 1399233.0) + (set! (-> a0-0 y) 39027.11) + (set! (-> a0-0 z) -1485580.1) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) 0.9965) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.0829) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) -0.0021) + (set! (-> a1-0 vector 1 y) 0.9996) + (set! (-> a1-0 vector 1 z) 0.0253) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) -0.0829) + (set! (-> a1-0 vector 2 y) -0.0254) + (set! (-> a1-0 vector 2 z) 0.9962) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (send-event *camera* 'set-fov 11650.845) + (clear *camera-old-level*) + (format *camera-old-level* "jungle") + (set! *camera-old-cpu* 5801) + (set! *camera-old-vu* 9605) + (set! *camera-old-tfrag-bytes* #x1ffee0) + (clear *camera-old-stat-string-tfrag*) + (clear *camera-old-stat-string-tfrag-near*) + (clear *camera-old-stat-string-total*) + ) + +;; definition (debug) for function gregs-village1-cam-restore +;; Used lq/sq +(defun-debug gregs-village1-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) -511224.06) + (set! (-> a0-0 y) 157579.95) + (set! (-> a0-0 z) 764585.25) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.9009) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) -0.4338) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) 0.0984) + (set! (-> a1-0 vector 1 y) 0.9739) + (set! (-> a1-0 vector 1 z) -0.2043) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) 0.4225) + (set! (-> a1-0 vector 2 y) -0.2268) + (set! (-> a1-0 vector 2 z) -0.8774) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (send-event *camera* 'set-fov 11650.845) + (clear *camera-old-level*) + (format *camera-old-level* "village1") + (set! *camera-old-cpu* 4899) + (set! *camera-old-vu* 9605) + (set! *camera-old-tfrag-bytes* #x24e680) + (clear *camera-old-stat-string-tfrag*) + (clear *camera-old-stat-string-tfrag-near*) + (clear *camera-old-stat-string-total*) + ) + +;; definition (debug) for function gregs-texture-cam-restore +;; Used lq/sq +(defun-debug gregs-texture-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 1103816.0) + (set! (-> a0-0 y) 96275.71) + (set! (-> a0-0 z) -632064.5) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) 0.4063) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) -0.9137) + (set! (-> a1-0 vector 0 w) 1.0) + (set! (-> a1-0 vector 1 x) 0.2824) + (set! (-> a1-0 vector 1 y) 0.951) + (set! (-> a1-0 vector 1 z) 0.1256) + (set! (-> a1-0 vector 1 w) 1.0) + (set! (-> a1-0 vector 2 x) 0.8689) + (set! (-> a1-0 vector 2 y) -0.3091) + (set! (-> a1-0 vector 2 z) 0.3864) + (set! (-> a1-0 vector 2 w) 1.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (send-event *camera* 'set-fov 11650.845) + (clear *camera-old-level*) + (format *camera-old-level* "village1") + (set! *camera-old-cpu* 4772) + (set! *camera-old-vu* 9603) + (set! *camera-old-tfrag-bytes* #x22e680) + (clear *camera-old-stat-string-tfrag*) + (clear *camera-old-stat-string-tfrag-near*) + (clear *camera-old-stat-string-total*) + ) + +;; definition (debug) for function gregs-texture2-cam-restore +;; Used lq/sq +(defun-debug gregs-texture2-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) 1954572.9) + (set! (-> a0-0 y) 135123.98) + (set! (-> a0-0 z) -1028725.44) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) 0.2535) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) 0.9673) + (set! (-> a1-0 vector 0 w) 1.0) + (set! (-> a1-0 vector 1 x) -0.1051) + (set! (-> a1-0 vector 1 y) 0.994) + (set! (-> a1-0 vector 1 z) 0.0275) + (set! (-> a1-0 vector 1 w) 1.0) + (set! (-> a1-0 vector 2 x) -0.9615) + (set! (-> a1-0 vector 2 y) -0.1087) + (set! (-> a1-0 vector 2 z) 0.252) + (set! (-> a1-0 vector 2 w) 1.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + (send-event *camera* 'set-fov 11650.845) + (clear *camera-old-level*) + (format *camera-old-level* "village1") + (set! *camera-old-cpu* 4936) + (set! *camera-old-vu* #x4b0c) + (set! *camera-old-tfrag-bytes* #x22e680) + (clear *camera-old-stat-string-tfrag*) + (clear *camera-old-stat-string-tfrag-near*) + (clear *camera-old-stat-string-total*) + ) + +;; definition (debug) for function cave-cam-restore +;; Used lq/sq +(defun-debug cave-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) -1449013.1) + (set! (-> a0-0 y) 15114.015) + (set! (-> a0-0 z) -1621305.5) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.8223) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) -0.5689) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) 0.0076) + (set! (-> a1-0 vector 1 y) 0.9999) + (set! (-> a1-0 vector 1 z) -0.0111) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) 0.5689) + (set! (-> a1-0 vector 2 y) -0.0135) + (set! (-> a1-0 vector 2 z) -0.8222) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + ) + +;; definition (debug) for function paals-cam-restore +;; Used lq/sq +(defun-debug paals-cam-restore () + (let ((a0-0 (new-stack-vector0)) + (a1-0 (new-stack-matrix0)) + ) + (set! (-> a0-0 x) -791260.7) + (set! (-> a0-0 y) 50858.62) + (set! (-> a0-0 z) -163715.47) + (set! (-> a0-0 w) 1.0) + (set! (-> a1-0 vector 0 x) -0.7816) + (set! (-> a1-0 vector 0 y) 0.0) + (set! (-> a1-0 vector 0 z) -0.6236) + (set! (-> a1-0 vector 0 w) 0.0) + (set! (-> a1-0 vector 1 x) 0.0672) + (set! (-> a1-0 vector 1 y) 0.9941) + (set! (-> a1-0 vector 1 z) -0.0843) + (set! (-> a1-0 vector 1 w) 0.0) + (set! (-> a1-0 vector 2 x) 0.62) + (set! (-> a1-0 vector 2 y) -0.1079) + (set! (-> a1-0 vector 2 z) -0.7771) + (set! (-> a1-0 vector 2 w) 0.0) + (set! (-> a1-0 vector 3 x) 0.0) + (set! (-> a1-0 vector 3 y) 0.0) + (set! (-> a1-0 vector 3 z) 0.0) + (set! (-> a1-0 vector 3 w) 1.0) + (debug-set-camera-pos-rot! a0-0 a1-0) + ) + ) + + + + diff --git a/test/decompiler/reference/engine/entity/entity_REF.gc b/test/decompiler/reference/engine/entity/entity_REF.gc new file mode 100644 index 0000000000..e8fffdd884 --- /dev/null +++ b/test/decompiler/reference/engine/entity/entity_REF.gc @@ -0,0 +1,1912 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *spawn-actors*, type symbol +(define *spawn-actors* #t) + +;; definition for symbol *compact-actors*, type symbol +(define *compact-actors* #t) + +;; definition for symbol *vis-actors*, type symbol +(define *vis-actors* #t) + +;; definition for method 8 of type drawable-actor +;; INFO: Return type mismatch int vs drawable-actor. +(defmethod mem-usage drawable-actor ((obj drawable-actor) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 44 (-> arg0 length))) + (set! (-> arg0 data 43 name) "entity") + (+! (-> arg0 data 43 count) 1) + (let ((v1-6 (asize-of obj))) + (+! (-> arg0 data 43 used) v1-6) + (+! (-> arg0 data 43 total) (logand -16 (+ v1-6 15))) + ) + (mem-usage (-> obj actor) arg0 (logior arg1 64)) + (the-as drawable-actor 0) + ) + +;; definition for method 8 of type drawable-inline-array-actor +;; INFO: Return type mismatch int vs drawable-inline-array-actor. +(defmethod mem-usage drawable-inline-array-actor ((obj drawable-inline-array-actor) (arg0 memory-usage-block) (arg1 int)) + (set! (-> arg0 length) (max 1 (-> arg0 length))) + (set! (-> arg0 data 0 name) (symbol->string 'drawable-group)) + (+! (-> arg0 data 0 count) 1) + (let ((v1-7 32)) + (+! (-> arg0 data 0 used) v1-7) + (+! (-> arg0 data 0 total) (logand -16 (+ v1-7 15))) + ) + (dotimes (s3-0 (-> obj length)) + (mem-usage (-> obj data s3-0) arg0 arg1) + ) + (the-as drawable-inline-array-actor 0) + ) + +;; definition for method 2 of type entity-links +(defmethod print entity-links ((obj entity-links)) + (format #t "#" (-> obj process) obj) + obj + ) + +;; definition for method 2 of type entity-perm +(defmethod print entity-perm ((obj entity-perm)) + (format + #t + "#" + (-> obj aid) + (-> obj task) + (-> obj status) + (-> obj user-uint64) + obj + ) + obj + ) + +;; definition for method 22 of type entity +(defmethod birth! entity ((obj entity)) + (format #t "birth ~A~%" obj) + obj + ) + +;; definition for method 23 of type entity +(defmethod kill! entity ((obj entity)) + (format #t "kill ~A~%" obj) + obj + ) + +;; definition for method 2 of type entity +(defmethod print entity ((obj entity)) + (format #t "#<~A :name ~S @ #x~X>" (-> obj type) (res-lump-struct obj 'name structure) obj) + obj + ) + +;; definition for method 26 of type entity +(defmethod get-level entity ((obj entity)) + (dotimes (v1-0 (-> *level* length)) + (let ((a1-3 (-> *level* level v1-0))) + (when (= (-> a1-3 status) 'active) + (if (and (>= (the-as int obj) (the-as int (-> a1-3 heap base))) + (< (the-as int obj) (the-as int (-> a1-3 heap top-base))) + ) + (return a1-3) + ) + ) + ) + ) + (-> *level* level-default) + ) + +;; definition for function entity-by-name +(defun entity-by-name ((arg0 string)) + (dotimes (s5-0 (-> *level* length)) + (let ((s4-0 (-> *level* level s5-0))) + (when (= (-> s4-0 status) 'active) + (let ((s3-0 (-> s4-0 bsp actors))) + (when (nonzero? s3-0) + (dotimes (s2-0 (-> s3-0 length)) + (let ((s1-0 (-> s3-0 data s2-0 actor))) + (if (name= (res-lump-struct s1-0 'name basic) arg0) + (return s1-0) + ) + ) + ) + ) + ) + (let ((s3-1 (-> s4-0 bsp ambients))) + (when (nonzero? s3-1) + (dotimes (s2-1 (-> s3-1 length)) + (let ((s1-1 (-> s3-1 data s2-1 ambient))) + (if (name= (res-lump-struct s1-1 'name basic) arg0) + (return s1-1) + ) + ) + ) + ) + ) + (let ((s4-1 (-> s4-0 bsp cameras))) + (when (nonzero? s4-1) + (dotimes (s3-2 (-> s4-1 length)) + (let ((s2-2 (-> s4-1 s3-2))) + (if (name= (res-lump-struct s2-2 'name basic) arg0) + (return s2-2) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as entity #f) + ) + +;; definition for function entity-by-type +(defun entity-by-type ((arg0 type)) + (dotimes (s5-0 (-> *level* length)) + (let ((v1-3 (-> *level* level s5-0))) + (when (= (-> v1-3 status) 'active) + (let ((s4-0 (-> v1-3 bsp actors))) + (when (nonzero? s4-0) + (dotimes (s3-0 (-> s4-0 length)) + (let ((s2-0 (-> s4-0 data s3-0 actor))) + (if (and (type-type? (-> s2-0 type) entity-actor) (= (-> s2-0 etype) arg0)) + (return s2-0) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as entity-actor #f) + ) + +;; definition for function entity-by-aid +(defun entity-by-aid ((arg0 uint)) + (dotimes (v1-0 (-> *level* length)) + (let ((a1-3 (-> *level* level v1-0))) + (when (= (-> a1-3 status) 'active) + (let ((a1-4 (-> a1-3 entity))) + (when (nonzero? a1-4) + (let ((a2-4 0) + (a3-2 (+ (-> a1-4 length) -1)) + ) + 0 + (while (>= a3-2 a2-4) + (let* ((t0-3 (+ a2-4 (/ (- a3-2 a2-4) 2))) + (t1-2 (-> a1-4 data t0-3)) + (t2-0 (-> t1-2 perm aid)) + ) + (cond + ((= t2-0 arg0) + (return (-> t1-2 entity)) + ) + ((< (the-as uint t2-0) arg0) + (set! a2-4 (+ t0-3 1)) + ) + (else + (set! a3-2 (+ t0-3 -1)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as entity #f) + ) + +;; definition for function entity-by-meters +(defun entity-by-meters ((arg0 float) (arg1 float) (arg2 float)) + (dotimes (v1-0 (-> *level* length)) + (let ((a3-3 (-> *level* level v1-0))) + (when (= (-> a3-3 status) 'active) + (let ((a3-5 (-> a3-3 bsp actors))) + (when (nonzero? a3-5) + (dotimes (t0-4 (-> a3-5 length)) + (let* ((t1-3 (-> a3-5 data t0-4 actor)) + (t2-1 (-> t1-3 extra trans)) + ) + (if (and (= (the float (the int (-> t2-1 x))) arg0) + (= (the float (the int (-> t2-1 y))) arg1) + (= (the float (the int (-> t2-1 z))) arg2) + ) + (return t1-3) + ) + ) + ) + ) + ) + ) + ) + ) + (the-as entity-actor #f) + ) + +;; definition for function process-by-ename +(defun process-by-ename ((arg0 string)) + (let ((v1-0 (entity-by-name arg0))) + (if v1-0 + (-> v1-0 extra process) + ) + ) + ) + +;; definition for function entity-process-count +(defun entity-process-count ((arg0 symbol)) + (let ((gp-0 0)) + (dotimes (s4-0 (-> *level* length)) + (let ((s3-0 (-> *level* level s4-0))) + (when (= (-> s3-0 status) 'active) + (let ((s2-0 (-> s3-0 bsp level entity))) + (dotimes (s1-0 (-> s2-0 length)) + (let ((v1-9 (-> s2-0 data s1-0 entity))) + (case arg0 + (('vis) + (if (is-object-visible? s3-0 (-> v1-9 extra vis-id)) + (+! gp-0 1) + ) + ) + (else + (if (-> v1-9 extra process) + (+! gp-0 1) + ) + ) + ) + ) + ) + ) + ) + ) + ) + gp-0 + ) + ) + +;; definition for function entity-count +(defun entity-count () + (let ((v0-0 0)) + (dotimes (v1-0 (-> *level* length)) + (let ((a0-3 (-> *level* level v1-0))) + (when (= (-> a0-3 status) 'active) + (let ((a0-6 (-> a0-3 bsp level entity))) + (dotimes (a1-3 (-> a0-6 length)) + (-> a0-6 data a1-3 entity) + (+! v0-0 1) + ) + ) + ) + ) + ) + v0-0 + ) + ) + +;; definition for function entity-remap-names +;; INFO: Return type mismatch int vs none. +(defun entity-remap-names ((arg0 pair)) + (let ((s5-0 (car arg0))) + (while (not (null? arg0)) + (let ((a0-2 (entity-by-meters + (the float (/ (the-as int (car (cdr s5-0))) 8)) + (the float (/ (the-as int (car (cdr (cdr s5-0)))) 8)) + (the float (/ (the-as int (car (cdr (cdr (cdr s5-0))))) 8)) + ) + ) + ) + (if a0-2 + (add-data! + a0-2 + (new 'static 'res-tag :name 'name :key-frame -1000000000.0 :elt-count #x1 :elt-type string) + (the-as pointer (car s5-0)) + ) + ) + ) + (set! arg0 (cdr arg0)) + (set! s5-0 (car arg0)) + ) + ) + 0 + (none) + ) + +;; definition (debug) for function process-status-bits +;; INFO: Return type mismatch int vs none. +(defun-debug process-status-bits ((arg0 process) (arg1 symbol)) + (let* ((s5-0 arg0) + (proc-draw (the-as process-drawable (if (and (nonzero? s5-0) (type-type? (-> s5-0 type) process-drawable)) + (the-as process-drawable s5-0) + ) + ) + ) + ) + (if (and (the-as process proc-draw) (zero? (-> proc-draw draw))) + (set! proc-draw (the-as process-drawable #f)) + ) + (let ((s5-1 format) + (s4-0 "~C~C~C") + (a2-0 (if (and arg0 (zero? (logand (-> *kernel-context* prevent-from-run) (-> arg0 mask))) (run-logic? arg0)) + 114 + 32 + ) + ) + (a3-0 (if (and proc-draw (logtest? (-> proc-draw draw status) (draw-status drwf03))) + 100 + 32 + ) + ) + (t0-0 (cond + ((and proc-draw (logtest? (-> proc-draw draw status) (draw-status drwf03))) + (let ((v1-15 (-> proc-draw draw cur-lod))) + (cond + ((zero? v1-15) + 48 + ) + ((= v1-15 1) + 49 + ) + ((= v1-15 2) + 50 + ) + ((= v1-15 3) + 51 + ) + ((= v1-15 4) + 52 + ) + ) + ) + ) + (else + 32 + ) + ) + ) + ) + (s5-1 arg1 s4-0 a2-0 a3-0 t0-0) + ) + ) + 0 + (none) + ) + +;; definition for method 2 of type process +;; INFO: this function exists in multiple non-identical object files +(defmethod print process ((obj process)) + (format #t "#<~A ~S ~A :state ~S :flags " (-> obj type) (-> obj name) (-> obj status) (if (-> obj state) + (-> obj state name) + ) + ) + (process-status-bits obj #t) + (format + #t + " :stack ~D/~D :heap ~D/~D @ #x~X>" + (&- (-> obj top-thread stack-top) (the-as uint (-> obj top-thread sp))) + (-> obj main-thread stack-size) + (- (-> obj allocated-length) (&- (-> obj heap-top) (the-as uint (-> obj heap-cur)))) + (-> obj allocated-length) + obj + ) + obj + ) + +;; definition for method 3 of type entity +(defmethod inspect entity ((obj entity)) + ((the-as (function entity entity) (find-parent-method entity 3)) obj) + (format #t "~Ttrans: ~`vector`P~%" (-> obj trans)) + (format #t "~Taid: ~A~%" (-> obj aid)) + obj + ) + +;; definition for method 3 of type entity-actor +(defmethod inspect entity-actor ((obj entity-actor)) + ((the-as (function entity-actor entity-actor) (find-parent-method entity-actor 3)) obj) + (format #t "~Tnav-mesh: ~A~%" (-> obj nav-mesh)) + (format #t "~Tetype: ~A~%" (-> obj etype)) + (format #t "~Ttask: ~d~%" (-> obj task)) + (format #t "~Tvis-id: ~d~%" (-> obj vis-id-signed)) + (format #t "~Tquat: ~`vector`P~%" (-> obj quat)) + obj + ) + +;; definition for method 29 of type entity-actor +;; INFO: Return type mismatch entity-actor vs none. +(defmethod debug-print entity-actor ((obj entity-actor) (mode symbol) (expected-type type)) + (let ((s4-0 (-> obj etype))) + (when (or (not expected-type) (and s4-0 (valid? s4-0 type #f #f 0) (type-type? s4-0 expected-type))) + (format #t "~5D #x~8X ~-21S" (-> obj extra vis-id) obj (res-lump-struct obj 'name structure)) + (let ((t9-4 format) + (a0-5 #t) + (a1-5 "~8D ~3D ~-4S #x~4X") + (a2-4 (-> obj extra perm aid)) + (a3-3 (-> obj extra perm task)) + (t0-3 (-> obj extra level nickname)) + ) + (set! t0-3 (cond + (t0-3 + (empty) + t0-3 + ) + (else + (-> obj extra level name) + ) + ) + ) + (t9-4 a0-5 a1-5 a2-4 a3-3 t0-3 (-> obj extra perm status)) + ) + (if (= mode 'entity-meters) + (format #t " :trans ~14m ~14m ~14m " (-> obj extra trans x) (-> obj extra trans y) (-> obj extra trans z)) + (format #t " :trans ~14f ~14f ~14f " (-> obj extra trans x) (-> obj extra trans y) (-> obj extra trans z)) + ) + (let* ((s3-2 (-> obj extra process)) + (s4-2 (if (and (nonzero? s3-2) (type-type? (-> s3-2 type) process-drawable)) + s3-2 + ) + ) + ) + (format + #t + ":pr #x~8X ~-12S ~-21S ~-5S/~-5S " + (if (-> obj extra process) + (-> obj extra process) + 0 + ) + (if (-> obj extra process) + (-> obj extra process name) + "" + ) + (if (and (-> obj extra process) (-> obj extra process state)) + (-> obj extra process state name) + "" + ) + (if (-> obj extra process) + (* (- (-> obj extra process allocated-length) + (&- (-> obj extra process heap-top) (the-as uint (-> obj extra process heap-cur))) + ) + 8 + ) + "" + ) + (if (-> obj extra process) + (* (-> obj extra process allocated-length) 8) + "" + ) + ) + (process-status-bits s4-2 #t) + ) + (format #t "~%") + (if (= mode 'entity-perm) + (format #t " ~`entity-perm`P~%" (-> obj extra perm)) + ) + ) + ) + (none) + ) + +;; definition for method 13 of type level-group +;; INFO: Return type mismatch int vs none. +(defmethod debug-print-entities level-group ((obj level-group) (mode symbol) (expected-type type)) + (format + #t + " id address name aid tsk lev status x y z address name state heap flags~%" + 0 + 0 + 0 + ) + (dotimes (s3-0 (-> obj length)) + (let ((s2-0 (-> obj level s3-0))) + (when (= (-> s2-0 status) 'active) + (case mode + (('art-group) + (format #t "level ~A~%" (-> s2-0 name)) + (dotimes (s1-0 (-> s2-0 art-group art-group-array length)) + (format #t "~T~2D ~S~%" s1-0 (-> s2-0 art-group art-group-array s1-0 name)) + ) + ) + (else + (let ((s2-1 (-> s2-0 bsp level entity))) + (dotimes (s1-1 (-> s2-1 length)) + (debug-print (the-as entity-actor (-> s2-1 data s1-1 entity)) mode expected-type) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 24 of type entity +;; INFO: Return type mismatch entity vs none. +;; Used lq/sq +(defmethod add-to-level! entity ((obj entity) (lev-group level-group) (lev level) (aid actor-id)) + (let ((level-link (-> lev entity data (-> lev entity length)))) + (+! (-> lev entity length) 1) + (set! (-> level-link process) #f) + (set! (-> level-link entity) obj) + (set! (-> obj extra) level-link) + (cond + ((-> lev-group entity-link) + (let* ((other-prev (-> lev-group entity-link)) + (other-front (-> other-prev next-link)) + ) + (set! (-> other-prev next-link) level-link) + (set! (-> level-link prev-link) other-prev) + (set! (-> level-link next-link) other-front) + (set! (-> other-front prev-link) level-link) + ) + ) + (else + (set! (-> level-link prev-link) level-link) + (set! (-> level-link next-link) level-link) + ) + ) + (set! (-> lev-group entity-link) level-link) + (set! (-> level-link trans quad) (-> obj trans quad)) + ) + (set! (-> obj extra perm aid) aid) + (set! (-> obj extra level) lev) + (cond + ((= (-> obj type) entity-actor) + (set! (-> (the-as entity-actor obj) extra perm task) (-> (the-as entity-actor obj) task)) + (set! (-> (the-as entity-actor obj) extra vis-id) (-> (the-as entity-actor obj) vis-id-signed)) + ) + (else + (set! (-> obj extra perm task) (game-task none)) + (set! (-> obj extra vis-id) 0) + 0 + ) + ) + (none) + ) + +;; definition for method 25 of type entity +(defmethod remove-from-level! entity ((obj entity) (arg0 level-group)) + (let ((v1-0 (-> obj extra))) + (cond + ((= (-> v1-0 next-link) v1-0) + (set! (-> arg0 entity-link) #f) + ) + (else + (set! (-> v1-0 next-link prev-link) (-> v1-0 prev-link)) + (set! (-> v1-0 prev-link next-link) (-> v1-0 next-link)) + (if (= (-> arg0 entity-link) v1-0) + (set! (-> arg0 entity-link) (-> v1-0 prev-link)) + ) + ) + ) + ) + obj + ) + +;; definition for function update-actor-vis-box +;; INFO: Return type mismatch int vs none. +(defun update-actor-vis-box ((proc process-drawable) (min-pt vector) (max-pt vector)) + (when (and proc (nonzero? (-> proc draw))) + (let ((world-bounds-origin (vector+! (new 'stack-no-clear 'vector) (-> proc draw origin) (-> proc draw bounds))) + (radius (-> proc draw bounds w)) + ) + (set! (-> min-pt x) (fmin (-> min-pt x) (- (-> world-bounds-origin x) radius))) + (set! (-> min-pt y) (fmin (-> min-pt y) (- (-> world-bounds-origin y) radius))) + (set! (-> min-pt z) (fmin (-> min-pt z) (- (-> world-bounds-origin z) radius))) + (set! (-> max-pt x) (fmax (-> max-pt x) (+ (-> world-bounds-origin x) radius))) + (set! (-> max-pt y) (fmax (-> max-pt y) (+ (-> world-bounds-origin y) radius))) + (set! (-> max-pt z) (fmax (-> max-pt z) (+ (-> world-bounds-origin z) radius))) + ) + ) + 0 + (none) + ) + +;; definition for method 22 of type level-group +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defmethod update-vis-volumes level-group ((obj level-group)) + (local-vars + (v1-10 symbol) + (sv-16 process) + (sv-32 (function process-drawable vector vector none)) + (sv-48 process-tree) + ) + (dotimes (s5-0 (-> obj length)) + (let ((v1-3 (-> obj level s5-0))) + (when (= (-> v1-3 status) 'active) + (let ((s4-0 (-> v1-3 bsp level entity))) + (dotimes (s3-0 (-> s4-0 length)) + (let* ((s0-0 (-> s4-0 data s3-0 entity)) + (v0-0 (res-lump-data s0-0 'visvol (inline-array vector))) + (s2-0 (-> v0-0 0)) + (s1-0 (-> v0-0 1)) + ) + (let ((s0-1 (-> s0-0 extra process))) + (set! v1-10 (when (and (nonzero? s0-1) (type-type? (-> s0-1 type) process-drawable)) + (set! sv-16 (the-as process v1-10)) + (set! sv-16 s0-1) + v1-10 + ) + ) + ) + (when sv-16 + (update-actor-vis-box (the-as process-drawable sv-16) s2-0 s1-0) + (let ((s0-2 (-> sv-16 child))) + (while s0-2 + (set! sv-32 update-actor-vis-box) + (set! sv-48 (-> s0-2 0)) + (let ((a0-7 (if (and (nonzero? sv-48) (type-type? (-> sv-48 type) process-drawable)) + sv-48 + ) + ) + (a1-5 s2-0) + (a2-2 s1-0) + ) + (sv-32 (the-as process-drawable a0-7) a1-5 a2-2) + ) + (set! s0-2 (-> s0-2 0 brother)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 23 of type level-group +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defmethod update-vis-volumes-from-nav-mesh level-group ((obj level-group)) + (local-vars (sv-16 entity) (sv-32 entity)) + (dotimes (s5-0 (-> obj length)) + (let ((v1-3 (-> obj level s5-0))) + (when (= (-> v1-3 status) 'active) + (let ((s4-0 (-> v1-3 bsp level entity))) + (dotimes (s3-0 (-> s4-0 length)) + (set! sv-32 (-> s4-0 data s3-0 entity)) + (let* ((v0-0 (res-lump-data sv-32 'visvol (inline-array vector))) + (s1-0 (-> v0-0 0)) + (s2-0 (-> v0-0 1)) + ) + (let ((s0-0 (-> sv-32 extra trans))) + (set! sv-16 sv-32) + (let* ((t9-1 entity-actor-lookup) + (a1-2 'nav-mesh-actor) + (a2-1 0) + (v0-1 (t9-1 sv-32 a1-2 a2-1)) + ) + (when v0-1 + (set! sv-16 v0-1) + (the-as entity-actor sv-16) + ) + ) + (cond + ((and (type-type? (-> sv-16 type) entity-actor) (nonzero? (-> (the-as entity-actor sv-16) nav-mesh))) + (compute-bounding-box (-> (the-as entity-actor sv-16) nav-mesh) s1-0 s2-0) + ) + (else + (set! (-> s1-0 quad) (-> s0-0 quad)) + (set! (-> s2-0 quad) (-> s0-0 quad)) + ) + ) + ) + (let ((f1-0 -12288.0) + (f0-0 12288.0) + ) + (+! (-> s1-0 x) f1-0) + (+! (-> s1-0 y) f1-0) + (+! (-> s1-0 z) f1-0) + (+! (-> s2-0 x) f0-0) + (+! (-> s2-0 y) f0-0) + (+! (-> s2-0 z) f0-0) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 24 of type level-group +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defmethod print-volume-sizes level-group ((obj level-group)) + (local-vars (sv-16 type) (sv-32 (function _varargs_ object)) (sv-48 symbol) (sv-64 string) (sv-80 entity)) + (dotimes (s5-0 (-> obj length)) + (let ((v1-3 (-> obj level s5-0))) + (when (= (-> v1-3 status) 'active) + (let ((s4-0 (-> v1-3 bsp level entity))) + (dotimes (s3-0 (-> s4-0 length)) + (set! sv-80 (-> s4-0 data s3-0 entity)) + (let ((s1-0 (the-as object (res-lump-data sv-80 'visvol pointer))) + (f30-0 (res-lump-float sv-80 'vis-dist :default 409600.0)) + (s2-0 (-> sv-80 extra trans)) + ) + (if (type-type? (-> sv-80 type) entity-actor) + (set! sv-16 (-> (the-as entity-actor sv-80) etype)) + (set! sv-16 (the-as type #f)) + ) + (let ((s0-0 (-> (the-as (inline-array vector) s1-0) 0)) + (s1-1 (-> (the-as (inline-array vector) s1-0) 1)) + ) + (when (not (or (name= sv-16 money) (or (name= sv-16 crate) (name= sv-16 fuel-cell) (let ((t9-6 name=) + (a1-7 springbox) + ) + (t9-6 sv-16 a1-7) + ) + ) + ) + ) + (set! sv-32 format) + (set! sv-48 #t) + (set! sv-64 "actor-vis ~S ~6,,1M ") + (let* ((t9-7 (method-of-type res-lump get-property-struct)) + (a1-8 'name) + (a2-2 'interp) + (a3-2 -1000000000.0) + (t0-2 #f) + (t1-2 #f) + (t2-2 *res-static-buf*) + (a2-3 (t9-7 sv-80 a1-8 a2-2 a3-2 t0-2 (the-as (pointer res-tag) t1-2) t2-2)) + (a3-3 f30-0) + ) + (sv-32 sv-48 sv-64 a2-3 a3-3) + ) + (format + #t + "~6,,1M ~6,,1M ~6,,1M ~6,,1M ~6,,1M ~6,,1M~%" + (- (-> s0-0 x) (-> s2-0 x)) + (- (-> s0-0 y) (-> s2-0 y)) + (- (-> s0-0 z) (-> s2-0 z)) + (- (-> s1-1 x) (-> s2-0 x)) + (- (-> s1-1 y) (-> s2-0 y)) + (- (-> s1-1 z) (-> s2-0 z)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function expand-vis-box-with-point +;; INFO: Return type mismatch int vs none. +(defun expand-vis-box-with-point ((arg0 entity) (arg1 vector)) + (let ((v1-1 (res-lump-data arg0 'visvol (inline-array vector)))) + (when v1-1 + (let ((a0-2 (-> v1-1 0)) + (v1-2 (-> v1-1 1)) + ) + (set! (-> a0-2 x) (fmin (-> a0-2 x) (-> arg1 x))) + (set! (-> a0-2 y) (fmin (-> a0-2 y) (-> arg1 y))) + (set! (-> a0-2 z) (fmin (-> a0-2 z) (-> arg1 z))) + (set! (-> v1-2 x) (fmax (-> v1-2 x) (-> arg1 x))) + (set! (-> v1-2 y) (fmax (-> v1-2 y) (-> arg1 y))) + (set! (-> v1-2 z) (fmax (-> v1-2 z) (-> arg1 z))) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 14 of type level-group +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defmethod debug-draw-actors level-group ((obj level-group) (arg0 symbol)) + (local-vars + (sv-48 (function symbol bucket-id string vector font-color vector2h symbol)) + (sv-64 symbol) + (sv-80 int) + (sv-96 (function symbol bucket-id string vector font-color vector2h symbol)) + (sv-112 symbol) + (sv-128 int) + (sv-144 (function _varargs_ object)) + (sv-160 string) + (sv-176 string) + (sv-192 (function symbol bucket-id string vector font-color vector2h symbol)) + (sv-208 symbol) + (sv-224 int) + (sv-240 (function symbol bucket-id vector vector rgba symbol)) + (sv-256 symbol) + (sv-272 int) + (sv-288 pointer) + (sv-304 pointer) + ) + (when (and arg0 (not (or (= *master-mode* 'menu) (= *master-mode* 'progress)))) + (dotimes (s4-0 (-> obj length)) + (let ((v1-8 (-> obj level s4-0))) + (when (= (-> v1-8 status) 'active) + (let ((s3-0 (-> v1-8 bsp level entity))) + (dotimes (s2-0 (-> s3-0 length)) + (let* ((s0-0 (-> s3-0 data s2-0 entity)) + (s1-0 (-> s0-0 extra trans)) + ) + (cond + ((and (= arg0 'process) (-> s0-0 extra process) (type-type? (-> s0-0 extra process type) process-drawable)) + (let ((s1-1 (the-as process-drawable (-> s0-0 extra process)))) + (add-debug-x + #t + (bucket-id debug-draw1) + (-> s1-1 root trans) + (new 'static 'rgba :r #x80 :g #xff :b #x80 :a #x80) + ) + (set! sv-48 add-debug-text-3d) + (set! sv-64 #t) + (set! sv-80 68) + (let ((a2-2 (res-lump-struct s0-0 'name structure)) + (a3-2 (-> s1-1 root trans)) + (t0-1 1) + (t1-1 (new 'static 'vector2h :y 8)) + ) + (sv-48 sv-64 (the-as bucket-id sv-80) (the-as string a2-2) a3-2 (the-as font-color t0-1) t1-1) + ) + (add-debug-text-3d + #t + (bucket-id debug-draw1) + (symbol->string (-> s1-1 state name)) + (-> s1-1 root trans) + (font-color white) + (new 'static 'vector2h :y 16) + ) + (let ((s0-1 (res-lump-data (-> s1-1 entity) 'eco-info (pointer int32) :time 0.0))) + (when s0-1 + (set! sv-96 add-debug-text-3d) + (set! sv-112 #t) + (set! sv-128 68) + (set! sv-144 format) + (set! sv-160 (clear *temp-string*)) + (set! sv-176 "~S ~D~%") + (let ((a2-7 (pickup-type->string (the-as pickup-type (-> s0-1 0)))) + (a3-5 (-> s0-1 1)) + ) + (sv-144 sv-160 sv-176 a2-7 a3-5) + ) + (let ((a2-8 *temp-string*) + (a3-6 (-> s1-1 root trans)) + (t0-4 1) + (t1-4 (new 'static 'vector2h :y 24)) + ) + (sv-96 sv-112 (the-as bucket-id sv-128) a2-8 a3-6 (the-as font-color t0-4) t1-4) + ) + ) + ) + (let ((v0-10 (res-lump-struct (-> s1-1 entity) 'art-name symbol))) + (if (and (the-as structure v0-10) (= (-> v0-10 type) symbol)) + (add-debug-text-3d + #t + (bucket-id debug-draw1) + (symbol->string v0-10) + (-> s1-1 root trans) + (font-color white) + (new 'static 'vector2h :y 24) + ) + ) + ) + ) + ) + ((or (= arg0 'full) (-> s0-0 extra process)) + (add-debug-x #t (bucket-id debug-draw1) s1-0 (the-as rgba (if (-> s0-0 extra process) + (the-as uint #x8080ff80) + (the-as uint #x800000ff) + ) + ) + ) + (set! sv-192 add-debug-text-3d) + (set! sv-208 #t) + (set! sv-224 68) + (let ((a2-13 (res-lump-struct s0-0 'name structure)) + (t0-8 (if (logtest? (-> s0-0 extra perm status) (entity-perm-status bit-0 bit-1)) + 1 + 5 + ) + ) + (t1-8 (new 'static 'vector2h :y 8)) + ) + (sv-192 sv-208 (the-as bucket-id sv-224) (the-as string a2-13) s1-0 (the-as font-color t0-8) t1-8) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (when (and *display-actor-vis* (not (or *display-actor-anim* *display-process-anim*))) + (let ((s5-1 *display-actor-vis*)) + (dotimes (s4-1 (-> obj length)) + (let ((s3-1 (-> obj level s4-1))) + (when (= (-> s3-1 status) 'active) + (let ((s2-1 (-> s3-1 bsp level entity))) + (dotimes (s1-2 (-> s2-1 length)) + (let ((s0-2 (-> s2-1 data s1-2 entity))) + (let ((v0-15 (res-lump-data s0-2 'visvol pointer)) + (a1-16 (-> s0-2 extra vis-id)) + ) + (when (and v0-15 (or (= s5-1 #t) (= s5-1 'box))) + (set! sv-240 add-debug-box) + (set! sv-256 #t) + (set! sv-272 68) + (set! sv-288 (&+ v0-15 0)) + (set! sv-304 (&+ v0-15 16)) + (let ((t0-10 (if (is-object-visible? s3-1 a1-16) + (the-as uint #x80808000) + (the-as uint #x80800080) + ) + ) + ) + (sv-240 sv-256 (the-as bucket-id sv-272) (the-as vector sv-288) (the-as vector sv-304) (the-as rgba t0-10)) + ) + ) + ) + (when (or (= s5-1 #t) (= s5-1 'sphere)) + (let ((s0-3 (-> s0-2 extra process))) + (when s0-3 + (when (and (type-type? (-> s0-3 type) process-drawable) (nonzero? (-> (the-as process-drawable s0-3) draw))) + (add-debug-x + #t + (bucket-id debug-draw1) + (-> (the-as process-drawable s0-3) root trans) + (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + ) + (add-debug-sphere + #t + (bucket-id debug-draw0) + (vector+! + (new 'stack-no-clear 'vector) + (-> (the-as process-drawable s0-3) draw origin) + (-> (the-as process-drawable s0-3) draw bounds) + ) + (-> (the-as process-drawable s0-3) draw bounds w) + (new 'static 'rgba :r #x80 :a #x80) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if *generate-actor-vis* + (update-vis-volumes obj) + ) + (when (or *display-actor-anim* *display-process-anim*) + (let ((s5-2 (ppointer->process *display-process-anim*))) + (if (not s5-2) + (set! s5-2 (process-by-name *display-actor-anim* *active-pool*)) + ) + (when (and s5-2 (type-type? (-> s5-2 type) process-drawable)) + (let ((s3-2 (-> (the-as process-drawable s5-2) entity)) + (s4-2 (-> (the-as process-drawable s5-2) root trans)) + ) + (when s3-2 + (add-debug-x #t (bucket-id debug-draw1) s4-2 (the-as rgba (if (-> s3-2 extra process) + (the-as uint #x8080ff80) + (the-as uint #x800000ff) + ) + ) + ) + (add-debug-text-3d + #t + (bucket-id debug-draw1) + (res-lump-struct s3-2 'name string) + s4-2 + (the-as font-color (if (logtest? (-> s3-2 extra perm status) (entity-perm-status bit-0 bit-1)) + 1 + 1 + ) + ) + (new 'static 'vector2h :y 8) + ) + (add-debug-text-3d + #t + (bucket-id debug-draw1) + (symbol->string (-> (the-as process-drawable s5-2) state name)) + s4-2 + (font-color white) + (new 'static 'vector2h :y 16) + ) + ) + ) + (if (nonzero? (-> (the-as process-drawable s5-2) skel)) + (dummy-10 (-> (the-as process-drawable s5-2) skel) (the-as symbol *stdcon*)) + ) + (if (nonzero? (-> (the-as process-drawable s5-2) nav)) + (dummy-9 (-> (the-as process-drawable s5-2) nav)) + ) + (if (nonzero? (-> (the-as process-drawable s5-2) path)) + (dummy-9 (-> (the-as process-drawable s5-2) path)) + ) + (if (nonzero? (-> (the-as process-drawable s5-2) vol)) + (dummy-9 (-> (the-as process-drawable s5-2) vol)) + ) + ) + (if (and (the-as process-drawable s5-2) + (type-type? (-> (the-as process-drawable s5-2) type) process-drawable) + (nonzero? (-> (the-as process-drawable s5-2) draw)) + *display-actor-vis* + ) + (add-debug-sphere + #t + (bucket-id debug-draw0) + (vector+! + (new 'stack-no-clear 'vector) + (-> (the-as process-drawable s5-2) draw origin) + (-> (the-as process-drawable s5-2) draw bounds) + ) + (-> (the-as process-drawable s5-2) draw bounds w) + (new 'static 'rgba :r #x80 :a #x80) + ) + ) + ) + (when (and *display-actor-vis* *display-actor-anim*) + (let ((s5-3 (entity-by-name (the-as string *display-actor-anim*)))) + (when s5-3 + (let ((v0-35 (res-lump-data s5-3 'visvol pointer)) + (a1-31 (-> s5-3 extra vis-id)) + ) + (if v0-35 + (add-debug-box + #t + (bucket-id debug-draw1) + (the-as vector (&+ v0-35 0)) + (the-as vector (&+ v0-35 16)) + (the-as rgba (if (is-object-visible? (-> s5-3 extra level) a1-31) + (the-as uint #x80808000) + (the-as uint #x80800080) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (if (and (or *display-nav-marks* *display-path-marks* *display-vol-marks*) + (not (or *display-actor-anim* *display-process-anim*)) + ) + (iterate-process-tree + *active-pool* + (the-as (function object object) (lambda ((arg0 process-drawable)) + (when (type-type? (-> arg0 type) process-drawable) + (if (nonzero? (-> arg0 nav)) + (dummy-9 (-> arg0 nav)) + ) + (if (nonzero? (-> arg0 path)) + (dummy-9 (-> arg0 path)) + ) + (if (nonzero? (-> arg0 vol)) + (dummy-9 (-> arg0 vol)) + ) + ) + (none) + ) + ) + *null-kernel-context* + ) + ) + (when (and *display-actor-graph* (not (or (= *master-mode* 'menu) (= *master-mode* 'progress)))) + (if (not (paused?)) + (float-save-timeplot (if (< (the int (the float (mod (-> *display* base-frame-counter) 600))) 300) + 1.0 + 0.0 + ) + ) + ) + (camera-plot-float-func + 0.0 + 399.0 + -81920.0 + 81920.0 + float-lookup-redline + (new 'static 'vector4w :x #xff :w #x80) + ) + (camera-plot-float-func + 0.0 + 399.0 + -81920.0 + 81920.0 + float-lookup-blueline + (new 'static 'vector4w :z #xff :w #x80) + ) + (camera-plot-float-func + 0.0 + 399.0 + -81920.0 + 81920.0 + float-lookup-greenline + (new 'static 'vector4w :y #xff :w #x80) + ) + (camera-plot-float-func + 0.0 + 399.0 + 0.0 + 409600.0 + float-lookup-yellowline + (new 'static 'vector4w :x #xff :y #xff :w #x80) + ) + (camera-plot-float-func + 0.0 + 399.0 + 0.0 + 1.0 + float-lookup-timeplot + (new 'static 'vector4w :x #x80 :y #x80 :z #x80 :w #x80) + ) + ) + (when *display-split-boxes* + (dotimes (s5-4 (-> obj length)) + (let ((s4-4 (-> obj level s5-4))) + (when (= (-> s4-4 status) 'active) + (when (nonzero? (-> s4-4 bsp boxes)) + (let ((s3-4 (-> s4-4 bsp boxes))) + (countdown (s2-4 (-> s3-4 length)) + (add-debug-box + #t + (bucket-id debug-draw0) + (the-as vector (-> s3-4 data s2-4)) + (the-as vector (+ (the-as uint (-> s3-4 data 0 max)) (* s2-4 32))) + (the-as rgba (if (zero? (-> s4-4 index)) + (the-as uint #x80808000) + (the-as uint #x808080ff) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (when (or *display-ambient-hint-marks* + *display-ambient-sound-marks* + *display-ambient-poi-marks* + *display-ambient-light-marks* + *display-ambient-dark-marks* + *display-ambient-weather-off-marks* + *display-ambient-ocean-off-marks* + *display-ambient-ocean-near-off-marks* + *display-ambient-music-marks* + ) + (dotimes (s5-5 (-> obj length)) + (let ((v1-214 (-> obj level s5-5))) + (when (= (-> v1-214 status) 'active) + (let ((s4-5 (-> v1-214 bsp ambients))) + (when (nonzero? s4-5) + (dotimes (s3-5 (-> s4-5 length)) + (draw-debug (-> s4-5 data s3-5 ambient)) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 22 of type entity-camera +(defmethod birth! entity-camera ((obj entity-camera)) + (add-connection *camera-engine* *camera* nothing obj #f #f) + obj + ) + +;; definition for method 23 of type entity-camera +(defmethod kill! entity-camera ((obj entity-camera)) + (remove-by-param1 *camera-engine* obj) + obj + ) + +;; definition for function init-entity +;; INFO: Return type mismatch process vs none. +(defun init-entity ((proc process) (ent entity)) + (activate proc *entity-pool* (res-lump-struct ent 'name basic) (the-as pointer #x70004000)) + (set! (-> proc entity) ent) + (set! (-> ent extra process) proc) + ((the-as (function process function process entity none) run-function-in-process) + proc + (method-of-object proc init-from-entity!) + proc + ent + ) + (none) + ) + +;; definition for method 22 of type entity-actor +(defmethod birth! entity-actor ((obj entity-actor)) + (let* ((entity-type (-> obj etype)) + (info (entity-info-lookup entity-type)) + (entity-process (get-process *default-dead-pool* entity-type (if info + (-> info heap-size) + #x4000 + ) + ) + ) + ) + (cond + ((not entity-process) + ) + ((begin + (set! (-> entity-process type) entity-type) + (and entity-type + (valid? entity-type type #f #f 0) + (valid? (method-of-object entity-process init-from-entity!) function #f #f 0) + ) + ) + (init-entity entity-process obj) + ) + (else + (when (not (birth-viewer entity-process obj)) + (format 0 "ERROR: no proper process type named ~A exists in the code, could not start ~A~%" entity-type obj) + (logior! (-> obj extra perm status) (entity-perm-status bit-0)) + ) + ) + ) + ) + obj + ) + +;; definition for function entity-deactivate-handler +;; INFO: Return type mismatch symbol vs none. +(defun entity-deactivate-handler ((arg0 process) (arg1 entity)) + (when (= arg0 (-> arg1 extra process)) + (logclear! (-> arg1 extra perm status) (entity-perm-status bit-1 bit-3)) + (set! (-> arg1 extra process) #f) + ) + (none) + ) + +;; definition for method 23 of type entity-actor +(defmethod kill! entity-actor ((obj entity-actor)) + (let ((a0-1 (-> obj extra process))) + (if a0-1 + (deactivate a0-1) + (entity-deactivate-handler a0-1 obj) + ) + ) + obj + ) + +;; definition for method 18 of type bsp-header +;; INFO: Return type mismatch bsp-header vs none. +;; WARN: Unsupported inline assembly instruction kind - [mfc0 s5, Count] +;; WARN: Unsupported inline assembly instruction kind - [mfc0 v1, Count] +(defmethod birth bsp-header ((obj bsp-header)) + (local-vars (v1-71 int) (s5-0 int)) + (.mfc0 s5-0 Count) + (let ((actor-count (if (nonzero? (-> obj actors)) + (-> obj actors length) + 0 + ) + ) + ) + (cond + ((not (-> obj level entity)) + (set! (-> obj level entity) (new 'loading-level 'entity-links-array actor-count)) + ) + ((< (-> obj level entity allocated-length) actor-count) + (format + 0 + "ERROR: Attempting to rebirth level ~A with incorrect entity table size ~D/~D~%" + (-> obj level) + actor-count + (-> obj level entity allocated-length) + ) + ) + ) + ) + (set! (-> obj level entity length) 0) + 0 + (when (nonzero? (-> obj actors)) + (dotimes (birth-idx (-> obj actors length)) + (let* ((idx-to-birth (-> obj actor-birth-order birth-idx)) + (actor-to-birth (-> obj actors data (logand idx-to-birth #xffff) actor)) + ) + (add-to-level! actor-to-birth *level* (-> obj level) (the-as actor-id (-> actor-to-birth aid))) + ) + ) + ) + (let ((existing-amb-count (if (nonzero? (-> obj ambients)) + (-> obj ambients length) + 0 + ) + ) + ) + (cond + ((not (-> obj level ambient)) + (set! (-> obj level ambient) (new 'loading-level 'entity-ambient-data-array existing-amb-count)) + ) + ((< (-> obj level ambient allocated-length) existing-amb-count) + (format + 0 + "ERROR: Attempting to rebirth level ~A with incorrect ambient table size ~D/~D~%" + (-> obj level) + existing-amb-count + (-> obj level ambient allocated-length) + ) + ) + ) + ) + (set! (-> obj level ambient length) 0) + 0 + (let ((amb-array (-> obj level ambient)) + (bsp-ambs (-> obj ambients)) + ) + (when (nonzero? bsp-ambs) + (dotimes (s2-0 (-> bsp-ambs length)) + (let ((amb-to-birth (-> bsp-ambs data s2-0 ambient))) + (set! (-> amb-to-birth ambient-data) (-> amb-array data (-> amb-array length))) + (birth-ambient! amb-to-birth) + ) + (+! (-> amb-array length) 1) + ) + ) + ) + (let ((cams (-> obj cameras))) + (when (nonzero? cams) + (dotimes (s3-1 (-> cams length)) + (birth! (-> cams s3-1)) + ) + ) + ) + (.mfc0 v1-71 Count) + (let ((a3-3 (- v1-71 s5-0))) + (format 0 "Done ~S in ~D~%" "birth" a3-3) + ) + (none) + ) + +;; definition for method 19 of type bsp-header +;; INFO: Return type mismatch bsp-header vs none. +(defmethod deactivate-entities bsp-header ((obj bsp-header)) + (let ((s5-0 (-> obj actors))) + (when (nonzero? s5-0) + (dotimes (s4-0 (-> s5-0 length)) + (let ((s3-0 (-> s5-0 data s4-0 actor))) + (kill! s3-0) + (remove-from-level! s3-0 *level*) + ) + ) + ) + ) + (let ((s5-1 (-> obj cameras))) + (when (nonzero? s5-1) + (dotimes (s4-1 (-> s5-1 length)) + (kill! (-> s5-1 s4-1)) + ) + ) + ) + (let ((s5-2 (-> *entity-pool* child)) + (s4-2 (-> obj level heap base)) + (s3-1 (-> obj level heap top-base)) + ) + (while s5-2 + (let ((s2-0 (ppointer->process s5-2))) + (set! s5-2 (-> s5-2 0 brother)) + (cond + ((-> (the-as process s2-0) entity) + (when (= (-> (the-as process s2-0) entity extra level) (-> obj level)) + (format #t "NOTICE: rogue level entity ~A~% still alive~%" s2-0) + (deactivate s2-0) + ) + ) + ((= (-> s2-0 type) part-tracker) + (let ((v1-28 (the-as part-tracker s2-0))) + (if (and (nonzero? (-> v1-28 part)) + (>= (the-as int (-> v1-28 part group)) (the-as int s4-2)) + (< (the-as int (-> v1-28 part group)) (the-as int s3-1)) + ) + (deactivate s2-0) + ) + ) + ) + (else + (let* ((s1-0 s2-0) + (v1-34 (if (and (nonzero? s1-0) (type-type? (-> s1-0 type) process-drawable)) + s1-0 + ) + ) + ) + (when v1-34 + (cond + ((and (nonzero? (-> (the-as process-drawable v1-34) part)) + (>= (the-as int (-> (the-as process-drawable v1-34) part group)) (the-as int s4-2)) + (< (the-as int (-> (the-as process-drawable v1-34) part group)) (the-as int s3-1)) + ) + (format + #t + "NOTICE: rogue null level entity (using part ~A) ~A~% still alive~%" + (-> (the-as process-drawable (-> (the-as process-drawable v1-34) part)) brother) + s2-0 + ) + (deactivate s2-0) + ) + ((and (nonzero? (-> (the-as process-drawable v1-34) draw)) + (>= (the-as int (-> (the-as process-drawable v1-34) draw art-group)) (the-as int s4-2)) + (< (the-as int (-> (the-as process-drawable v1-34) draw art-group)) (the-as int s3-1)) + ) + (format + #t + "NOTICE: rogue null level entity (using art ~A) ~A~% still alive~%" + (-> (the-as process-drawable (-> (the-as process-drawable v1-34) draw)) mask) + s2-0 + ) + (deactivate s2-0) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (none) + ) + +;; definition for function process-drawable-from-entity! +;; INFO: Return type mismatch process-drawable vs none. +;; Used lq/sq +(defun process-drawable-from-entity! ((arg0 process-drawable) (arg1 entity-actor)) + (logior! (-> arg0 mask) (process-mask actor-pause)) + (set! (-> arg0 root trans quad) (-> arg1 extra trans quad)) + (quaternion-copy! (-> arg0 root quat) (-> arg1 quat)) + (vector-identity! (-> arg0 root scale)) + (none) + ) + +;; definition for method 9 of type entity-perm +(defmethod update-perm! entity-perm ((obj entity-perm) (arg0 symbol) (arg1 entity-perm-status)) + (cond + ((= arg0 'game) + (logclear! (-> obj status) arg1) + ) + ((nonzero? (-> obj task)) + (logclear! (-> obj status) (logior (if (logtest? (-> obj status) (entity-perm-status bit-4)) + 524 + 0 + ) + 515 + ) + ) + ) + (else + (logclear! (-> obj status) (logior arg1 (if (logtest? (-> obj status) (entity-perm-status bit-4)) + 524 + 0 + ) + ) + ) + ) + ) + (when (zero? (logand (-> obj status) (entity-perm-status user-set-from-cstage))) + (set! (-> obj user-uint64) (the-as uint 0)) + 0 + ) + obj + ) + +;; definition for function reset-actors +;; INFO: Return type mismatch int vs none. +(defun reset-actors ((arg0 symbol)) + (set! *display-process-anim* (the-as (pointer process) #f)) + (let* ((v1-0 arg0) + (s5-0 (cond + ((or (= v1-0 'life) (= v1-0 'debug)) + 623 + ) + ((= v1-0 'try) + 623 + ) + ((= v1-0 'game) + 1919 + ) + (else + 1663 + ) + ) + ) + (s4-0 *game-info*) + ) + (dotimes (s3-0 (-> *level* length)) + (let ((v1-4 (-> *level* level s3-0))) + (when (= (-> v1-4 status) 'active) + (let ((s2-0 (-> v1-4 bsp level entity))) + (dotimes (s1-0 (-> s2-0 length)) + (let ((s0-0 (-> s2-0 data s1-0 entity))) + (kill! s0-0) + (update-perm! (-> s0-0 extra perm) arg0 (the-as entity-perm-status s5-0)) + ) + ) + ) + ) + ) + ) + (let ((s3-1 (-> s4-0 task-perm-list))) + (dotimes (s2-1 (-> s3-1 length)) + (update-perm! (-> s3-1 data s2-1) arg0 (the-as entity-perm-status s5-0)) + ) + (logior! (-> s3-1 data 1 status) (entity-perm-status real-complete)) + ) + (let ((s4-1 (-> s4-0 perm-list))) + (dotimes (s3-2 (-> s4-1 length)) + (update-perm! (-> s4-1 data s3-2) arg0 (the-as entity-perm-status s5-0)) + ) + ) + ) + (iterate-process-tree + *entity-pool* + (the-as (function object object) (lambda ((arg0 process-drawable)) (deactivate arg0) (none))) + *null-kernel-context* + ) + (if (= arg0 'game) + (task-control-reset arg0) + ) + (set! (-> *ACTOR-bank* birth-max) 1000) + 0 + (none) + ) + +;; definition for function reset-cameras +;; INFO: Return type mismatch int vs none. +(defun reset-cameras () + (remove-all *camera-engine*) + (dotimes (gp-0 (-> *level* length)) + (let ((v1-5 (-> *level* level gp-0))) + (when (= (-> v1-5 status) 'active) + (let ((s5-0 (-> v1-5 bsp cameras))) + (when (nonzero? s5-0) + (dotimes (s4-0 (-> s5-0 length)) + (birth! (-> s5-0 s4-0)) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 12 of type process-drawable +(defmethod run-logic? process-drawable ((obj process-drawable)) + (or (zero? (logand (-> obj mask) (process-mask actor-pause))) + (or (>= (+ (-> *ACTOR-bank* pause-dist) (-> obj root pause-adjust-distance)) + (vector-vector-distance (-> obj root trans) (math-camera-pos)) + ) + (and (nonzero? (-> obj skel)) (!= (-> obj skel root-channel 0) (-> obj skel channel))) + (and (nonzero? (-> obj draw)) (logtest? (-> obj draw status) (draw-status drwf04))) + ) + ) + ) + +;; definition for method 9 of type entity-links +(defmethod birth? entity-links ((obj entity-links) (arg0 vector)) + (and (zero? (logand (-> obj perm status) (entity-perm-status bit-0 dead))) + (< (vector-vector-distance (-> obj trans) arg0) (-> *ACTOR-bank* birth-dist)) + ) + ) + +;; definition for method 15 of type level-group +;; INFO: Return type mismatch int vs object. +;; Used lq/sq +(defmethod actors-update level-group ((obj level-group)) + (local-vars (sv-16 vector) (sv-24 int) (sv-32 entity-links) (sv-48 int) (sv-64 string) (sv-80 int)) + (when *compact-actors* + (if (and (= *compact-actors* 'debug) (= (-> *nk-dead-pool* alive-list prev) (-> *nk-dead-pool* first-gap))) + (churn *nk-dead-pool* 1) + ) + (if (nonzero? *debug-dead-pool*) + (compact *debug-dead-pool* 10) + ) + (compact + *nk-dead-pool* + (the int + (lerp-scale 8.0 1.0 (the float (-> *display* frames (-> *display* last-screen) frame run-time)) 2000.0 8000.0) + ) + ) + ) + (when (not (paused?)) + (let ((s5-1 (-> *display* frames (-> *display* last-screen) frame run-time))) + (let ((f0-5 + (fmax + 327680.0 + (fmin (+ 327680.0 (* 204.8 (the float (- 7000 (the-as int s5-1))))) (-> *ACTOR-bank* birth-dist)) + ) + ) + ) + (set! (-> *ACTOR-bank* pause-dist) + (seek (-> *ACTOR-bank* pause-dist) f0-5 (* 81920.0 (-> *display* seconds-per-frame))) + ) + ) + (set! (-> *ACTOR-bank* birth-max) + (seekl (-> *ACTOR-bank* birth-max) (the int (lerp-scale 25.0 1.0 (the float s5-1) 2000.0 7000.0)) 10) + ) + ) + (if (movie?) + (set! (-> *ACTOR-bank* birth-max) 1000) + ) + ) + (when *spawn-actors* + (set! sv-16 (camera-pos)) + (set! sv-24 0) + (dotimes (s5-2 (-> obj length)) + (let ((s4-2 (-> obj level s5-2))) + (when (= (-> s4-2 status) 'active) + (cond + ((= (-> s4-2 display?) 'special) + (let* ((s4-3 (-> s4-2 entity)) + (s3-1 (-> s4-3 length)) + ) + (dotimes (s2-0 s3-1) + (let ((v1-44 (-> s4-3 data s2-0))) + (cond + ((logtest? (-> v1-44 perm status) (entity-perm-status bit-7)) + (when (not (or (-> v1-44 process) (logtest? (-> v1-44 perm status) (entity-perm-status bit-0 dead)))) + (birth! (-> v1-44 entity)) + (set! sv-24 (+ sv-24 1)) + (if (>= sv-24 (-> *ACTOR-bank* birth-max)) + (return (the-as object #f)) + ) + ) + ) + (else + (if (and (-> v1-44 process) (zero? (logand (-> v1-44 perm status) (entity-perm-status bit-3)))) + (kill! (-> v1-44 entity)) + ) + ) + ) + ) + ) + ) + ) + ((= (-> s4-2 display?) 'special-vis) + (let* ((s3-2 (-> s4-2 entity)) + (s2-1 (-> s3-2 length)) + ) + (dotimes (s1-0 s2-1) + (let ((s0-0 (-> s3-2 data s1-0))) + (cond + ((and (logtest? (-> s0-0 perm status) (entity-perm-status bit-7)) (is-object-visible? s4-2 (-> s0-0 vis-id))) + (when (not (or (-> s0-0 process) (logtest? (-> s0-0 perm status) (entity-perm-status bit-0 dead)))) + (birth! (-> s0-0 entity)) + (set! sv-24 (+ sv-24 1)) + ) + ) + (else + (when (and (-> s0-0 process) (zero? (logand (-> s0-0 perm status) (entity-perm-status bit-3)))) + (kill! (-> s0-0 entity)) + (set! sv-24 (+ sv-24 1)) + ) + ) + ) + ) + (if (>= sv-24 (-> *ACTOR-bank* birth-max)) + (return (the-as object #f)) + ) + ) + ) + ) + ((= (-> s4-2 display?) 'actor) + (let* ((s4-4 (-> s4-2 entity)) + (s3-3 (-> s4-4 length)) + ) + (dotimes (s2-2 s3-3) + (let ((v1-84 (-> s4-4 data s2-2))) + (cond + (#t + (when (not (or (-> v1-84 process) (logtest? (-> v1-84 perm status) (entity-perm-status bit-0 dead)))) + (birth! (-> v1-84 entity)) + (set! sv-24 (+ sv-24 1)) + (if (>= sv-24 (-> *ACTOR-bank* birth-max)) + (return (the-as object #f)) + ) + ) + ) + (else + (if (and (-> v1-84 process) (zero? (logand (-> v1-84 perm status) (entity-perm-status bit-3)))) + (kill! (-> v1-84 entity)) + ) + ) + ) + ) + ) + ) + ) + ((not *vis-actors*) + (let* ((s4-5 (-> s4-2 entity)) + (s3-4 (-> s4-5 length)) + ) + (dotimes (s2-3 s3-4) + (let ((s1-1 (-> s4-5 data s2-3))) + (cond + ((and (< (vector-vector-distance (-> s1-1 trans) sv-16) (-> *ACTOR-bank* birth-dist)) + (zero? (logand (-> s1-1 perm status) (entity-perm-status bit-9 bit-10))) + ) + (when (not (or (-> s1-1 process) (logtest? (-> s1-1 perm status) (entity-perm-status bit-0 dead)))) + (birth! (-> s1-1 entity)) + (set! sv-24 (+ sv-24 1)) + (if (>= sv-24 (-> *ACTOR-bank* birth-max)) + (return (the-as object #f)) + ) + ) + ) + (else + (if (and (-> s1-1 process) (zero? (logand (-> s1-1 perm status) (entity-perm-status bit-3)))) + (kill! (-> s1-1 entity)) + ) + ) + ) + ) + ) + ) + ) + (*vis-actors* + (when (not (and (-> s4-2 vis-info 0) (-> s4-2 all-visible?))) + (let* ((s3-5 (-> s4-2 entity)) + (s2-4 (-> s3-5 length)) + (s0-1 #f) + ) + (dotimes (s1-2 s2-4) + (set! sv-32 (-> s3-5 data s1-2)) + (cond + ((and (is-object-visible? s4-2 (-> sv-32 vis-id)) + (zero? (logand (-> sv-32 perm status) (entity-perm-status bit-9 bit-10))) + ) + (when (not (or (-> sv-32 process) (logtest? (-> sv-32 perm status) (entity-perm-status bit-0 dead)) s0-1)) + (birth! (-> sv-32 entity)) + (set! sv-24 (+ sv-24 1)) + (when (< (/ (the float (memory-free *nk-dead-pool*)) (the float (memory-total *nk-dead-pool*))) 0.1) + (let ((s0-2 format)) + (set! sv-48 0) + (set! sv-64 "WARNING: low actor memory, no birth triggered!!! ~D/~D~%") + (set! sv-80 (memory-free *nk-dead-pool*)) + (let ((a3-2 (memory-total *nk-dead-pool*))) + (s0-2 sv-48 sv-64 sv-80 a3-2) + ) + ) + (set! s0-1 #t) + ) + ) + ) + (else + (when (and (-> sv-32 process) (zero? (logand (-> sv-32 perm status) (entity-perm-status bit-3)))) + (kill! (-> sv-32 entity)) + (set! sv-24 (+ sv-24 1)) + ) + ) + ) + (if (>= sv-24 (-> *ACTOR-bank* birth-max)) + (return (the-as object #f)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + ) + +;; definition for function entity-birth-no-kill +;; INFO: Return type mismatch process vs none. +(defun entity-birth-no-kill ((arg0 entity)) + (let ((gp-0 (-> arg0 extra))) + (logior! (-> gp-0 perm status) (entity-perm-status bit-3)) + (if (not (or (-> gp-0 process) (logtest? (-> gp-0 perm status) (entity-perm-status bit-0 dead)))) + (birth! (-> gp-0 entity)) + ) + (-> gp-0 process) + ) + (none) + ) + +;; definition for function entity-task-complete-on +;; INFO: Return type mismatch int vs none. +(defun entity-task-complete-on ((arg0 entity)) + (let ((v1-0 (-> arg0 extra))) + (if (nonzero? (-> v1-0 perm task)) + (logior! (-> *game-info* task-perm-list data (-> v1-0 perm task) status) (entity-perm-status real-complete)) + ) + ) + 0 + (none) + ) + +;; definition for function entity-task-complete-off +;; INFO: Return type mismatch int vs none. +(defun entity-task-complete-off ((arg0 entity)) + (let ((v1-0 (-> arg0 extra))) + (if (!= (-> v1-0 perm task) (game-task complete)) + (logclear! (-> *game-info* task-perm-list data (-> v1-0 perm task) status) (entity-perm-status real-complete)) + ) + ) + 0 + (none) + ) + +;; definition for method 30 of type entity-actor +;; INFO: Return type mismatch entity-perm-status vs none. +(defmethod dummy-30 entity-actor ((obj entity-actor) (arg0 entity-perm-status) (arg1 symbol)) + (let ((v1-0 (-> obj extra))) + (if arg1 + (logior! (-> v1-0 perm status) arg0) + (logclear! (-> v1-0 perm status) arg0) + ) + (-> v1-0 perm status) + ) + (none) + ) + +;; definition for function process-entity-status! +(defun process-entity-status! ((arg0 process) (arg1 entity-perm-status) (arg2 symbol)) + (cond + ((and (-> arg0 entity) (= arg0 (-> arg0 entity extra process))) + (let ((v1-6 (-> arg0 entity extra))) + (if arg2 + (logior! (-> v1-6 perm status) arg1) + (logclear! (-> v1-6 perm status) arg1) + ) + (the-as int (-> v1-6 perm status)) + ) + ) + (else + 0 + ) + ) + ) + +;; definition (debug) for function entity-speed-test +;; INFO: Return type mismatch entity vs none. +;; WARN: Unsupported inline assembly instruction kind - [mtc0 Count, r0] +;; WARN: Unsupported inline assembly instruction kind - [sync.p] +;; WARN: Unsupported inline assembly instruction kind - [mfc0 s4, Count] +(defun-debug entity-speed-test ((arg0 string)) + (local-vars (r0-0 none) (s4-0 int)) + (let ((gp-0 (entity-by-name arg0))) + (when gp-0 + (set! *spawn-actors* #f) + (reset-actors 'debug) + 0 + (disable-irq) + (.mtc0 Count r0-0) + (.sync.p) + (birth! gp-0) + (.mfc0 s4-0 Count) + (enable-irq) + (format #t "~D spawn ~A ~A ~%" s4-0 arg0 (-> gp-0 extra process)) + (kill! gp-0) + ) + ) + (none) + ) + +;; failed to figure out what this is: +0 diff --git a/test/decompiler/reference/engine/gfx/ocean/ocean-frames_REF.gc b/test/decompiler/reference/engine/gfx/ocean/ocean-frames_REF.gc new file mode 100644 index 0000000000..5c1d124a6e --- /dev/null +++ b/test/decompiler/reference/engine/gfx/ocean/ocean-frames_REF.gc @@ -0,0 +1,16395 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *ocean-wave-frames*, type (pointer uint32) +(define *ocean-wave-frames* (new 'static 'array uint32 16384 + #x130af9fc + #x12fdff18 + #xf1effc05 + #xb170e04 + #x4fb00fb + #xf0dfa07 + #xffff0701 + #xf80010 + #x1408f4fa + #xbf1021b + #xe7fa050b + #x11140efa + #x4fcfcfc + #xe00fe0e + #xfa010e06 + #xfcf80a11 + #xefff2fb + #xfbf00c19 + #xeb0b0906 + #x120d0aee + #x2fdf803 + #x7fc060e + #xfa0c1108 + #xfc001007 + #x7faf700 + #xf1f8100f + #xfc1502fc + #xc0603eb + #x5fef80b + #x2ff0d0a + #x120b06 + #x51001 + #x5fcfd02 + #xf1ff0804 + #xe12f9f5 + #x100fdf3 + #xbfcfa0f + #x1071008 + #x50e0507 + #x20c10fd + #x8fb0004 + #xf1fafb06 + #x1606f6f3 + #xf7fcfd02 + #x10f9000b + #xe0d09 + #x406070b + #x5130ef9 + #x7f70509 + #xebf0f914 + #x1201f9ec + #xf3fe000d + #xff90400 + #x2180b0d + #x2020e08 + #xc1904f4 + #xfcf40e10 + #xe4ed041f + #xe07f7e1 + #xf7ff0012 + #x7fb06f7 + #x91f0e13 + #x1031301 + #x1312f4f4 + #xf0ff170f + #xe8f71117 + #xe0dede0 + #xfefb0213 + #xfd0003f6 + #x171c1214 + #x1050b00 + #xe00ed00 + #xf30d1404 + #xf3011207 + #xf08e4e1 + #xfff50a13 + #xf80400fd + #x1f19140d + #x1050107 + #xf4f608 + #x21306f6 + #x40aff + #xcf9e0e7 + #xf8f21313 + #xfa050005 + #x1f181602 + #x5fd12 + #xf4f70608 + #xa07f7f2 + #x3000505 + #x2ebe0f2 + #xf1fa170d + #x1060409 + #x1e1a11fb + #x3030018 + #xf5020d02 + #x2f6f3f8 + #xff070d + #xf7e7e8fb + #xf2031403 + #x7070804 + #x1b1d08f9 + #x7000217 + #xfc0b0c03 + #xf1edfa00 + #x20c0a + #xf1f2f4fa + #xfa0708f9 + #xa080900 + #x1b1d01fd + #x9fd0311 + #x20a0a0c + #xe8f60000 + #x80807f7 + #xf6fdf5fb + #xfdf3 + #x90a0803 + #x1d150104 + #x5fb010f + #x1081316 + #xeffffffd + #xf04fae9 + #xfbfff404 + #xfef7faf3 + #x90b0709 + #x1d100706 + #xf9fe10 + #xfe0b1d16 + #xfdfff9fb + #xdf8eaea + #xfcf9fd12 + #xf5f4fef4 + #xc0b080c + #x19100b03 + #xfdf9fc16 + #xfe151f0b + #x1f5f9fe + #xebe5f9 + #xf7f90e17 + #xf1fdfff1 + #x11080a07 + #x14150700 + #xfff6001a + #x21a1d04 + #xfbedff00 + #xf1e6eb06 + #xf5031b0d + #xf907f7ec + #x14030900 + #x12180001 + #xfff30918 + #x51e1702 + #xf1ef0400 + #xeee8f30b + #xf81218f9 + #xa09e9ea + #xefe0700 + #x1216fc0c + #xfbf51413 + #x71f1405 + #xedf70002 + #xf5ecf907 + #xfe1c09ee + #x15fde2ed + #xfe090b + #x130a0012 + #xf6001b0e + #xd1f0f05 + #xeffafa09 + #xfbecfd02 + #x31bfbef + #x14eee6f2 + #xf4010e19 + #x12030a0d + #xf90e1609 + #x161b0a02 + #xf1f9fd14 + #xf9ed00ff + #x513f5f7 + #x6e5f0f3 + #xf209161f + #xe051000 + #x5180a08 + #x1d130500 + #xf0f80a18 + #xf3f202fa + #x50bf7fa + #xfaeaf6f2 + #xfc10191f + #xc0c0af3 + #x12170009 + #x18080302 + #xf300140f + #xf2f8fff6 + #x608faf8 + #xf6f3f6f3 + #x9111918 + #xa0f00f2 + #x160c000b + #x9010408 + #xfc0b1302 + #xf8faf9f8 + #x808faf6 + #xfaf8f4f7 + #xf0e1510 + #x80cf8fc + #x11060609 + #xfdfe050c + #x80f09fc + #xfdf6f8ff + #x806f6f8 + #xfef8f7fd + #xb09110d + #x607fc05 + #xc080a04 + #xf8fc060e + #x100c02f8 + #xf9f2fd07 + #x704f5fb + #xfdf8ff00 + #x5050d0e + #x4060307 + #xb0a0700 + #xf4f8070d + #x120702f4 + #xf3f8040e + #x600f4f9 + #xfafd0801 + #x3030b0d + #x40b0903 + #xb0a0200 + #xeefb0a0a + #x100502f0 + #xf7020610 + #x6f9f3f7 + #xf9070c02 + #x5000909 + #x61205ff + #xa050200 + #xed000808 + #xf0700f2 + #x2080312 + #x1f1f4f8 + #xfe110c05 + #x6fc0601 + #x915fefe + #x70103ff + #xf4020309 + #x110afbfa + #x1002ff17 + #xf7edf800 + #x8170d07 + #x6fb03fd + #xd13fb03 + #x1fe0600 + #xfffdfe0f + #x1305f4fb + #x9f50c18 + #xecf80010 + #x13130df9 + #xfcfffdff + #x13fc020b + #xfc05000a + #xfafb0e07 + #x11fdf4f7 + #xf7f4141a + #xee03080f + #x121109eb + #xfefcf906 + #x9f80a0c + #xfd0b070b + #xf50313ff + #x6f7f7fa + #xec001812 + #xff0d0703 + #xe0dfee7 + #x1fafc0f + #x1ff0e08 + #x4110809 + #xfa0b0ffa + #xf7fdfe + #xef071009 + #xf0bfff8 + #x707f4f1 + #x4f70110 + #x80d07 + #xa0e0607 + #xf0bfb + #xfb0001 + #xf7030206 + #x1600f8f5 + #xfd01f303 + #x7f70808 + #x210080a + #xa070805 + #x51307fd + #xfb0207 + #xf5f6ff0e + #x10fdf8f3 + #xfa00fb0f + #x4fc0bfd + #x7120810 + #x3040f03 + #xe1600fb + #xf9fc0711 + #xecef0814 + #xb02f5e9 + #xfb000312 + #xff0007f3 + #xe120c14 + #x71000 + #x1810f5fb + #xf1030f16 + #xe5f6170d + #xb0aeae0 + #xfdfd0911 + #xfb0500f2 + #x1a131414 + #x10c0902 + #x19ffec00 + #xf511100d + #xec031afc + #x1302e2e1 + #xfaf90f10 + #xfc05fcfd + #x1f13180b + #x30aff0e + #x9f0f304 + #x31607fd + #xf7090ff5 + #x14f3e0e7 + #xf4fb1413 + #x2fd04 + #x1e161600 + #x305fd18 + #xf9f30003 + #xe0efaf3 + #xfe0504fe + #x9e5e0f3 + #xef021712 + #x4010504 + #x1b1a0dfb + #x401041d + #xf4000800 + #x7fdf3f7 + #xfc000709 + #xfae0e8fc + #xf10c130a + #x7040afc + #x1c1d03fc + #x6ff0a1b + #xfd090500 + #xf8f3f6ff + #xfb030e08 + #xf2e7f3fd + #xfb0f0cfe + #x8080af8 + #x1d18fe01 + #x5ff0c16 + #x4090409 + #xecf5fd02 + #x80df8 + #xf5f6f5fb + #x20900f5 + #x90a06fc + #x1f110006 + #x2fd0714 + #x4070b11 + #xf0fefeff + #x80900e9 + #xfef8f402 + #xfff9f4 + #xa0a0604 + #x1c0b0507 + #xfffc0117 + #xb1810 + #xfafffbfb + #x9ffefe9 + #xf4fc0f + #xf7faf8f7 + #xc080b08 + #x170d0805 + #xfdf8031a + #x161d0a + #xfff9f8fd + #xefe7f7 + #xfbf40c14 + #xf2fff8f9 + #xf090f00 + #x14130304 + #xfdf50819 + #x51f1802 + #xf7f3fb03 + #xf4e5ee04 + #xf601180b + #xfa05f4f4 + #xf080df7 + #x1715fe09 + #xfaf31015 + #xe1f1003 + #xedf6fe07 + #xede5fa05 + #xf91416fd + #x804ecef + #x90709f7 + #x1a0cfd11 + #xf4f71612 + #x141f0d07 + #xebfefb0a + #xeeea02fe + #x21f06f2 + #x11f9e6ee + #x50502 + #x19010513 + #xf1011811 + #x181e0b07 + #xf1fff511 + #xf1ef04f6 + #xd1af8f3 + #xcebe8f2 + #xf8050917 + #x14fe100c + #xf60f1113 + #x1d170aff + #xf5faf918 + #xeff304f3 + #x110ef3fa + #xffe6eef6 + #xf809131f + #xd0412ff + #x3160811 + #x1f1206fa + #xf3f8061c + #xeaf804f3 + #x1002f8fd + #xf2ebf2f9 + #xf1d1b + #x90e09f2 + #x1314020e + #x1d0b00fe + #xf2001213 + #xecfc00f1 + #xdfffcf9 + #xf0f4f0fa + #xa141f10 + #xc13fbf3 + #x1708030d + #xf040109 + #xf80b1205 + #xf3fdfbf1 + #xb00fbf5 + #xf6f7eefd + #xe151d07 + #xd0bf4fe + #x1002070b + #x2020511 + #x41209fd + #xf9f8f7f7 + #xb02f8f8 + #xfcf7f100 + #xc101605 + #xb01f908 + #x8040a08 + #xfc02080f + #xe0c01f9 + #xf6f4fc02 + #xafff7fd + #xfbf7f902 + #x60d1209 + #x800020a + #x90a0705 + #xf900080b + #xe0600f4 + #xf0f6030c + #x9fbf9fc + #xf9fcff03 + #x3081009 + #x6050706 + #xc0a0202 + #xf3000809 + #xa0500ef + #xf1ff0911 + #x7f7f9f7 + #xf9040105 + #x2061002 + #x90d0402 + #xd070001 + #xf002070a + #x908fbef + #xfe050811 + #x2f3f6f5 + #xd0308 + #x1030dfc + #xf10fe02 + #x9030100 + #xf403050c + #xd0af5f6 + #xb000613 + #xf9f1f5fd + #x9110707 + #xff0208f9 + #x1409fb06 + #x2020001 + #xfcff050d + #x1308f4fc + #xdf90918 + #xeef4fc0b + #x12130cff + #xfc0100fb + #x14ff000b + #xfe030006 + #xfdf90a0c + #x11faf6f4 + #xf3ff1718 + #xf1fb0a12 + #x141206ee + #xfdfdf90c + #x7fb0c03 + #x1030013 + #xf30911fc + #x7f4f5f4 + #xe8071c17 + #xfd041005 + #x1211f8e9 + #xfef8ff10 + #xfe020e03 + #x70a070e + #xf8120cf7 + #xfef4f9fb + #xef11150d + #xb0607f6 + #xf0aebf4 + #xfff7050f + #xfe0b0c04 + #xd0a0806 + #x21404fb + #xfbfafc01 + #xfb0e0905 + #x1100fdf2 + #x901ea05 + #xfdfa0c08 + #x40e0808 + #xc070802 + #x9130100 + #xfcfdfd08 + #xff000205 + #xcfbf8f5 + #x2fcf712 + #xfa010dfd + #xb0c080d + #x5050b01 + #x1111ff03 + #xfbfe0013 + #xf2f6090a + #x5fef7f3 + #xfd0514 + #xfa0706f6 + #x100a0f10 + #xa0a01 + #x1b0bf700 + #xf701081b + #xe6fb1402 + #x801eee9 + #xffff0d0e + #xfc09fdf6 + #x150a170e + #x20f0406 + #x1dfdf2fe + #xfa0d1016 + #xe50a19f4 + #x11fce1e0 + #xfb00100e + #x4f6fc + #x190d1906 + #x80dfe10 + #xfedf400 + #x7150d03 + #xf2140ced + #x15ebe0e4 + #xf5021116 + #x600fb00 + #x1a161300 + #x906001b + #xfaeeff00 + #x120ffff6 + #xfc0e00f7 + #xae1e2ee + #xf209131a + #x6ff04fd + #x191b0aff + #x6000a1e + #xf3fb0300 + #xe01f4f7 + #xfd040006 + #xf9e0ebf9 + #xf7101314 + #x40409f3 + #x1c1b0100 + #x3ff131b + #xfb060001 + #xfff5f400 + #xfa040a09 + #xede2f4fb + #x130d05 + #x50a06ef + #x1f12fe04 + #x1011219 + #x6050007 + #xf3f5fa05 + #xfb0b0efc + #xefedf8f9 + #x70e04fa + #x70c02f4 + #x1e090007 + #x1020d1a + #x802060c + #xf2fbfe01 + #x20f03eb + #xf9f3f7fd + #x604faf7 + #x90a01ff + #x1a060608 + #x81c + #x206110d + #xfafefbfe + #x906f1e9 + #xfdeffd07 + #xfefef5fd + #xb080803 + #x140a0708 + #xfdfa091c + #x1131607 + #xfefbf600 + #x3f5e9f4 + #xf9f00a0f + #xf8fdf600 + #xa0a0efd + #x130f0409 + #xfaf81019 + #xa1f1304 + #xf7f6f509 + #xf7e7efff + #xf300170c + #xfd00f6fc + #x90f0df1 + #x180d000b + #xf4f81315 + #x171e0c04 + #xf0f8f711 + #xebe7fdfe + #xf81314ff + #x6fff2f4 + #x71004f3 + #x1c050210 + #xeffd1414 + #x1d1a0a06 + #xf0fcf715 + #xe6ef05f4 + #x51d08f5 + #xcf7edf0 + #x40cff01 + #x19fc0b11 + #xee061218 + #x1f150b00 + #xf7fcf719 + #xe7f805eb + #x1419fbf4 + #x6eceaf5 + #xfe070213 + #x10fb1309 + #xf510101a + #x1f140bf7 + #xfbf6fc1d + #xe8fd00ed + #x1a06f8f8 + #xf9e8ebff + #x6101c + #x70712fe + #x4140c16 + #x1f1305f2 + #xf7f4071f + #xe800fef0 + #x16fbfbf8 + #xefeced04 + #x30e1e15 + #x51207f5 + #x100f0a0f + #x1e0cfff9 + #xf2fb141a + #xeb01fcf0 + #xdfa00f4 + #xeff2ee06 + #x8171f06 + #xe13f8f6 + #x1406080a + #x1403fd08 + #xf709130c + #xf300f7ed + #x9fefdf0 + #xf6f4ed06 + #xd1b1cfd + #x1208f300 + #xb000a0c + #x8010414 + #x3110902 + #xf8fbf4f0 + #x8fff9f3 + #xfbf2f106 + #xe1b16fe + #x10fcf909 + #x4030b0e + #x2030a11 + #xe0e00fe + #xf6f6f6fc + #x8fcfafb + #xfbf2f607 + #xa161103 + #x7f9040b + #x609090b + #x4090a + #xe06fefb + #xeff7ff08 + #x6f9fefa + #xf8f8fb08 + #x6111103 + #x4010906 + #xc0a0407 + #xfc030608 + #x804fcf5 + #xeffd070e + #x4f8fef4 + #xfb00fe09 + #x40e11ff + #x7090603 + #xe060104 + #xf902040c + #x608f7f3 + #xfa040b0d + #xf7f8f0 + #x205000a + #xe0ef9 + #xf090002 + #xa030004 + #xf902060f + #xd09f0f6 + #x6030b0c + #xfaf4f3f9 + #xb080509 + #xfe0d06f8 + #x14040004 + #x502fe07 + #xfd00080e + #x1304eef9 + #x6fe0d10 + #xf2f3f808 + #x110b0b00 + #xfd09ff00 + #x13fb0405 + #x202fd0f + #xfc000c07 + #x13fdf4f6 + #xfbfd1416 + #xeff80513 + #x13100bf3 + #xfc02f907 + #xbf80a05 + #x103fd12 + #xf5041100 + #x5f2f2f5 + #xee0e1b1b + #xf9001401 + #x1310f6ee + #xf70012 + #xfb0909fe + #x3000e0d + #xfd1305fd + #xfbf1f3fd + #xf4171a13 + #x3080ef1 + #x1608e8f6 + #xfcf70810 + #xfe0e0800 + #x8050e04 + #x913fefe + #xf7f7f706 + #x3160e06 + #x906ffec + #x11fbe905 + #xf7ff0d0b + #x60f0704 + #xa070a00 + #x100dfc06 + #xfbfbfa0d + #x80a0501 + #x700f7f3 + #x8f3f711 + #xf5060b05 + #xc0a0a06 + #x6070600 + #x150afe08 + #xfdfdfd15 + #xfefe0601 + #xfdf7f9 + #xf60911 + #xf90b03ff + #xe061106 + #x1090406 + #x1a06fe04 + #xfcfe071c + #xed000eff + #x3fff5f1 + #xfefe110b + #x9fafc + #xe081604 + #x50d000b + #x1afdf9fe + #xfe041319 + #xe80d0ff5 + #xaf9ebe5 + #xfd040f0b + #x703f5fe + #xf111602 + #xb0cff12 + #xdf1f8fe + #x60e1706 + #xf41804ef + #xfe8e0e0 + #xfb070d16 + #xafdfa00 + #x11190f01 + #xc040319 + #xf8eefd00 + #x110f09f6 + #x112f7fa + #x4e0e2e8 + #xfa0b121e + #x6fd01f8 + #x151c0701 + #x6ff111a + #xeef80002 + #x1204f9f5 + #x506f808 + #xf4e0e9f3 + #xfe10181a + #x10405ef + #x1b180204 + #x1011918 + #xf6000003 + #x5f8f4ff + #xff01050d + #xe6e1f4f7 + #x6141609 + #x20c00ec + #x1f0e0106 + #xff061719 + #x300ff05 + #xf8f3fb06 + #xfe0a0a02 + #xe6ecf8f6 + #xd110bfa + #x70cf9f4 + #x1c050306 + #x9111b + #x5ff0407 + #xf4f70003 + #x21003f3 + #xf0f2f7f7 + #xc0800f7 + #xb08faff + #x17030607 + #x50e1e + #x1020c08 + #xf9fcfeff + #xa0bf2ec + #xf7effa00 + #x400f8fe + #xb060203 + #x11070808 + #xfeff101f + #xd1106 + #xfdfbf703 + #x9f9e8f4 + #xf3f20509 + #xfefbf901 + #x90a08fd + #x110b060a + #xf8fd1519 + #xb180f03 + #xfbf6f40e + #xfcebeefc + #xefff1109 + #xfefafefe + #x81206f5 + #x1609050c + #xf3001615 + #x1a1a0b02 + #xf5f4f718 + #xeceafbfa + #xf4121300 + #x4fcfcf4 + #xa14fef5 + #x1901080d + #xef041218 + #x1f130900 + #xf5f6fd1d + #xe4f501f0 + #x51b09f5 + #x7f6f4f1 + #xc0cf702 + #x13fc0e0c + #xf10a101d + #x1f100cf8 + #xfaf6011f + #xe5fffeea + #x1513fef0 + #x1efedf8 + #xb04fd12 + #x9011408 + #xf80e111e + #x1e110bef + #xfcf1071f + #xea03f7ee + #x1b04fbf0 + #xf8eaeb06 + #x6010d19 + #x10c0f00 + #x4111217 + #x1d1204ec + #xf6f0111f + #xee02f4f5 + #x14fbffef + #xefebee10 + #x40c1d0d + #x41603fa + #xf0e130c + #x1c0dfbf6 + #xf0f8191b + #xf301f5f5 + #x9fb00ed + #xf0eef311 + #x7191eff + #xe13f8fa + #x11080f07 + #x1503f906 + #xf3061911 + #xf900f4ef + #x200fcea + #xf5eff60d + #xd1f17f7 + #x1605f400 + #x9020b0b + #xafe0313 + #xf0c06 + #xfcfdefee + #x301f7ef + #xf8edf909 + #x131f0ffa + #x12f8fa08 + #x30b11 + #x4020d11 + #xc0b0203 + #xfaf7eff8 + #x4fdf7f5 + #xf7edfc09 + #x131b0b00 + #x7f6030a + #x80b11 + #x3070d07 + #xd03fe02 + #xf3f5f806 + #x3fafdf8 + #xf6f2fe0a + #xf160c02 + #xff0907 + #x90b090b + #x3060605 + #x701fdff + #xf0fb030c + #xfffbfef1 + #xf8f8000b + #xa140dfd + #x3080704 + #xd070505 + #x1030c + #x604f7fb + #xf8020a0a + #xfdfdf8ec + #xfffd040b + #x81509fa + #xb080302 + #xa030205 + #xffff0611 + #xd05eff9 + #x1070b06 + #xfafaf1f3 + #x7000807 + #x51301fc + #x10020201 + #x501ff0b + #xfe000c0f + #x13ffedfa + #x3040a0a + #xf5f4f402 + #xa040d01 + #x50cfb03 + #xdfd0500 + #x400ff13 + #xfd020e0a + #x12f7f0f7 + #xfa030f15 + #xf2f3020b + #xd0b0af7 + #x603f90b + #x5fe09ff + #x4fe0417 + #xf9090e03 + #x9f3f3f4 + #xef0a181c + #xf4fb1208 + #x1211feef + #x2fafe11 + #xfd0308fe + #x2fe0911 + #xf9120afd + #xf8efee03 + #xff181d17 + #xfc0f0ced + #x1604ecf5 + #xfaf90a12 + #x100200 + #xff0514ff + #x110dfe03 + #xf4f2f30d + #xd1b1607 + #x511fbe9 + #x13f5ec00 + #xf5000d12 + #x80f0500 + #x4090bfc + #x1708fc07 + #xf7f6fa11 + #x141209fe + #x507f1f5 + #x6ecfb0a + #xf6080b10 + #xd0a08ff + #x5090401 + #x1603000a + #xfcf80015 + #xa0503fe + #xfff4ff + #xfcf10c0d + #xfe0c040a + #xc080cfd + #x4090107 + #x15010206 + #xfdf90a18 + #xf70106ff + #xfffdfafb + #xf8fe1407 + #x707fc04 + #x80c0ffd + #x70a010c + #x13ff00ff + #xfbff1815 + #xf10b06fb + #x4fcf4eb + #xfc070f06 + #xc00f800 + #x7140eff + #xc08030e + #x9f6fbfe + #x91d06 + #xfc13fef7 + #x7efe7e1 + #xa0c11 + #xaf9fafe + #xc1b0a02 + #xe020910 + #xf8f3fc02 + #xa1114f4 + #xc0df2fd + #xfde1e0e6 + #x10b101c + #x5fa00f9 + #x131d0606 + #x6001111 + #xeaf6ff06 + #xf0a00f0 + #xffff20b + #xece0e3f1 + #x30f1c16 + #x400f1 + #x1b140408 + #xff041914 + #xf0fd0005 + #x9fcf7fa + #x7fbff12 + #xe1e3edf8 + #x8131f06 + #x10af9f1 + #x1f0b0406 + #xfe0c1718 + #xfdfe0003 + #xfbf4fc02 + #x40b0a + #xe0eef4f7 + #xe1417f5 + #x908f1f9 + #x19050604 + #x210121d + #x1fc0302 + #xf4f60300 + #x50d04fb + #xe9f4f4f5 + #xf0f07f1 + #xe02f303 + #x12030706 + #x40b131f + #xfdff0903 + #xf6fb02fd + #xe0bf6f2 + #xf2f4f5fb + #xa03fef7 + #xd00fc08 + #xd070709 + #x106161c + #xfc090e03 + #xfbfcfb00 + #x10fbeaf4 + #xf0f3fe05 + #x1fbfeff + #x9060403 + #xd0a080b + #xfb031817 + #x6120d02 + #xfbf6f70e + #x2eceefc + #xed000909 + #xfefa04fb + #x90e01fb + #x1208080a + #xf6071614 + #x16140bfe + #xf7f1fd1a + #xf0ebf8fb + #xf30d0e03 + #xfefb03f2 + #x1010fafa + #x13030a09 + #xf50b1218 + #x1e110af9 + #xf5f1071f + #xe5f6fdf3 + #x41709f6 + #xfbfaef + #x1608f404 + #xe010e0a + #xf70c111e + #x1b0e0bf1 + #xf6f2101c + #xe900f7f0 + #x161300ec + #xfef5effa + #x14fefb0e + #x3060f09 + #xfd0d161c + #x161108ea + #xf6f2161b + #xf201eff4 + #x1906fae9 + #xf6eeec0a + #xcfd0b0f + #xff110b06 + #x40f1c14 + #x151400ea + #xf1f31a1c + #xf9fdedfb + #x11fef9e9 + #xf0eaf316 + #x4091b07 + #x4180301 + #xb0f1b08 + #x180ff5f5 + #xebfb1f1b + #xfefaf2f9 + #x401f9e9 + #xefeafe15 + #x6191bfb + #x1011fbff + #xc0d1204 + #x1502f405 + #xee071e13 + #xfbf3f2 + #xff04f5ea + #xf1ec030e + #xf1f12f6 + #x1802f600 + #x909090b + #xbfcff10 + #xfc0f1408 + #x1f9efee + #x204f1ef + #xf3ed0407 + #x191f08f9 + #x11f5fa06 + #x1070915 + #x1000f0e + #x90c0703 + #xfef3ebf7 + #x3fff2f5 + #xf1ee0307 + #x1d1b05ff + #x4f5020b + #x90d15 + #x1091102 + #xb020205 + #xf8f0f104 + #x1fcf7f6 + #xf0f10408 + #x1a140800 + #xfdff070c + #x50b0f0c + #x60b08ff + #x5fe0105 + #xf4f4fe0d + #xfefffbf2 + #xf3f60609 + #x13140afd + #x80608 + #xa0a0b04 + #x6030207 + #x300fe00 + #xf7fe0809 + #xfd02f6ec + #xf9f90907 + #xf1505fa + #x8090304 + #x9060403 + #xfd070f + #x901f7fc + #xff060905 + #xfd00eff0 + #xfefd0d04 + #x111400fe + #xd040101 + #x602010a + #xfcfd0e10 + #x11fbf2f9 + #x307060a + #xfaf6f0fd + #x10f00 + #x120bfb06 + #x9000200 + #x4000312 + #xf9051209 + #xff2f1f8 + #xfe050815 + #xf5f1ff06 + #x5090afa + #x1002fd0b + #x1020200 + #x2fd0b14 + #xfb0b0e06 + #x6edf1f9 + #xf809111e + #xf2fa0e02 + #xc0e00f3 + #x9fa000e + #xfc090200 + #xfd140d + #x100804 + #xfceeeeff + #xfa131c1d + #xf80911f3 + #x150af0f3 + #xfef80811 + #xfd0f0200 + #xfd011702 + #xa110002 + #xf1edf512 + #x121d1e07 + #x516f4ee + #x10f5f2f8 + #xf4020e17 + #xc0902fe + #x1109fc + #x16030001 + #xf2f1ff14 + #x1a1810fb + #xb0ae9fa + #x2ebfc02 + #xf7070e19 + #xf0904fa + #x70e0100 + #x12ff0205 + #xf8f50612 + #x130c04fb + #x6fcef07 + #xf5f10b06 + #x90b13 + #xc0904f7 + #x7080008 + #xd000605 + #xf9f70e12 + #x20302ff + #xf8fa06 + #xf2001103 + #xa060509 + #x80e03f9 + #x806030c + #xb000301 + #xf6fd180f + #xf90603ff + #xfcfcf7 + #xf90b0d01 + #xeff0000 + #x71503ff + #xc060709 + #x5fdfe00 + #xf90a1e04 + #x10cfefb + #x2f9ede8 + #x20d0909 + #x8f8fffe + #xd190306 + #xb020b07 + #xf9f8fb05 + #x21516f5 + #x1006f6fd + #xfdece1ea + #x60a0f12 + #xf9fffc + #x15160409 + #x5020f09 + #xeef7fe0b + #xd1301ed + #x15f9f407 + #xeae0e0f7 + #x40c1e10 + #xfc01fef7 + #x1c110909 + #x8140f + #xeefb0009 + #xa04f6f4 + #x9f3ff10 + #xe0e2e800 + #x7131fff + #x205f5f8 + #x1d090a06 + #x1101319 + #xf8fd0002 + #xf8fafd + #xfffc0b0d + #xe0ebf1ff + #xc1a1bef + #xc01effe + #x17060803 + #x512121e + #xfdfd01ff + #xf4f703fd + #x2090901 + #xe7f3f3f9 + #x11190ae8 + #x11faf106 + #xe060506 + #xa0f151f + #xf9fe0400 + #xf4fe03f9 + #xe08fcf6 + #xf1f4f1fc + #xe0cfef0 + #xcf8fb0c + #xa08060b + #x50a1b1a + #xf8050802 + #xf900fdfc + #x12fdf1f5 + #xf1f4f606 + #x600fff7 + #x7fe0209 + #xb09080d + #xc1b13 + #xd0a01 + #xfbfaf908 + #x6edeffb + #xeefa020e + #xfdfc05f6 + #x8080202 + #xf080a0b + #xfd0d1712 + #xe1209fc + #xf7f20115 + #xf3ebf7fc + #xf4080b07 + #xfa0005ee + #x120afbff + #xe060a09 + #xfe0f1116 + #x161007f5 + #xf1f10f18 + #xe9f4faf8 + #x3120af9 + #xfc02fbed + #x1802f702 + #xa060a0b + #xd141c + #x141006ee + #xeff51915 + #xedfdf5f5 + #x141100eb + #xfdfceefa + #x16f8fc07 + #x30c090f + #x10c1b18 + #xf1301eb + #xeefa1b13 + #xfafceef8 + #x1709f7e7 + #xf9f2ee0b + #xaf90b09 + #x12090f + #x40f1f0d + #x1115f8ed + #xecfe1c16 + #xf5eefc + #xf02f2e9 + #xf2ebf917 + #x61602 + #x813060b + #x8121d03 + #x160eeff6 + #xe9041e1a + #x1f1f4f9 + #x403f0ed + #xedea0716 + #x1817f9 + #x140f0103 + #xc141203 + #x1700ee03 + #xed0d1f13 + #xf4f7ef + #x5edf0 + #xecef0f0a + #x101f0df6 + #x1800fd01 + #xa0f060d + #xcf8fb0b + #xf9141908 + #xf5f2ea + #x403ebf5 + #xecf30e03 + #x1e1c03f9 + #x10f7fb06 + #x5090517 + #xfd0a0a + #x6120d00 + #xfff2ebf2 + #x6fceefa + #xecf60904 + #x1f1401fc + #x1f6000d + #x2080e17 + #xfe0a0f01 + #x8070503 + #xf9ecef01 + #x3f8f4fb + #xecf70606 + #x1f1005fc + #xfaff0512 + #x50b130c + #x60f07fb + #x3000508 + #xf4edfb0b + #xfffdf7f7 + #xeefa0805 + #x1a1108f8 + #xfd070712 + #x90d0f01 + #x9070000 + #x504 + #xf4f80709 + #xff02f4f0 + #xf2fc0a03 + #x151405f7 + #x709050c + #xa0b0600 + #x2fe040b + #x40000fc + #xfc020803 + #x2ffedf1 + #xf6000d00 + #x171100fd + #xb040208 + #x8050107 + #xf8ff0e0d + #xafcfaf6 + #x2060307 + #xf5edfa + #xfa050bff + #x190afe02 + #x8020007 + #x4000610 + #xf5061209 + #x9f3f4f6 + #x3030416 + #xf9effa02 + #xfe0a08fd + #x16000105 + #x104fe07 + #xff0f0f + #xfa0f0f06 + #xffecf1fb + #xff030f1e + #xf2f807ff + #x80e00f7 + #xcfb0608 + #x7fe09 + #xfd021708 + #x2100a05 + #xf5ebf003 + #xc1a19 + #xf40a08f4 + #x120af6f2 + #xfb0a0c + #x209ff07 + #xfa0917ff + #xc0c0503 + #xf1ecf20e + #xb181f0d + #xff17fced + #x14fbf0f5 + #xf5ff0d13 + #x80b0201 + #xfe0f0efb + #x15070001 + #xedee0512 + #x1a1f16f7 + #x1205e801 + #xeff7fe + #xf907121b + #xf0401f6 + #xa10fb06 + #xc0102fc + #xf1f50d0d + #x191506f5 + #xff4ee10 + #xf1f30206 + #x91515 + #xd08fef4 + #xc08fd0b + #x6000502 + #xf4fa0f0a + #xa0700fc + #x3f0fe11 + #xee010a06 + #x9081104 + #xa0cfbfa + #x904030b + #x4030402 + #xf4001509 + #x302fe + #xfff80202 + #xf90e0802 + #x90209fa + #xb0ffc03 + #x8030907 + #x3020002 + #xf40b1a03 + #x20601fa + #x1fdf5f3 + #x50f0403 + #x4fe02f9 + #x100fff09 + #x9040a04 + #xfdfcfc08 + #x1813f8 + #xd03fcf8 + #xf4e4f2 + #x90a0b0a + #xfcfc00fd + #x180e050c + #x4050a06 + #xf4f8ff0c + #xc1901f0 + #x10f9f8ff + #xf4e6e1ff + #x60b1909 + #xf900fe00 + #x1a0a0b08 + #x90a0f + #xf2fa0209 + #x110df3f2 + #x4f10009 + #xe3e0ea0a + #x5151ffc + #xff02f7fe + #x1a080b02 + #x4100d18 + #xf8fd0302 + #x5fdf5f9 + #xf8f90c0b + #xe0e4f407 + #xd1e18ea + #xbfcf100 + #x14090802 + #xd13111d + #xfbfd0000 + #xf9fafffa + #xfa050e03 + #xe7edf6fe + #x131f06e4 + #xef4f306 + #xd0a0508 + #xe10181c + #xf9ff0001 + #xf50001f7 + #x70a02f7 + #xf1f1f3fd + #x1616f8ea + #x7f2fc0c + #xa09050e + #xb0d1c16 + #xf7020305 + #xfa03faf8 + #xe00f7f3 + #xf3f0f507 + #xc07faf3 + #x1f9040d + #xb080a0f + #x40f1c11 + #xff090604 + #xfdfdf702 + #x6f2f3f7 + #xf1f3ff11 + #x20200f4 + #x2020607 + #xd080c0b + #x3131610 + #x90e06fe + #xf8f5ff0e + #xf4edf8fb + #xf4fe0b0e + #xfc0501ee + #xc060000 + #xd080a08 + #x5121214 + #x111003f6 + #xeff50f12 + #xeaf3fbf9 + #x10a0dfe + #xfe09f7ee + #x1500fdff + #x80a070d + #x60d1516 + #x1010fff3 + #xebfd1810 + #xeff9f7f5 + #xf0f02ee + #x103ecfa + #x11f8ff00 + #x50b0815 + #x50c1d14 + #xf11f9f3 + #xeb05180f + #xfbf8f2f3 + #x150af4e9 + #xf6ed0b + #x4f90801 + #x60d0a17 + #x4101f09 + #x1210f1f5 + #xed0a1615 + #xf0f3f4 + #xf04ecef + #xf6ecfd16 + #xfa061100 + #xd0e0d11 + #x7171a02 + #x1a07eafa + #xee0e171b + #xfeedf8f0 + #x800ebf6 + #xeced0d13 + #xfe1711fa + #x14090a07 + #xc190d03 + #x1bfbec02 + #xf2131c16 + #xf8f2fbe8 + #x4ffecfa + #xe8f61409 + #x101f08f6 + #x17020200 + #x1014020e + #xff2f708 + #xfc191909 + #xf8f7f5e4 + #x7faedfc + #xe9fe0f03 + #x1e1701f5 + #xffbfd06 + #xd0a0619 + #xf90508 + #x7170e00 + #xf9f4ecec + #x9f5f0fe + #xeb000704 + #x1f0f00f5 + #xf8fe10 + #x6061117 + #xfc070c03 + #xb0f0401 + #xf8ebedfc + #x4f2f600 + #xee000508 + #x1f0b03f4 + #xf8fd0519 + #x409170a + #x51004fe + #x404040a + #xf0eafa06 + #xf7f9fc + #xef000706 + #x190d05f1 + #xfd030b1b + #x9101100 + #xe0afcff + #xfe03090a + #xedf40504 + #xfdf7f5 + #xf2010902 + #x161103f1 + #x5060b16 + #xd0e0600 + #x9fffd06 + #x507fe + #xf4010700 + #x4fdf0f2 + #xf5040900 + #x181000f6 + #xa04070f + #xb070006 + #xfafe090b + #x501fff3 + #xff050204 + #x4f2eef8 + #xf9090602 + #x1a0900fa + #x702020f + #x601050d + #xf4080f09 + #x4faf5f3 + #x4010310 + #xfdecf600 + #xff0d0301 + #x140103fc + #x4010012 + #x1000f0d + #xfa110e06 + #xfcf1f0fb + #x1ff0f19 + #xf2f40101 + #x80e00fc + #x90007fe + #x2000012 + #xfc051505 + #x5120a04 + #xf1ecf105 + #x61c15 + #xf30502fa + #xf09faf4 + #xfe000804 + #x601030f + #xfc0f1200 + #xd0d0801 + #xecebf70d + #x6161f06 + #x11f8f4 + #x1100f4f1 + #xf7030b10 + #xa010606 + #x1507fe + #x100705fc + #xecec0012 + #x141e1bfa + #xf0debfc + #x6f1f4f9 + #xf6060f1a + #xe0403fa + #x914fe02 + #xf0302fb + #xecf71109 + #x1d1d07f0 + #x12ecf412 + #xf4f5f90c + #xc1a0f + #xa06fcf4 + #x1104fd0d + #x402ff01 + #xf1fe1005 + #x150ffef5 + #x3e70319 + #xf0ff020d + #x40d18ff + #xb07f6f9 + #xa00040d + #x1040205 + #xf3031006 + #x50400fa + #xfaf40b0c + #xfb0b0406 + #x60d0ef2 + #xd05f703 + #x6020909 + #x3040005 + #xf50c1103 + #x402f7 + #xfdff01fd + #x70d0202 + #x10704f3 + #x1104ff0a + #x6060706 + #x100fe07 + #xff160efd + #x605fff1 + #x1faeff9 + #xe090405 + #xfb01fefe + #x1502090b + #x506030a + #xfbfa000b + #xf1a00f5 + #x8fef9f6 + #xfce8e803 + #x8091108 + #xf900fe03 + #x16060d05 + #x3080311 + #xf6f90509 + #x1710f3f5 + #xf6fc02 + #xede0f10d + #x51419ff + #xfefffd02 + #x140a0d00 + #x50b0819 + #xf8fe0602 + #xffff1f8 + #xf2f9070b + #xe2e0fe0b + #xf1f11ed + #x7faf800 + #x100d0600 + #xc0e0e1c + #xfbff01ff + #xfffaf9fa + #xf2050e04 + #xe4e800ff + #x1a1fffe4 + #x7f2f704 + #xd0c0308 + #x100e1918 + #xfafdfe05 + #xf800fcf7 + #xb07fa + #xedeffafb + #x1d17f2e8 + #xf1fd0a + #xc09060f + #xd0f1d13 + #xf8ff000a + #xfd04f7f8 + #xa05faf2 + #xf2eef703 + #x1809f1f1 + #xf9f7050f + #xc070d10 + #x9131a0f + #xfc030509 + #x1fff500 + #x4f9f5f5 + #xf0ed0010 + #x903faf4 + #xfc00080c + #xb08100a + #x815150f + #x6090402 + #xfdf7fb09 + #xf6f1f6fa + #xf2f60c0f + #x208fcf1 + #x5040602 + #xb0b0c07 + #xa131211 + #xe0c00fc + #xf2f7070f + #xebf3fbfa + #xfb041100 + #x50bf4ef + #xe0100fc + #xa0c080c + #xa0e1413 + #x110dfbfa + #xed011210 + #xeef8faf3 + #x90d06f1 + #xa04eafa + #xbfc00fc + #x90a0917 + #x70d1d10 + #x120af5fd + #xf00c1012 + #xf8f7f6ed + #x110cf7ed + #x6f6ee08 + #xfffc03ff + #xa08101a + #x4141d09 + #x1606f0fd + #xf6110d18 + #xfcf2f5ea + #xf01ecf4 + #xfbedfe13 + #xf6060900 + #xd081712 + #x61a1605 + #x1dffecfe + #xfa11111e + #xf6f0f8e8 + #xaf9edfc + #xeef10f12 + #xfd1309fc + #x11091304 + #x101d0807 + #x1cf4ed00 + #xfd131819 + #xeff5f9e4 + #x7f5f1ff + #xe8fc140b + #xf1905f5 + #x120709ff + #x16160011 + #xfedf505 + #x3191b0b + #xf0fbf2e1 + #x8f1f5fd + #xec070f06 + #x1f1500ef + #xc01ff06 + #x12090319 + #xfff20009 + #xc1a10ff + #xf6f7e9ea + #x7eef7fd + #xf2090409 + #x1f0dfeed + #xfdff12 + #x9041314 + #xfa010707 + #x10130300 + #xf6eee8f8 + #x2eefaff + #xf606020c + #x1c0900ec + #xf9fb051c + #x4091b09 + #x30b0402 + #xb09000a + #xefe9f402 + #xfdf3fefe + #xf7030609 + #x150c00eb + #xfbff111f + #x61113fe + #x1009fb00 + #x203080f + #xe8f20101 + #xfef9fcf7 + #xf6030804 + #x140ffeed + #x204141b + #xe1205fe + #xefff905 + #x70c05 + #xec0005fc + #x2f8f6f1 + #xf8060603 + #x180efcf0 + #x8061016 + #xf090005 + #xfb010b + #x40903f6 + #xf90500fd + #x3f2f2f3 + #xfd090305 + #x1909fcf2 + #x7030915 + #x800030c + #xf6030b0c + #x501f4f4 + #x2010108 + #xfcebf6fc + #x20b0207 + #x120500f4 + #x4000618 + #x1000e0c + #xfd0e0c09 + #xf7ecfd + #xfd0c11 + #xf2f1fe01 + #x80a0201 + #x70402f7 + #x3fd0919 + #xfe081107 + #x9120905 + #xf4eeee07 + #xfb051d0d + #xf10001ff + #x1008fff6 + #xff060200 + #x4fb0e13 + #xff100d03 + #x100e07ff + #xececf80d + #xff151f00 + #xff0afaf9 + #xf01f7f0 + #xfb07050c + #x6fd0e08 + #x7150303 + #x100b05fa + #xe9ee030e + #xb1f18f4 + #xf03effc + #x6f8f1f8 + #xfc070c16 + #x80109fc + #x1012fc07 + #xb0801f9 + #xeaf40e0b + #x191f0def + #x15f3f00c + #xf9f3f507 + #xfe091616 + #xa05fef5 + #x1208fa0c + #x605fefd + #xf0030e05 + #x1f13f9ef + #xfee60518 + #xf4f90015 + #x3161afc + #x902f5fa + #xafd070c + #x400fe0d + #xf5060b04 + #x1206faf4 + #xf1f31115 + #xfc02070b + #x5170eef + #xbfcf701 + #x3000a0c + #x403010a + #xf90a0b05 + #x404fff2 + #xf5020c04 + #x8070500 + #x41100f2 + #xcfa0006 + #x406070b + #x5010008 + #x120902 + #x307feef + #xff01fcfc + #xd050301 + #x207f9ff + #xdfd0906 + #x607020d + #xfc0109 + #xf1602fb + #x604f6f2 + #xffeff101 + #x9050806 + #xfe00fc08 + #xd041002 + #x5050113 + #xfafb0608 + #x180df8f7 + #xfcf500 + #xf2e1f90a + #x70f1004 + #xffff0006 + #xd0b0bfd + #x6050818 + #xf8fe0803 + #x1500f3f9 + #xf5f9fe0d + #xe5e20408 + #xf1c0df7 + #x1fdff00 + #xd0f04fe + #x9071118 + #xfa010401 + #x5f8f7fb + #xf101080d + #xe0ec09fc + #x1b1efde9 + #x3f7fb00 + #xe0f0307 + #xc0c1815 + #xfbfeff06 + #xfcfcfaf8 + #xfd0c0800 + #xe7f400f5 + #x1f14eee7 + #xfaf4fd0d + #xe09090f + #xb0f1b11 + #xf9fb000e + #xff00f5f8 + #x809fdf5 + #xedf2fafe + #x1e07edee + #xf3f80314 + #xd060f0d + #xa14170f + #xfafe050d + #x4fef2fd + #x6fef4f6 + #xedee0009 + #x11fff5f4 + #xf5ff0a14 + #xa091305 + #xc17130e + #x1050707 + #xf6f906 + #xfaf5f4fd + #xecf40e0d + #x803f8f2 + #x50909 + #xa0e0e02 + #xe14110f + #xa070102 + #xf8f7020d + #xeff5f9fc + #xf2021401 + #x907f3f1 + #x60503ff + #xb0e0908 + #xd10140e + #x1006fc03 + #xf1ff0b11 + #xeff9faf4 + #xe0af2 + #xf01ecf6 + #x700fefc + #xc090b14 + #x70e180d + #x1203f803 + #xf60b0c14 + #xf6faf6ea + #xc0efaee + #xcf4f003 + #xfefffe03 + #xb051516 + #x416190b + #x16fdf501 + #xff0f0b1a + #xf8f6f2e6 + #xf03f0f4 + #xffecfe0e + #xf8040206 + #xa071c0e + #x91e1008 + #x19f7f3fe + #x40e101d + #xf1f4f1e7 + #xaf5f1fc + #xeff20e12 + #xff0c0501 + #xc0f1a00 + #x141d050a + #x15eff2fe + #x50e1b17 + #xecf8f0e8 + #x5eff8fd + #xeb00120e + #xf1103f6 + #xc100bfc + #x1a140110 + #x8eaf604 + #x8141e09 + #xeefcebe8 + #x2eefdf8 + #xf10c0d0b + #x1d0ffeec + #xa0aff04 + #x17080715 + #xfaeeff0c + #xf1a15fd + #xf6f8e3ee + #xeefcf6 + #xfb0d040d + #x1f0bfae8 + #x301ff16 + #xa031312 + #xf4fb060d + #x151504fd + #xf9eee3fb + #xfbf0fefa + #x7050d + #x1708f9ea + #xfdfc0b1f + #x1091a07 + #xff050507 + #x120aff08 + #xf1e9ed03 + #xf7f400fc + #xff030a0a + #x1109f8ec + #xfafd151f + #x41313ff + #xc05ff01 + #x8020611 + #xe8effc04 + #xf7fa00f6 + #xfd040a04 + #x120bf6ee + #xff041b1d + #xd1506fc + #x10fdfb03 + #x2060e0a + #xeafd00fe + #xfdfbfbee + #xfd060603 + #x160af5f0 + #x40b1818 + #x110b0002 + #x2f7ff0b + #x50c08fb + #xf604fdfb + #xf5f4ed + #x70306 + #x1807f6f1 + #x6091119 + #xa010309 + #xf8fd070f + #x908f6f6 + #x101fc01 + #xfaeef4f6 + #x407030a + #x1305f8f1 + #x4020f1c + #xff0c0b + #xfd080b0d + #x6fbea00 + #xfd070a + #xf0f2fbff + #x9060703 + #x905f9f8 + #x1fd121a + #xfd081008 + #xa0d0a05 + #xfbeeed0b + #xf8041609 + #xeffb0000 + #xc0505f8 + #x408fa00 + #xfd1512 + #x2110b05 + #x120c07ff + #xefe9f90f + #xf8161dfe + #xfb03fefa + #xd03fcf0 + #x306fd0b + #xff011609 + #xc130306 + #x110a03fb + #xe9ed040e + #x71f14f1 + #xafff6f9 + #x7fcf1f9 + #x3050813 + #x60dff + #x140e0008 + #xd0afffd + #xe9f60c0b + #x181f07eb + #xff0f403 + #xfcf5f009 + #x3081310 + #x30901f9 + #x1605000a + #x906fb05 + #xed000f07 + #x1f19fbed + #x4e60015 + #xf5f6fb14 + #x2101b03 + #x706f6f7 + #xdfe040c + #x602fb0a + #xf8090806 + #x1d04f4ef + #xeaf70f1a + #xf8fc1009 + #x91c0af4 + #x8f9f6fe + #x1010c0b + #x4fd030f + #xfd080706 + #xd01f9f1 + #xed07120f + #x2030dfb + #xd17fbf5 + #x5f5fe02 + #x1060a0d + #x5000408 + #x10c0805 + #x606f9ef + #xfc090401 + #xa0305f9 + #xc08f401 + #x2fb0703 + #x606050e + #x3fe0408 + #xb0f0500 + #x905f3f3 + #xfcfa00 + #x8020401 + #x7fffa0b + #x3040a00 + #x7030611 + #xfdfc0608 + #x170cfdf9 + #x7fdef01 + #xf6eafb05 + #x4070a06 + #x2fd020a + #x60f08fd + #x5010b12 + #xf8000905 + #x1400f8f9 + #xfdf6f710 + #xe5ea0605 + #xe140cfc + #x1ff0202 + #xc1101fd + #x5041312 + #xfa030503 + #x8f7f8fb + #xf6fb0314 + #xe0f60afb + #x1c1a02ed + #xfdfe04 + #xf0c0002 + #x70a1711 + #xfc000106 + #xfdf8fbfa + #xfb06090a + #xe40001f1 + #x1f11f3e4 + #xfaf8fc0f + #x11070809 + #xa111810 + #xfafb010d + #xfffdf7f7 + #x80900fd + #xebfbf8f7 + #x1e02ede9 + #xf2f7021c + #xe071207 + #xb151310 + #xf7fd080d + #x3fbf4f9 + #xb00f5fb + #xedf3fc04 + #x14faf2ef + #xf3fe0a1e + #x90c1300 + #xd17100f + #xfb020b09 + #x1f4f700 + #xf7f301 + #xeaf60909 + #x9fdf8f0 + #xfb040e14 + #x9120dfb + #x1115100d + #x3070506 + #xf8f3000a + #xf5f4f801 + #xec041100 + #xb02f5ee + #x3070707 + #xd110701 + #xf11110d + #xb040008 + #xf4fc080f + #xf2f7fbf8 + #xf8120af4 + #xffff1f0 + #x504ff04 + #xd0a0a0b + #xb12140d + #xefffe08 + #xf8060b12 + #xf6fbf6ec + #x714fbed + #xcf3f1fb + #xfb0a + #xa051412 + #x817140c + #xefafe04 + #x20a0e15 + #xf8f9efe9 + #xe04f2f4 + #xffedfe07 + #xfcff0010 + #x60b1e09 + #xd1d0e0b + #xdf6fcfd + #x8081616 + #xf5f6eaee + #xaf6f4fa + #xf1f30a0f + #x104050a + #x71518fe + #x171b070b + #x9f1f8fc + #x70a1e0f + #xf0f6e8f3 + #x1effcf8 + #xed02110f + #xd0a05f9 + #xb1b0afb + #x1f13040c + #xfeedf705 + #x7111f02 + #xf3f7e5f5 + #xfcf2fff2 + #xf60d0d0d + #x180bffec + #xd13fe05 + #x18070b0f + #xf2effd10 + #xd191af7 + #xfbf3e2f8 + #xf8f6fdef + #x10d090b + #x1a08f7e8 + #x904ff16 + #xb04130e + #xedf70413 + #x151808f6 + #xfeeae200 + #xf5f7faf4 + #x707090a + #x1605f2ee + #x1fb0c1f + #x10b1908 + #xf600090d + #x150c0002 + #xf5e3ea08 + #xf2fafdfa + #x3030f06 + #x1004f1f4 + #xfcff191f + #x5141000 + #x5040402 + #xc02060d + #xebe9f70a + #xf4fe00f6 + #x41000 + #x1104f0f6 + #xfb071f1b + #xc1603fc + #xbfefe00 + #x202110b + #xeaf7ff04 + #xfa00fdec + #x70aff + #x1503f0f5 + #x101d17 + #x130efffe + #x2f7fe07 + #x40c0efd + #xf6fffafe + #xfcfdf4e9 + #x2070502 + #x1600f1f4 + #x6111619 + #xc020204 + #xf6f90610 + #xb0bfef6 + #x1fdf700 + #xf8f6f0f0 + #x5040706 + #x1200f2f6 + #x60a151d + #x1010a07 + #xf7020d0e + #xcfdeeff + #x1f9fe08 + #xf0f3f5fc + #x6030c02 + #xd00f2fb + #x102181c + #xfe080e07 + #x5090d05 + #xedf00b + #xf8000d0a + #xeefaffff + #x8050bf7 + #xa00f303 + #xfc041b12 + #x3100b05 + #xe0b08fd + #xf3e6fd10 + #xf7131502 + #xf70000f9 + #x80600f1 + #xa00f90b + #xfb091608 + #xd110604 + #xf0a02fc + #xe8eb080f + #x61f0ff5 + #x4fffaf4 + #x700f2f7 + #xaff0411 + #xfb100d03 + #x150c0402 + #xd07fd02 + #xe8f70c0d + #x1a1f01ec + #x7f4f5fc + #xf6f107 + #x603100f + #xf02ff + #x12040602 + #xc03fb0b + #xed000c0b + #x1f15f5ea + #xfdecfc0c + #xf9f2fd13 + #x4101604 + #x608f9fd + #xb000904 + #xafdfd13 + #xf6080907 + #x1f09f2ed + #xeef10b19 + #xf6f70c10 + #x51a11f7 + #x9fef6fd + #x2ff0c09 + #x6fd0112 + #x70704 + #x13fcf4f0 + #xec07141d + #xfa0515f4 + #x1715faf8 + #x1f5fa01 + #x80b0b + #xa07 + #x1070805 + #x801f6f2 + #xfb0f0d0c + #x20807f0 + #x1706f300 + #xfcf90004 + #x509090b + #x2000605 + #x70a0801 + #xb02f1f6 + #x404ff03 + #x40400fb + #xffbfa0b + #xfd040405 + #x7040909 + #xfefe0707 + #xf0a03fb + #xcfaed00 + #xfdf7fc05 + #x3030503 + #x5fa040c + #x30d0302 + #x3000e0a + #xf9000907 + #x1103fcf8 + #x5f1f410 + #xebf20307 + #x60b0dff + #x705 + #xb0ffeff + #x3130a + #xf9050804 + #x7fbfafa + #xfbf30317 + #xe2fe0700 + #x151308ee + #x10005 + #x110bfe00 + #x20a150d + #xfd040304 + #xfef8fbfb + #xfaff0c0f + #xe80700f6 + #x1f10fae3 + #xfefdfd13 + #x11040403 + #x6101310 + #xfcff0207 + #xfcfbfaf7 + #x4060702 + #xf104f5f5 + #x1c01eee2 + #xf6f7021e + #xd050d02 + #xd151112 + #xf7fd090b + #xfaf5f5 + #xb01fb00 + #xf2faf700 + #x10f8efea + #xf4fa0e1f + #xa100efb + #x11160f10 + #xf6040d09 + #xf4f6fb + #x5f7f503 + #xedf80208 + #x7f9f5ec + #xfa02141c + #xa1509f7 + #x13130f0b + #xfe090a08 + #xf7f2fd03 + #xfaf1fa05 + #xec050c04 + #x6fef6e9 + #x1090f10 + #x101402fb + #x12110f0a + #x606040a + #xf2f8060a + #xf5f5fefd + #xf71307f8 + #xcfef2e9 + #x506040b + #x100b0604 + #xd110f0c + #x800030b + #xf6010c0c + #xf6faf9f1 + #x614fcf1 + #x9f5f1f2 + #x400ff12 + #xc080f09 + #xc160f0e + #x6fd0304 + #x6100b + #xf9f9eeee + #x1107f3f3 + #xfeeff800 + #xfb0217 + #x60e1707 + #x121b0d0c + #x2fb01fd + #x606180a + #xf8f3e7f6 + #xbf8f5f8 + #xf1f5040c + #x1fe0a0c + #x71c12ff + #x1b180908 + #xfff9fafe + #x40a1f05 + #xf6efe6fe + #xf3fcf6 + #xef010d0f + #x7030afb + #xd1f06fe + #x1f0f0807 + #xf7f4f707 + #x2111ffb + #xf8ede700 + #xf7f9fdf0 + #xf90b100b + #x100902ec + #x1416fc04 + #x19080b09 + #xeef1fb15 + #xa1b16f1 + #xfdeae6ff + #xf4fef8ef + #x50d0e06 + #x1307f6ec + #x12060014 + #xc06100b + #xeaf60518 + #x141c07f0 + #xfee5e702 + #xf4fff4f5 + #x9080f02 + #x1101eef4 + #x8fc0d1d + #x20b120a + #xf0ff0b0f + #x1710fdfa + #xf6e0ed0b + #xf3fef7fb + #x40512ff + #xffeedfd + #xfefe1b1d + #x6150f04 + #xfe050903 + #xd030306 + #xeae3f80f + #xf500fdf9 + #x711fa + #xffbeffe + #xfa0d1f19 + #x111704fd + #x5020100 + #x3021007 + #xe8ef000a + #xf902fcef + #xa0af9 + #x12faf1fb + #xff181e17 + #x150efefb + #x1fbfd05 + #xb12fe + #xf3fafe01 + #xfe01f3e8 + #x30a06fd + #x12faf1f9 + #x8181919 + #xf04ffff + #xf6f8040e + #xa1003f4 + #xfff9f800 + #xfbfbecef + #x5060801 + #xffaf1fb + #xa12191d + #x2010504 + #xf2000e0e + #xe03f5f8 + #xf5f908 + #xf5f5f0fb + #x4050eff + #xcfaf1ff + #x60c1c1b + #xff090a07 + #xfc0a1003 + #x4eff404 + #xf9f8050e + #xf1f6fb00 + #x3090ef6 + #xcf9f304 + #xff0c1c15 + #x5100a04 + #x70d09fa + #xf3e7010c + #xf7090e09 + #xf6fe00f9 + #x60c02f0 + #xcf7f909 + #xfc14170d + #xf100800 + #xb0b02fb + #xe6ec0d0d + #x61b0cfd + #xff00fbf1 + #x805f5f5 + #x9f8020c + #xff170e09 + #x120b06fc + #xa07fd03 + #xe4f90f0c + #x1d1c00ee + #x3fbf1f7 + #x4f9f102 + #x4000e0c + #x5130307 + #x100607fb + #xa00fd10 + #xec020c0b + #x1f10f3e9 + #xfbf2f409 + #xfbf0000d + #x20b1306 + #xa0bfe03 + #x80307fe + #x9fb0115 + #xf6060a09 + #x1f03eeeb + #xedf40219 + #xf4f41109 + #x8180efd + #xafffa00 + #x30704 + #x4f90812 + #xff080704 + #x1afcf2ef + #xe901131f + #xf60018fa + #x121800f7 + #x5f6f900 + #x60a0a + #xfd0a0b + #x1060900 + #x5fbf4f5 + #xfc0d181a + #x1103ea + #x1c03f7fb + #xf9f8fc0b + #x50a0a05 + #xfd040a01 + #x3080a00 + #x8fff3f6 + #x90c0a0a + #x60af8f5 + #x13f7fc05 + #xfa00000e + #x7070a03 + #xfe010705 + #x90a07fc + #xdf8efff + #x4feff0a + #x303fe02 + #x4f80608 + #x108020b + #x3040c01 + #xfa020907 + #xc06fff8 + #x6eff50b + #xf6f7010d + #x2060800 + #xfd000b05 + #xb0a0005 + #x60e03 + #xfa060905 + #x700fafb + #xf9ee0313 + #xeaff0708 + #xc0f0af0 + #xff040504 + #x1205fe00 + #xff0a0f0b + #xff070502 + #xfefbfbfd + #xf5fa100f + #xef0801fd + #x1710fde2 + #x10 + #x11020001 + #x5100f10 + #x20302 + #xfafcfbfa + #xfb050e04 + #xfa06f7f8 + #x1906eee1 + #xfdf8041e + #xc040700 + #xc130f12 + #xfb000505 + #xfdfbf6f4 + #x70402ff + #xfdfbf4ff + #xff9e9e9 + #xf6f8121f + #x80e09fb + #x11120f10 + #xf7050b08 + #xfdf6f2f7 + #x4f9fc03 + #xf4f7fe09 + #x4f8eeed + #xf6021b1d + #xc1603f5 + #x14110f0b + #xfd0c0a0a + #xf8f3f7ff + #xfbf2fe05 + #xf0000807 + #x2fcf2e9 + #xfe0b1a13 + #x1314fff8 + #x13100d0a + #x40a060c + #xf2f70005 + #xf3f502fe + #xf80e08ff + #x6fdf0e5 + #x50a0c0e + #x150c00ff + #x10100b0e + #x604060c + #xf4ff0a06 + #xf4fbfdf3 + #x811fdf6 + #x6f8eced + #x6010613 + #xe070806 + #xf120c10 + #x2010708 + #xfc060f03 + #xf8faf3f1 + #x1206f5f5 + #xfef3effd + #x2fb0915 + #x70f0f06 + #x13130d0d + #xfe020301 + #x1081300 + #xfaf2eaf9 + #xef9f5f9 + #xf3f4fc0a + #xfffc120d + #x91c0e01 + #x1a140d07 + #xfc00fb01 + #xe18fe + #xf8e9ea01 + #xf6faf8 + #xf200080e + #x411fb + #x131f0500 + #x1d0e0a03 + #xf8faf50d + #x11818f8 + #xf7e6ef01 + #xf8fbfaf4 + #xfb090f08 + #x60a06ee + #x1a17ff05 + #x17080805 + #xf2f3fa18 + #x91f0eef + #xf8e4f0fe + #xf601f4f3 + #x50d1000 + #xc09f7ef + #x1a03000f + #xb07090e + #xecf4051c + #x151f00ec + #xf7e2ef00 + #xf900f0f9 + #x90b10fc + #xe00edfa + #xdfb0f18 + #x50c0c10 + #xeefd0f12 + #x1b14f7f4 + #xefe0f209 + #xfafbf4ff + #x50a0ff9 + #xdf7ee03 + #x21c1a + #x7120b0a + #xf9060d03 + #x1206fc00 + #xe5e2fc11 + #xfafcfdfd + #x10d0cf6 + #xcf4f303 + #xfb101f17 + #x11140600 + #x20703fe + #x4030904 + #xe2ec040e + #xfc00fdf2 + #x31006f7 + #xbf4f6fe + #x11d1c16 + #x170dfff9 + #x1fffd06 + #xc0ffe + #xebf60304 + #x2f5ea + #x50d01fa + #xaf5f5fb + #xb1d1a18 + #x1303fdfb + #xf9fa000f + #x81406f3 + #xf9f9fcff + #x1fcebee + #x70904ff + #x8f5f4fe + #x10171a1b + #x6000002 + #xf2fe0c10 + #x100bf7f3 + #xfbf3fa05 + #xfcf2edfb + #x3080afe + #x7f4f401 + #xb121e1b + #x1050607 + #xf7080f04 + #x9f8f4fd + #xf6f4010f + #xf6f1f800 + #x30e0af8 + #x8f3f603 + #x4151e16 + #x50c0805 + #x21009fa + #xf5eb0007 + #xf3ff0d0f + #xf6f900fc + #x71200f1 + #x7f3fc04 + #x2191812 + #xe0f08ff + #x90efffa + #xe4f10c0a + #x20f0e00 + #xfe00fbf2 + #xb0af4f3 + #x2f50306 + #x61b1111 + #x120b06f9 + #xa07fb06 + #xe2fe0f0a + #x181704ef + #x200f0f7 + #x9fdf2fe + #xfefd0b09 + #xc150b0e + #xe0801f8 + #x800ff0f + #xec060d09 + #x1f0df6e5 + #xfdf5ed0a + #xfdf2ff06 + #xfd091007 + #x11090609 + #x807fffe + #x6fc0613 + #xf7080b06 + #x1e00eee7 + #xf2f1fd1c + #xf2f61002 + #x6140d00 + #xd000103 + #x4060004 + #xfb0d10 + #xfe070a01 + #x14f7eeee + #xedfa0f1f + #xf10415f5 + #x141503f9 + #x6f9fd02 + #x208030a + #xfc001007 + #x1060900 + #x7f9f3f4 + #xf5091a1f + #xfb100bea + #x1e0af8f9 + #xfcf6fb07 + #x50a090a + #xfc040c01 + #x20907fe + #x1faf3f9 + #x7101910 + #xb0feff3 + #x10fafbfb + #xf7fa0218 + #xa0a09fe + #xfe070503 + #x50c08fc + #x8f9f2fa + #xb05090b + #x902f202 + #xf80403 + #xff000815 + #x60707fd + #xfc040707 + #xb0a00f9 + #x3f0f504 + #xfffb0511 + #x3020105 + #xf9010b02 + #x9030709 + #x1070700 + #xfb080905 + #x903fafb + #xf7ee010c + #xf4fc0a0e + #x60b07f9 + #xfd080701 + #xe010301 + #xb0708 + #xa0600 + #x1fef900 + #xedf90f0b + #xf5040902 + #x1111fde8 + #x2040209 + #xeff0000 + #x50e0a11 + #x40602ff + #xfdfdfaff + #xf4051004 + #x5fef9 + #x1609ebe7 + #xfb0719 + #x9010201 + #xc100d13 + #x10202 + #xfdfdf8f9 + #xff0909fe + #x3fbf7fc + #x11fce3ef + #xf8fb151f + #x70a05ff + #x1010100f + #xfc030507 + #xfef8f1f8 + #x4000000 + #xfcf3fc06 + #x6f4e8f5 + #xf3051f1e + #xc1301f8 + #x110f100a + #xff0a080b + #xf8f3f1ff + #xfbf80101 + #xf4fb0809 + #xf8edef + #xf9121f12 + #x1610fcf6 + #x100e0c0b + #x60a070f + #xf3f4fa05 + #xf1f906fd + #xf9070a01 + #x3fbece9 + #x312160c + #x1809fbfb + #x100e0910 + #x907070f + #xf3fc0304 + #xf0ff01f3 + #x80d02f8 + #x5f9e6ed + #x8080d0f + #x10050102 + #xf0d0b14 + #x405080c + #xfa040800 + #xf7fef7f0 + #x1205f9f5 + #xf3e7fe + #x1001112 + #xa0b0906 + #x120f0f0f + #x50408 + #xb0aff + #xfaf4eff7 + #x10fbf7f8 + #xf8f2f20c + #xfb00170a + #xb170a04 + #x150f1007 + #x3fd0a + #x10f0cff + #xf8e9efff + #x2f6f9fb + #xf5fa0210 + #xf90a16fb + #x151c0601 + #x170e0b02 + #xfcf712 + #x4190bfb + #xf1e5f6fe + #xf9fcfaf9 + #xfc050e08 + #xff1008f1 + #x1e110003 + #x140a0409 + #xfbf2fc1d + #xd1f04f4 + #xede7f9fa + #xfa00f6f7 + #x40c0ffe + #x80cf8f3 + #x1c030309 + #xd080311 + #xf3f1081e + #x181cf9ee + #xebe7f6fc + #xfffcf2fa + #x90e0cfa + #xd00effe + #x10fd0f11 + #x6090718 + #xeffb1313 + #x1e12f1f2 + #xe6e5f606 + #xf5f7ff + #x70f08f9 + #xbf4f205 + #x41915 + #x90e0b10 + #xf7061006 + #x1905f3fc + #xe1e6fd11 + #xfef5fffc + #x51103f9 + #x6f0f904 + #xfc141e15 + #x11100a02 + #x10a0601 + #x9010003 + #xe0ee0612 + #xfdfc00f2 + #x91200f9 + #x1f2fdff + #x41f1b14 + #x150c02f9 + #x502fc07 + #x2090800 + #xe4f80805 + #x100f8e9 + #xd0ffbfb + #xf6fbfd + #x101e1a16 + #x1103fcfb + #xfefafe12 + #x71203f7 + #xf0fc01fd + #x4fceeeb + #xc09fdff + #xf5f7ff + #x15191b18 + #x9fffb02 + #xf6fc0813 + #x120ff7f2 + #xf6f7fb01 + #xf1eef7 + #x7080201 + #xf3f802 + #x11161f17 + #x1000109 + #xf6070e09 + #xefdf1fa + #xf1f3000d + #xf9ecf8fe + #x50d05fd + #xf2fa02 + #xb1a1f15 + #x5070708 + #x10e06fe + #xfcf2f804 + #xeffa0b10 + #xf5f400fa + #xa12fff7 + #xfef2fe00 + #x91e1c13 + #xb0a0800 + #xc0cfcff + #xe8f5040a + #xf8081101 + #xf9fffdf2 + #x110df4f5 + #xfaf60201 + #xe1d1712 + #xf0b04fb + #xe04f706 + #xe6010b0a + #xe1209ec + #xf0f6 + #xffff1fb + #xf6fd0707 + #x1314130f + #xe09fdfc + #xafefe11 + #xf00a0a07 + #x1e0efbe1 + #xf5ed0b + #x2f4fc02 + #xf8060c09 + #x140b1008 + #xb07f702 + #x5fc0712 + #xfb0b0a03 + #x1c00eee2 + #xf8ebfc1e + #xf4f80a01 + #x2100c03 + #xf040b03 + #x804f809 + #xff00100c + #x80aff + #xef6ecec + #xf0f0101f + #xf1070ef7 + #x111206f9 + #x7ff0202 + #x704fe0d + #xfa061106 + #x709fc + #x1f5eff4 + #xf3001b1d + #xfb1303ec + #x1a0afef3 + #xfffbfd0a + #x806050a + #xfb0b0d01 + #x10808fe + #xfaf3f7 + #x10e1e15 + #x913f4ee + #x18fef9f7 + #xf8f80015 + #x90a0902 + #xfe0a0700 + #x50b04ff + #x3f8f2fa + #xb121509 + #x11feec00 + #xfffcfe02 + #xf9f90f17 + #xa0803fb + #x1060408 + #xa0d01fb + #x3f3f3fe + #x5020b0f + #x6f9fc09 + #xf7010604 + #xff110c + #x50601ff + #xff080807 + #xc06fafd + #xf6f0fc07 + #xf9fe100f + #x3030501 + #xfc090501 + #x7010a00 + #x2080207 + #x20b0601 + #x6fff802 + #xecf90809 + #xf7021103 + #xc0dfef3 + #x4090202 + #x90003fe + #x60a0710 + #x80901fe + #xfcfb04 + #xef070e04 + #x607f6 + #x170aecee + #x400040f + #x5000101 + #xc0d0d12 + #x703ff00 + #xfffcfaff + #xfd0d08fe + #x4fffcf5 + #x14fbe2f6 + #xfaff131b + #x4040301 + #xe0e110e + #x106 + #xfaf4fc + #x30802fe + #xf6fbfe + #x8f0e6fe + #xf3091f1a + #xa0a02fc + #xf0f1109 + #x4050c + #xfcf3ef00 + #xfeff0100 + #xf6f60406 + #xf0eef9 + #xf7161f13 + #x140dfdf4 + #xe0f0d0b + #x608080f + #xf5f0f507 + #xf3fe05fc + #xf6030b01 + #xf5ecef + #x31c1b0b + #x1905f9f6 + #xe0d0a14 + #xb070a10 + #xf3f6ff07 + #xf10203f5 + #x30b08f7 + #x4f5e5f0 + #xb13110c + #x1201fcff + #xe0b0c17 + #x8060a0e + #xf8000303 + #xf702f9f0 + #xf07fef2 + #x2efe2fe + #x508130e + #x9050305 + #xe0b1112 + #x407070d + #xff070202 + #xfbf8f1f4 + #xdfdf9f6 + #xfbecee0d + #xfb091809 + #xc0e0805 + #x100e110a + #x504000e + #x40d0203 + #xf7edf2fa + #x3f9fafa + #xf6f10011 + #xf81117fe + #x16130800 + #x120f0a06 + #x7fbfd14 + #x9140302 + #xedeaf9fb + #xfbfbfcfb + #xf9fe0d0a + #xfe1709f5 + #x1e0f04fd + #x110d020b + #x1f1011c + #x121800fa + #xe6eefbf7 + #xfdfef9f7 + #x2090e00 + #xa10f9f6 + #x1a030401 + #xd080017 + #xf6f00d1c + #x1c16f8f1 + #xe4f0f7fb + #xfaf8f7 + #x80f06fa + #xf01f2ff + #xf000a09 + #x905071d + #xeffa1714 + #x1f0ceff0 + #xe2edf408 + #x1f2fcf8 + #xa0f00fe + #xbf4f606 + #x81310 + #x8081015 + #xf3081508 + #x1b00effa + #xe0ebfb15 + #xfdf302f5 + #xc0ffe00 + #xf1fe05 + #xff141912 + #xd0c0f05 + #xc0804 + #xefbf803 + #xe0ef0617 + #xfbfb03ed + #xf0ffcfe + #xfaf50000 + #x71e1a11 + #x120b07fa + #x604000b + #x4030304 + #xe1fa0c0b + #xfe01fbe5 + #x110bf9fd + #xf8f9fefe + #x141f1a10 + #xf05fcfc + #x2faff13 + #xa0d01fb + #xec000500 + #x3fdf0e5 + #x1006fa00 + #xf9f9fa03 + #x191a1c10 + #x7fff906 + #xf9f90814 + #x120df8f5 + #xf4fdfb00 + #x2f3eeef + #xc05ff04 + #xfaf6f905 + #x16191f10 + #x1fdfe0c + #xf6030f0d + #x1401eff9 + #xf2f5fd0c + #xf9edf7f9 + #x9080103 + #xfbf4fe03 + #x101c1e0f + #x1060b + #xc0803 + #x3f4f305 + #xedf80812 + #xf2f300f6 + #xe0efffc + #xf8f5fe00 + #x111f1d0f + #x7070805 + #xd0afc01 + #xf1f4fd0e + #xf1041104 + #xf4fffeef + #x140af8f6 + #xf4f9ff02 + #x151e1b0e + #xc0a0401 + #x1200f709 + #xec00060e + #x2110cec + #xfe02f3f1 + #x12fff3f9 + #xf3fd0109 + #x1818190a + #xd09fb01 + #xcf8fe11 + #xf6090808 + #x1411fbe0 + #x1f5ef05 + #x6f5fa00 + #xf703060f + #x16111703 + #xc05f508 + #x4fa0811 + #xa0702 + #x1705ece2 + #xfbe8fd1b + #xf9f80303 + #x10b0a09 + #xf0d0ffe + #xbfff70e + #xff000e0e + #x50807fe + #xcf8e5ec + #xf0ea131f + #xf40508fc + #xe0f08fa + #x7090500 + #x9feff0e + #xfc090f08 + #x30705fd + #xf3eaf6 + #xeefe1e1b + #xff11fff2 + #x160c00f0 + #x10009 + #x700060b + #xff0e0b05 + #x10802fe + #xfbf5f0f9 + #xfa0f1f11 + #xe11f0ef + #x1202f9f3 + #xfbfb0214 + #x8040902 + #x20d0605 + #x40b0400 + #x1f9f2f9 + #x815190a + #x1404eafb + #x5fdfafe + #xf8f80c1a + #xa0806fe + #x3090307 + #xb0a0000 + #x2f3f1fe + #xa120f0a + #x7f1f907 + #xfafe000e + #xf902170a + #x704fffc + #x405070b + #xd09fb00 + #xfaf0f604 + #xff04120e + #xfff90607 + #xfc070406 + #xff070efe + #x4030002 + #x40a0805 + #xa00f905 + #xeff5010a + #xf9081502 + #x50703fb + #x6090002 + #x20604fc + #x5060609 + #xa0a02ff + #x3fbfd09 + #xf0020907 + #xfd0d0df5 + #x1107f4f4 + #x9040008 + #x2020000 + #x9080d0e + #xb04fe00 + #xfffc0005 + #xfd0c0600 + #x408feef + #x15fae8f9 + #xb16 + #x10203 + #xc0c120b + #x4fffe06 + #xfffafaff + #x60a01ff + #xfdf9f8 + #x9ecec01 + #xf7081a1b + #x60504fd + #xd0e1108 + #x30b + #xfef5f500 + #x4030000 + #xf9f90000 + #xfeeaf400 + #xfa191f13 + #xd0700f4 + #xd0f0c0a + #x204080d + #xf7edf706 + #xf9000300 + #xf4000800 + #xfbf0f4f5 + #x71f1b0b + #x1504f8f2 + #xe0d0913 + #x8060b0e + #xf1f0ff09 + #xf50402f8 + #xfd0a06f6 + #xfff2e9f1 + #x121b130a + #x1200f7fb + #xc0a0e19 + #x8070d0e + #xf3fa0306 + #xfb04faf2 + #x90afff0 + #xebe5fd + #xd11110d + #x900fe04 + #xb0a1415 + #x6070b0d + #xfc010005 + #xfcf1f3 + #xb02f7f3 + #xfae5ee0c + #x10160b + #x9060605 + #xb0e130b + #x704060e + #x4050008 + #xfaf1f1f9 + #x2fcf8f9 + #xf3e9010f + #xfd161402 + #x120c09ff + #xe120909 + #x8fe0411 + #x9070106 + #xefeff6fb + #xfcfcfcfa + #xf3f70f08 + #x31a0afb + #x1a0c04f8 + #x110e0110 + #x2f50816 + #x100d02fe + #xe5f2f9fa + #xfdfdfdf5 + #xfc040e00 + #x1114fcf9 + #x180700fa + #xf07001a + #xf5f31218 + #x1c0cfdf1 + #xe5f5f401 + #xfafcf0 + #x50d05fe + #x1402f500 + #xc040204 + #xa020a1f + #xebfe1a12 + #x1e05f4ed + #xe7f3f20e + #xfff6fdee + #xc0dfd00 + #xcf6f905 + #x2080a0e + #x7031617 + #xee0a180b + #x18fbeff5 + #xe5edf81c + #xf9f700ec + #x100bfc03 + #xfef30006 + #x1131310 + #x80a1605 + #xfc100d07 + #xcf5f501 + #xe2ef051e + #xf6ff00e6 + #x1208fd00 + #xf5f90203 + #xa1b170d + #xc0d0afc + #x608030a + #x3faff05 + #xe4fa0d12 + #xfa06f9e1 + #x1305fdfe + #xf5fe0005 + #x161d1908 + #xd08fdfe + #x5fd0312 + #x50504ff + #xec020904 + #x104efe0 + #x1001fcff + #xf8fdfb08 + #x1c1b1806 + #x800f709 + #xfaf80b15 + #x100afcf6 + #xf600fe04 + #x1f7ebe7 + #xb00ff05 + #xfaf8fc0b + #x191c1a08 + #x1fbfe11 + #xf501110d + #x1401f2f8 + #xf7f9fa0e + #xfaf0f2f2 + #x9030305 + #xf8f7ff08 + #x141e1b08 + #xfefe060f + #xfc0a0e05 + #x9f4f103 + #xf0f50516 + #xf0f5fcf3 + #xc0703ff + #xf6f8ff04 + #x161f1908 + #x1040909 + #x9090101 + #xf8f1fc0e + #xef00100a + #xf100fcec + #x1307fef6 + #xf4fafd07 + #x1b1f1a06 + #x70a0306 + #xffefc06 + #xf1fa060f + #xfa0f0df4 + #xfb03f3ec + #x12fff8f5 + #xf4fcfe10 + #x1c1d1a02 + #xc09fc09 + #x9f5000d + #xf9030a07 + #xc14fbe3 + #x2f9eefa + #x7f5f8fd + #xf8ff0315 + #x181917fd + #xc04f70e + #xf70a10 + #x3070900 + #x1508e8e6 + #xfce9fc11 + #xfbf70003 + #x40b0f + #x11180ff9 + #xbfcfb11 + #xfb00100e + #x70605fe + #xef8e1f2 + #xefeb131e + #xf7010500 + #xa0b0a00 + #xc1405fd + #x6f8030f + #xfd090f0c + #x50502ff + #x1eee5fb + #xe7ff1f19 + #xc00f4 + #x120c01f2 + #x70aff06 + #x1fb0a09 + #x20e0b0a + #x3060003 + #xfbefedfc + #xf1141f0d + #x100bf4ee + #x1005f7f4 + #x512 + #x2000a03 + #x80d0709 + #x5080005 + #xfef4f1fa + #x21e1a04 + #x16ffedf5 + #x7fef401 + #xfbfb1017 + #x50506fe + #xa08040a + #x90b0003 + #x3f5f1fa + #xc181007 + #xdf2f202 + #xfcfefc0c + #xf7ff1811 + #x80500fd + #x606050c + #xd06fe03 + #xfceef405 + #xa0f0f0b + #xf9f30507 + #xff00060f + #xfb1110fe + #x300fffa + #x6070b09 + #xb01fb07 + #xf2effc0b + #xfe0d1405 + #xfc0108ff + #x6060403 + #x11002f9 + #x2010401 + #xa0a0702 + #x4fbff0b + #xf2fa050b + #x150df7 + #xa06fdf6 + #xc040005 + #x307fd00 + #x5060c05 + #xc050000 + #xfffb0409 + #xfd050605 + #x513ffef + #xffcf2f7 + #x6000411 + #x1010006 + #x90b1007 + #x6fffe04 + #xfefc0201 + #x7070100 + #x605f4f5 + #x7edf200 + #xfd05121b + #x1030501 + #xb0e1005 + #xfffe010a + #xfdf8fcfe + #x803ff01 + #xfdfcf9ff + #xf9e9fb01 + #xff141c17 + #x70600f6 + #xd0f0b07 + #xff01070c + #xf7f1fa01 + #x1000001 + #xf7ff0200 + #xf3effdf9 + #xc1f1b0b + #xc05f8f2 + #xe0d090f + #x3060b0c + #xefef0006 + #xfb0302fd + #xfa0904f8 + #xf8f2f3f2 + #x191e1307 + #xe00f2fa + #xc0a0d17 + #x6080d0c + #xeef60406 + #x4fcf4 + #x50cfcf1 + #xfbebeaf9 + #x1715100a + #x8fdf905 + #x90b1615 + #x60a0d0b + #xf6fe0306 + #x5fef3f3 + #xb07f5f3 + #xf6e3f106 + #xb13140c + #x6000107 + #x910150e + #x6080b0b + #xff000108 + #xf4f1f8 + #x5fff4fa + #xede5020c + #x5181307 + #xc080700 + #xd130b0a + #x7020a0b + #x6000506 + #xf3f0f4fd + #xfffcfafc + #xebf40f07 + #xd1a0bfe + #x130c02f8 + #x1210020f + #xfc0d0e + #x90207fd + #xeaf3f701 + #xfdfefdf4 + #xf3030f00 + #x181300fa + #x150afcf9 + #x11050319 + #xf3fc1312 + #xf0504ef + #xebf6f406 + #xfefceb + #x10d05fe + #x1905fafd + #xd07fa03 + #xaff0e1e + #xe8041911 + #x1603f9e9 + #xeff2f314 + #xfefbf8e8 + #xb0afe01 + #xef9fd03 + #x507010e + #x4021a16 + #xec10170c + #x12faf0f1 + #xeeebfb1e + #xf9fcf8e8 + #xf04ff04 + #xfef60107 + #x50d0c11 + #x30b1908 + #xfa140f08 + #x7f2f100 + #xe8ec091f + #xf503f8e5 + #x10020200 + #xf4fd040a + #xd15150a + #x8100dff + #x70d0608 + #xfef4fd05 + #xe6f81218 + #xfa09f3e1 + #xf0102fa + #xf600000b + #x171a1501 + #xc0cfe01 + #x601060d + #xfefd0400 + #xed020f09 + #x105eae0 + #xc0000fb + #xfbfeff10 + #x1c1c14ff + #xa02f80c + #xfcfd0c10 + #x70501f6 + #xf9030204 + #x4fbe5e4 + #x7fe0002 + #xfdf90012 + #x1b1d1100 + #x2fafe13 + #xf302130d + #xe01f6f5 + #xfcfafc0e + #xfdf3eaee + #x4000505 + #xf9f8020e + #x191f1202 + #xfdfb0813 + #xf90c1105 + #x9f6f2ff + #xf6f50316 + #xf2f5f5f2 + #x70408ff + #xf6fa0209 + #x191f1502 + #xfd030b0e + #x50b0700 + #xfbeffb0b + #xeffc1011 + #xf200f9ee + #xc0504f5 + #xf6fcff0a + #x1d1f1500 + #x409040c + #xb010000 + #xf1f5090b + #xf70b0ffd + #xfc03f1e9 + #xe01fcf2 + #xf8fbff13 + #x1f1f14fd + #xc09fd0f + #x3f80306 + #xf5ff0f02 + #x711feed + #x2fbecf2 + #x7faf8fa + #xfafa0519 + #x1d1f12f9 + #xd01fc13 + #xf8f90a0b + #x50cfb + #x1407e8ed + #xfeedf505 + #xfbf7fd03 + #xfeff0e14 + #x171f0af7 + #x8fa0012 + #xf402100d + #x50506fa + #x13f4e0f9 + #xefee0b15 + #xf7ff0401 + #x5070f02 + #x141c01fc + #x2f7070f + #xfa0a0f0d + #x40400ff + #x6e8e601 + #xe5011e16 + #x704f5 + #xc0c04f6 + #x1011ff05 + #xfdfa0b0a + #x20d0d0c + #x203ff05 + #xfbe7ef01 + #xed191f0d + #xd08fbe9 + #xf07f7f8 + #xa03030e + #xfb000b05 + #xa0b0b09 + #x4040009 + #xfaedf3fd + #x11f1603 + #x12fdf1ec + #xafdf207 + #xff0f14 + #x50601 + #xc070808 + #x9060108 + #xfef0f2fd + #xf1e0d03 + #x9f1f2f9 + #x2f7f915 + #xfa05190f + #x40500fd + #x904080a + #xc070004 + #xffeff201 + #xe140d0a + #xfbef0006 + #xfdfd0314 + #xf90d1402 + #x401fffa + #x6050a0c + #xb01ff06 + #xf2ecfb0c + #x9101107 + #xf4ff0704 + #x1030c02 + #x51603fd + #xf9 + #x70b0c03 + #x5fc000b + #xeef3040e + #x5170efb + #x10902f9 + #x90302ff + #x80bfb01 + #x10405ff + #xb0903ff + #xfefc070a + #xf7ff0808 + #xc17fff3 + #xc01f6f7 + #x8ff020b + #x500fe08 + #x60a0b02 + #x801ff02 + #xfcff0803 + #x3040402 + #xd0bf4f6 + #x5f4f4fe + #xd17 + #x1000407 + #x90e0b02 + #xfd0007 + #xfcfe01fd + #x8010001 + #x6fdf400 + #xf6edfd02 + #xd1b16 + #x30603fd + #xc0f0903 + #xfc00060a + #xf8f8fdff + #x3ff0202 + #xfcfcfe04 + #xeff300fd + #xc1a1c09 + #x906f8f7 + #xe0d0808 + #xff040a0b + #xf0f4ff02 + #x103fe + #xfc0401ff + #xf2f8fbf5 + #x1a1e1500 + #xa00f0fd + #xd0a0c10 + #x3080b0b + #xebf70304 + #x20300f5 + #x40cfbf7 + #xf7f1eff6 + #x1d180f04 + #x7f8f309 + #x90b1513 + #x60b0c0b + #xf1fd0405 + #x6fff7f0 + #xc07f2f7 + #xf2e7f201 + #x14141208 + #x3faff0d + #x911170e + #x70b0c08 + #xf9ff0306 + #x2f6f2f4 + #xafef2fe + #xe9e60009 + #xe161406 + #x5030505 + #xd140e0a + #x7080b07 + #xfffe0704 + #xf7f0f4fc + #x2f9f900 + #xe4f40d07 + #x11190ffd + #xd0a00fc + #x1310060d + #x40b0a + #x1000afb + #xeff1f702 + #xfcfdf8 + #xed040c01 + #x1b1406f5 + #x100af8ff + #x13050815 + #xf5030f0f + #x40506ef + #xf0f3f808 + #xfffaed + #xfd0c0500 + #x1c09fff6 + #xf05f509 + #xbff1019 + #xed091412 + #xa06f9e9 + #xf4f0f912 + #xff00f3e8 + #x90a0001 + #x11fefefe + #x900fe14 + #x1001a15 + #xef13150f + #xbfeecf1 + #xf3ea001c + #xfb00f0ea + #xd030101 + #xfffb0206 + #x8050a13 + #xd1b0b + #xfe170f08 + #x4f5ecfe + #xeaec0e1e + #xfa02efea + #xa0006fe + #xf7ff040c + #xd0d1309 + #x6140d03 + #xa120905 + #xfaf2f806 + #xe5f81a15 + #xfd05ede4 + #x80105f7 + #xf9010410 + #x151612fe + #xe10ff06 + #xa070608 + #xf8fa0201 + #xeb041609 + #x602e6e0 + #x60100f9 + #xfeff0412 + #x1a1a0dfb + #xd03fa0e + #x10b0c + #x102f7 + #xf8070b04 + #x8f9e1e4 + #x400fe00 + #xfffa0613 + #x1c1c09fd + #x5fb0015 + #xf706100b + #x802f8f3 + #xfefe000a + #x1f0e3ee + #x1ff0205 + #xfcf90910 + #x1b1e0a00 + #xfcfa0815 + #xf80e1106 + #x6f9f2fc + #xf7f50513 + #xf7f1edf5 + #x2030800 + #xf7fd090b + #x1d1e0c00 + #xfb010c13 + #x40f09ff + #xfdf1fa06 + #xeffa1112 + #xf4fbf4f2 + #x60706f6 + #xf7fe040a + #x1f1e0ffe + #x1080813 + #xa0701fd + #xf1f30707 + #xf2081303 + #xfe00f1eb + #xa06fdf1 + #xfafa0311 + #x1f1f0dfa + #xa070115 + #x3fe0001 + #xf2ff10fd + #x31003f3 + #x5f9eaee + #x5fff6f9 + #xfaf80a17 + #x1f1f0af9 + #xe000218 + #xf5fd0608 + #xfa080cf4 + #x1306eff1 + #x1efeefd + #xfefaf803 + #xfafd1312 + #x1d1f04f9 + #x8fa0516 + #xf0040c0d + #x10903f4 + #x15f1e4fb + #xf2ed000f + #xf9fc0103 + #xfd061504 + #x1d1dfffb + #xf80a12 + #xf70c0e0e + #x205fefc + #x6e3eb03 + #xe7001516 + #xfe0406f5 + #x50d08f8 + #x1c0ffd02 + #xf9fd0b0f + #x10e0e0b + #x103fe04 + #xf7e2f403 + #xef181b0e + #x807ffe6 + #xc09fafa + #x1303020b + #xf903080b + #x90d0d06 + #x2020109 + #xf2eaf9ff + #x31f1305 + #xe01f2e5 + #xcfcf309 + #x7010e11 + #xfe060407 + #xb0a0c01 + #x5030509 + #xf6eff5fe + #x151f0a02 + #x6f5eef4 + #x4f3fb16 + #xfe07150f + #x2050101 + #x8070b04 + #x9040506 + #xf8edf402 + #x18150807 + #xf9f0f602 + #xfef50815 + #xfd141406 + #x302fffa + #x5070c06 + #xb030004 + #xf5ecf809 + #xe10100a + #xf1f90407 + #xe08 + #x21807fd + #xfff7 + #x50a0e06 + #x6ff0208 + #xe9f1040e + #xc1511ff + #xfc060202 + #x20908f7 + #xf0afd01 + #x3fdfe + #x90e07fd + #xfd070b + #xedfc0a0a + #x111805f5 + #x807f9fb + #x6010000 + #xaffff0a + #x4080102 + #xa07fffe + #xfc010a05 + #xfa020803 + #x160bf7f6 + #x6fbf201 + #xff0a10 + #x2fd060a + #x90c0503 + #x3ffff04 + #xfd0405fe + #x2020300 + #xefcf5ff + #xfaf3f806 + #xfe051713 + #x1020602 + #xc0e0501 + #xfdfe0408 + #xfc00fefc + #x2000300 + #x1f7fd05 + #xeff60004 + #x6161d05 + #x606fcfc + #xe0d0503 + #xfd03080a + #xf5fafd00 + #x5fe + #xfdfe0103 + #xf2fdfdfb + #x151d15fa + #xafff300 + #xd0b090a + #x207090b + #xeffa0003 + #x303f4 + #x205fefe + #xf8faf5f7 + #x1d1a0dfa + #x7f4f40c + #xa0b100f + #x6090a0b + #xf0ff0206 + #x502fbec + #xc04f6fd + #xf5eef1fe + #x19140d02 + #xf3ff14 + #x911160e + #x80b0a09 + #xf7000307 + #x2faf4ef + #xdfaf401 + #xe8eafc09 + #x13161301 + #xfd060d + #xf151109 + #x90b0806 + #xfbff0605 + #xf9f3f3f7 + #x6f5fa03 + #xe3f4070a + #x151812f8 + #x6060204 + #x1411090a + #x5090709 + #xfc0108fe + #xf1f1f8fe + #xfff8fffd + #xeb040905 + #x1b170aed + #xe07f903 + #x1306090f + #xfe070910 + #xfe0702f4 + #xf0f3fc02 + #xfefaf0 + #xfb0b0301 + #x1a0e01ed + #x1000f510 + #x9001214 + #xf70a0e15 + #x409f6ef + #xf3f1ff08 + #xf2ec + #x7080001 + #x1104fdf7 + #xcf9fe18 + #x51a14 + #xf9111212 + #x902e7f5 + #xf2ed0511 + #xffecef + #xa020201 + #x3000003 + #x7fb0c17 + #xff0e1a0e + #x4161009 + #x4f5e602 + #xe8f01315 + #xfffcedf0 + #x60106fe + #xfa00040c + #x906150a + #x5160e08 + #x10130902 + #xfbeff20a + #xe2fd1d11 + #x1fcedea + #x30403f8 + #xfd02070f + #xf110ffe + #xf110209 + #x110b0603 + #xf4f50006 + #xe70b1c04 + #x8fbe7e3 + #x305fdfa + #x10a0f + #x171807fb + #x1106fe10 + #x605070a + #xfa0000fc + #xf60e0fff + #xaf3e1e4 + #x302fa01 + #xfe0d0f + #x1b1803fe + #x6fb0416 + #xfd070c0d + #x303f8f6 + #xff050602 + #x4eae1ee + #x100ff08 + #xfcff0f0b + #x1d160300 + #xfdfa0c18 + #xfd0e0d08 + #x6fceffc + #xfafa060d + #xfae9eaf8 + #x30605 + #xf7010e08 + #x1e180700 + #xfa010f16 + #x5110900 + #xfdf3f506 + #xeffd110e + #xf6f2f3f6 + #x40805fa + #xf9020a07 + #x1f1808fd + #x70c18 + #xb0b01fc + #xf2f30307 + #xef081604 + #xfdfaf2ed + #x809fcf5 + #xfbff070b + #x1f1b08fa + #x706081a + #x702fdff + #xefff0cff + #xfe1109f6 + #x5f7ebec + #x903f3fb + #xf9fb0d10 + #x1f1d04fa + #xa00081b + #xfbff0007 + #xf80b06f3 + #xe09f7f0 + #x2edeaf9 + #x2fbf503 + #xf600160e + #x1f1b01fa + #x6fb0c1b + #xf403060e + #x10dfcf2 + #x10f4ecf6 + #xf6ebf60b + #xfcfb0004 + #xf60a1804 + #x1f15fefb + #xfffb0d19 + #xfa0a0b0f + #x508f6fb + #x2e4f000 + #xebf90b17 + #xfd0106f8 + #xff120dfa + #x1f0bfeff + #xf9fe0b16 + #x40d0d0b + #x303f904 + #xf0e3fa00 + #xf2111811 + #x50800e7 + #x90dfefb + #x19010105 + #xf9030717 + #xa0e0e02 + #x1000008 + #xe7ecfefe + #x61e1505 + #xa04f0e5 + #xcfff806 + #xc000a0d + #xff060612 + #xb0d0bfd + #x3020608 + #xebf2fbfd + #x1a1c0bff + #x6f9e5f3 + #x4f3ff12 + #x109130f + #x4050407 + #x80c09fe + #x5040705 + #xf1f0f600 + #x1f120802 + #xfaf1ec06 + #xfaf50d12 + #x113120a + #x40200fe + #x50c0a02 + #x7040403 + #xf0ecf908 + #x170c0d05 + #xf2f6fa0d + #xf7001405 + #x8170a02 + #x100fef9 + #x50d0c02 + #x7000105 + #xebee010d + #xc111102 + #xf6020407 + #xff080df9 + #x101100ff + #x1fcfc + #x80f0bff + #x100050b + #xe7fb0b0a + #x13170af2 + #x505fc05 + #x408fff9 + #xefe0004 + #x401fb09 + #xe0bfffd + #xfe020a0a + #xf2030a04 + #x190ffdf0 + #x9fff306 + #x1000207 + #x3f9070b + #x9060008 + #x901fc02 + #x70701 + #xfd0504ff + #x12fef7f9 + #xfff5f60f + #xfc03110d + #xff010b05 + #xc090203 + #xfd0107 + #x500fc + #x202fe + #x6f5fd01 + #xf5f6ff0e + #x121904 + #x30503ff + #xd0a0201 + #xfd00070a + #xfdfffbfe + #xfd0204fc + #xfcfa0403 + #xf4fd0002 + #xe1e14f6 + #x900f800 + #xe090306 + #x6090b + #xf6fcfe03 + #xfe0503f5 + #x10100 + #xfafef9fc + #x1a1d0af5 + #x6f4f80c + #xb0a0a0c + #x508090b + #xf5fe0006 + #x206fded + #x700fb00 + #xfaf6f3ff + #x1b1606fb + #xffef0115 + #xa0e100d + #x809090a + #xf8000108 + #x300f3ea + #xbf8fa03 + #xefeef808 + #x15140cfe + #xfaf70b15 + #xe141108 + #xa0a0807 + #xfbff0409 + #xfcf7f1f2 + #x5f2fe05 + #xe6f4030e + #x161910f3 + #xff03070c + #x14120c05 + #xa08040a + #xfb010505 + #xf3f3f5f9 + #xfef602ff + #xec00080a + #x1a1b0ae7 + #x905ff0b + #x13090a09 + #x6060511 + #xfd0700fe + #xf0f4fcfb + #xfdfdfff5 + #xfb090404 + #x1b15ffe6 + #xefcfb13 + #x9030f11 + #x1070c17 + #x409f3f9 + #xf1f500fe + #xf4f0 + #x7070102 + #x130af8f2 + #xaf3031b + #xff061613 + #x20c1113 + #xa01e7fe + #xeef50504 + #x1fbeef2 + #x9020202 + #x802fa01 + #x3f50f17 + #xfe101711 + #xa111208 + #x9f3e508 + #xe6f80f0c + #x1f5eff3 + #x4000500 + #x1020b + #x1160c + #x718110c + #x13120c00 + #xfdebf10f + #xe103190b + #x2f3f1ec + #x10602fe + #x3090b + #x8101000 + #x1112060a + #x150d0501 + #xf5efff0d + #xe7101903 + #x5f3ede4 + #x407fbff + #x2030c09 + #x121606fc + #x1106040e + #xd060408 + #xf6fa0203 + #xf61610fa + #x7eee4e1 + #x604f706 + #x40f08 + #x1912feff + #x8fe0814 + #x305090f + #x1f8fd + #xe06fc + #x2e6e2ec + #x4fffd0c + #xfc051107 + #x1c0f0001 + #xfdfd0f18 + #x10a0c0b + #x6fdf000 + #xff030504 + #xf9e3e9f6 + #x100050a + #xf9091004 + #x1d0e0500 + #xf802121a + #x80e0901 + #xf2f208 + #xf3000d0c + #xf3e9f4f7 + #x3070700 + #xfa090c03 + #x1d1206fb + #xfe080f1a + #xf0c02fb + #xf4f1ff0b + #xef0a1404 + #xf8f3f5ef + #x90bfef9 + #xfd050905 + #x1f1403fa + #x5070e1c + #xc03fcff + #xf0fc0804 + #xfb130ef7 + #xf5eeea + #xc04f3fd + #xfb020c0a + #x1f1601fb + #x703101e + #x2fdfb06 + #xf70903fa + #xb0ffeee + #xeee9f3 + #x7faf406 + #xf405140c + #x1f1400fb + #x2ff111d + #xfbfe030e + #x30df5f7 + #xdfcf2f1 + #xf6e8f206 + #xf70007 + #xf50f1605 + #x1f0ffff9 + #xfc00111c + #xfe030a0f + #xa06effe + #xffecf3fa + #xedf00313 + #xfcfe08fc + #xfe170efe + #x1e08fef8 + #xf9020e1c + #x6090e09 + #x8fff306 + #xeae9fcff + #xf1041611 + #x10701ec + #xa1300fb + #x180200fe + #xfb040b1e + #xb0c0d00 + #x3fefd09 + #xe1f200fd + #x5161802 + #x906efe9 + #xe03fb04 + #xd000607 + #xff040b1c + #xc0e09fb + #x1000509 + #xe5f8fcfc + #x19180ff8 + #x9fce1f7 + #x5f7010d + #x4070d0d + #x2030b12 + #xb0e05fc + #x3040608 + #xeef6f700 + #x1f1008f8 + #xffefe50c + #xf8f80f0d + #x412120b + #x4010703 + #xa0d0300 + #x6060406 + #xeeeff904 + #x170b0bfd + #xf5eff615 + #xf2041602 + #xd160d02 + #x10000fe + #x90e0702 + #x6040206 + #xe8ef0009 + #xf0f10fd + #xf6fa0110 + #xf80f10f6 + #x130f04fe + #xfb00 + #xb1107ff + #x3000309 + #xe6f8080c + #xf160ef6 + #x50007 + #x10e02f4 + #x12030001 + #x201fa06 + #xe1102fb + #x30710 + #xf0040a05 + #x1914ffe9 + #x8fdfb0d + #x703fa02 + #x3fc0404 + #x5fe000c + #x1202f902 + #x2080808 + #xfc070500 + #x1506f7ef + #x2f4fa14 + #xfe00070c + #xfc000b06 + #x8020306 + #x6fbff08 + #x50701ff + #x401ff + #x6fafafa + #xf8f30315 + #xfd0d1205 + #x808ff + #xb050201 + #xfefe050a + #x301fcfd + #xff0201ff + #xfcfa0100 + #xf6fa080b + #xa1b0ffa + #x60500fd + #xc050203 + #xfe03080b + #xfdfdfc01 + #xfe0601fa + #xfb0004fe + #xfcff01ff + #x191d04f4 + #x5f8fb06 + #xb06050a + #x307090c + #xfafc0005 + #x208fcf2 + #x20100fe + #xfdfaf8ff + #x1d14fffa + #xfcf10313 + #xb0a0c0c + #x707090b + #xfbfe0207 + #x602f2ef + #x5fafe01 + #xf7f3f807 + #x190f03fd + #xf4f70d17 + #xd0f0f06 + #x8080809 + #xfcff0309 + #x1f9ecf2 + #x1f30104 + #xedf3010e + #x151509f4 + #xf8010e13 + #x12120d00 + #xa07050a + #xfc00050a + #xf9f3f0f6 + #xfaf80500 + #xeefd0a0b + #x1a1b04e7 + #x203060f + #x120d0903 + #xa030412 + #xfd040105 + #xf2f5f7f7 + #xf8ff02f7 + #xfa050a04 + #x1e17f9e5 + #xbfc0115 + #xb070b0b + #x6020a17 + #x406f801 + #xf1f8fcf8 + #xfe00f9f1 + #x5050501 + #x1a0cf0f0 + #x6f2091b + #x2091013 + #x4061512 + #xcfeee03 + #xeffafffe + #x1faf2f2 + #x7010402 + #x1002f300 + #xfdf61419 + #x111411 + #x90e1506 + #xaf0ec0a + #xeafe0607 + #x1f2f2f2 + #x3020403 + #x7fffd09 + #xfa02170e + #x616120b + #x10120ffd + #xfee5f611 + #xe6050f0c + #xfef0f5eb + #x2050202 + #x4020809 + #x111002 + #x11140c07 + #x140e05fe + #xf2ea0310 + #xed121205 + #xfef2f1e2 + #x506fc03 + #x4060c04 + #xd1504ff + #x12090808 + #xf070208 + #xf1f60709 + #xfc190cfc + #xf0e7e0 + #x901fa08 + #x2090d04 + #x1710ff00 + #x9010b0f + #x704070f + #xfbfeff01 + #x91302f8 + #xfde8e1e8 + #x7fdff0d + #xff0c0d06 + #x19070002 + #xfd000f17 + #x3070d0c + #x3faf503 + #x6080000 + #xf4e2e7f5 + #x2fd080b + #xfe0e0d05 + #x180704ff + #xf905131b + #x80b0c02 + #xf1f50a + #xfc030608 + #xeee6f2f8 + #x1030b02 + #xf0a03 + #x180b04fc + #xfd09141d + #xe0b04fa + #xf6eeff0e + #xf4090f07 + #xeff0f7f0 + #x80903fa + #x10b0702 + #x1a0f00fa + #x30a121e + #xe04fcfb + #xf0f70709 + #xfd140efa + #xf9f5f0e8 + #xd04f9fc + #x60808 + #x1d0ffffc + #x507141e + #x6fcfb04 + #xf6040400 + #xb1200ef + #xfdf1e8ef + #xbfaf904 + #xfa090e0c + #x1f0efffb + #x205161f + #xfff9010b + #x409f9fb + #xf03f3ef + #xf6e9ed00 + #xf40308 + #xf811120a + #x1e0bfff7 + #xfd06141f + #xfdfe0b0b + #xd00f0ff + #x1f4f1f9 + #xeceb000e + #xfafb0bfe + #x1170d03 + #x1b06fdf3 + #xfb07131f + #x2051005 + #xaf7f305 + #xedeff700 + #xedfb110b + #xfe0604f1 + #xe1403ff + #x1703fbf7 + #xfd06121f + #x80b0ffe + #x2f5fe0a + #xe2f6fd01 + #xfe0e18fd + #x808f2ec + #x1308fd01 + #xd02ff01 + #x4131f + #xa0d08fa + #xfb040b + #xe8fcfbff + #x11170fef + #xcfbe2f9 + #x9fc010a + #x507070b + #x1041516 + #xc0d02fc + #x101060b + #xf1faf700 + #x1a1305ed + #x4ece50d + #xf9fb0c0d + #x60e0f0a + #x41009 + #xd0c0000 + #x505040b + #xf3f3f803 + #x150d04f4 + #xf7e7f819 + #xf1091304 + #xe140f00 + #x20502 + #xd0a0202 + #x604020b + #xebf1fe07 + #xe0e09f6 + #xf3f10716 + #xf9140df9 + #x141107f8 + #xff00fe05 + #xf0d0400 + #x502020d + #xe6f70508 + #xd150af0 + #xfbfd080d + #x51300f5 + #x130601fa + #xfefc0d + #x120e00fe + #x1010511 + #xec010a08 + #x151803ea + #x500fd0a + #x907f8fc + #x9fd0102 + #x3fefd0f + #x1409faff + #x2050b10 + #xfc070702 + #x180df2e9 + #x1f60115 + #x4fd000b + #xfc020604 + #x2fe0705 + #xcf9fd07 + #x6080703 + #x2050200 + #xc00f3f4 + #xf8f10a18 + #xfe050c0b + #xfd0a08ff + #x4010500 + #xfffa050a + #x70300fd + #x20002 + #xfefdfcfc + #xf3f9100e + #x7140cff + #x50a01fa + #x7030200 + #xfc01090b + #x1fdfdff + #x30000 + #xfb0100fd + #xf8000b01 + #x181902f8 + #x501fc01 + #x9030306 + #x6090b + #xfcfb0004 + #x406fcfa + #x400fc + #xfeff00fd + #x1f10fbfb + #xfcf8000f + #x9060909 + #x507090c + #xfbfd0306 + #x902f2f5 + #x2fffe00 + #xfaf7fd03 + #x1b09feff + #xf2fa0c18 + #xb0b0e03 + #x607090b + #xfcff0407 + #x8f9ecf6 + #xfefa0103 + #xf2f4030a + #x160c03fa + #xf3041217 + #xf0f0cfb + #x706080c + #xfc000609 + #xfff1edf7 + #xf6fb0402 + #xeffa0c08 + #x181601ed + #xfd080e13 + #x110f08fb + #x8030710 + #xfd020707 + #xf6f1f2f7 + #xf60102fb + #xf7020e00 + #x1f15f4e8 + #x5000916 + #xd0b0605 + #x5010c13 + #x1030003 + #xf3f6f6f7 + #xfc04fcf4 + #x50afe + #x1f0aebf1 + #x3f80b1b + #x50a0a0e + #x105150f + #x8fdf902 + #xf3faf7fd + #x1fef5f1 + #x3030600 + #x18feed00 + #xf8fa141b + #x40f120f + #x30e1704 + #x6eff807 + #xf1fcfd08 + #xfff4f4f1 + #x1030503 + #xdfafa07 + #xf4071813 + #xa141306 + #x9130ffc + #xfbe6fe0e + #xf001060f + #xfaf2f6ea + #x1050404 + #x7fe0505 + #xfb141109 + #x10131000 + #xf1105fe + #xede80810 + #xf60c0d0a + #xf8f5f1e2 + #x6060104 + #x5050902 + #xa160603 + #x110d0b01 + #xe0a0006 + #xeaf50c0a + #x31509fd + #xf8f5e7e2 + #x9000004 + #x40b0803 + #x140d0003 + #xa060a09 + #x803060f + #xf3fe0604 + #xf1401f6 + #xf8ede1ea + #x6fa0509 + #x40d0807 + #x16040103 + #x1050d13 + #x3040d0d + #xfffcfc02 + #x1008fcfc + #xf2e4e2f6 + #xfb0d08 + #x40f0908 + #x12020400 + #xfb08121a + #x40a0e01 + #xfef2fb08 + #x4020105 + #xeae5effc + #xff021000 + #x70f0805 + #x100702fd + #xff0c151b + #xa0c06f9 + #xf5ee010d + #xfd060907 + #xeaeff6f5 + #x4080af8 + #xa0d0503 + #x130bfffc + #x40d171b + #xc06fefa + #xedf40a0b + #x100cfe + #xf1f7f1eb + #xb05fff7 + #x6080406 + #x180cfdfe + #x60c161c + #x7fdfb00 + #xf3000902 + #xd1202f1 + #xf8f4e7ee + #x9fcfefe + #x108090d + #x1b08fffd + #x30b181e + #xfef90005 + #x500fc + #x1308f5f1 + #xf6ebe8fe + #xf60503 + #xe0e0f + #x1b08fff8 + #xc171f + #xf9fc0a06 + #xafff7fc + #x8f9eefb + #xede8f90b + #xf7fc0dff + #x7140d08 + #x1707fbf2 + #xc171f + #xfb040f00 + #x7f2f900 + #xf5f1f406 + #xeaf60c09 + #xfb0607f2 + #x13140600 + #x1404f6f6 + #x10a191f + #xb0efb + #xfff00005 + #xeaf4fa09 + #xf50913f9 + #x408f7ed + #x17090000 + #xe02f701 + #x81b1e + #x50e09fa + #xf9f70609 + #xeefbfc04 + #x8170ae9 + #xcfde8f6 + #xeff0007 + #x704000d + #x71e18 + #xa0d01fb + #xfcff070c + #xf7faf901 + #x1417fee7 + #x5eaea08 + #xfefe0a0e + #x70a0a0b + #xff09180c + #xd09ff00 + #x103060d + #xf9f4f802 + #x1411faee + #xf7e3fc16 + #xf607100b + #xd100e00 + #xff090c05 + #xe060001 + #x503050e + #xf1f1fd05 + #xe0efff4 + #xeceb0e16 + #xfd130cff + #x141207f5 + #xff040209 + #xf070200 + #x5010510 + #xeaf60308 + #xd1302ee + #xf2fa100e + #xb1301f7 + #x140cfef5 + #xffff0010 + #x120900fe + #x2000715 + #xedff0707 + #x1317fee7 + #xfe00080b + #x1108f8fc + #xc03fdfe + #xfd0412 + #x1504fc00 + #x1030a14 + #xf8050804 + #x1a14f5e7 + #x3fa0010 + #xafefa07 + #x305 + #x1fd060c + #x11fcfa04 + #x4070f06 + #x2050402 + #x1500ebf3 + #xf7f70d19 + #xff090a + #xfe080503 + #x208fe + #xfdf90507 + #x70606fb + #x1010205 + #x5fbf4fc + #xeffc1612 + #x20b0d01 + #x50e01fa + #x20303fc + #xf8000a08 + #x300fffd + #x10205 + #xff00fcfd + #xf4051104 + #x141204f8 + #x906f9ff + #x4020102 + #xfe060909 + #xfefd0002 + #x303ff01 + #x3fdfc + #xfc0605fd + #x1d0dfcf9 + #x1fdfd0d + #x6030606 + #x407090b + #xfafd0205 + #xa00f8fc + #x302fbff + #xfdfefe00 + #x1c03fcff + #xf7fc0819 + #x7070c02 + #x5060a0b + #xfb000405 + #xaf7f1fa + #xfefe05 + #xf6f80305 + #x140401fe + #xf404121a + #xb0d0bf9 + #x5060a0c + #xfc000606 + #x2eff0fa + #xf9000306 + #xf0fb0b03 + #x130c00f4 + #xfc0b1317 + #xf0f04f5 + #x5050a0e + #xfc020805 + #xf8edf3f9 + #xf7040300 + #xf4040ffc + #x1d0ff5ec + #x4070e17 + #x100b00fe + #x3030d11 + #x40701 + #xf4f2f3f8 + #xfd05fdf8 + #xfd080af9 + #x1f04eaf1 + #x100101c + #xb090508 + #xfe07140d + #x30002ff + #xf5f6f3fd + #x300f7f4 + #x10704fd + #x1bf8ecfd + #xf700141f + #x70b0f09 + #xff111605 + #x1f5fe01 + #xf7f7f808 + #xf8f4f2 + #x1060302 + #xff3f803 + #xf30a191c + #xa101400 + #x5180cfe + #xf5ed0109 + #xf7fb010f + #xf9f5f4ee + #x1060503 + #x5fb0402 + #xfb151312 + #x111310f9 + #xd150300 + #xe9ee090e + #xfa030b09 + #xf5f9efe7 + #x4050500 + #x3040700 + #x8150b0b + #x12100afb + #x100bff08 + #xe5f80e0c + #x40d0cfb + #xf7fae5e6 + #x7020400 + #x50a0503 + #x140c0507 + #xd0b0504 + #xa04030f + #xee000a05 + #x110f03f2 + #xf8f0e0ef + #x4fe0801 + #x80b0509 + #x12020405 + #x5080810 + #x3040b0c + #xf9000201 + #x1308fcf5 + #xf3e5e2fc + #xfeff0e02 + #xb0c070b + #xd010402 + #x10a0f18 + #x20a0d02 + #xfcf8ff05 + #xc00fd00 + #xeae2ec03 + #xfa0412fd + #xd0c0905 + #xa060200 + #x20d1517 + #x70e06fa + #xf3f2030a + #x2010605 + #xe7ecf5fe + #x10c0cf4 + #xe0b0601 + #xd09fe00 + #x6101816 + #xb09fef9 + #xebf60b0a + #x10a0afd + #xeef6f2f4 + #x90a02f1 + #xc080405 + #x1207fc02 + #x8101817 + #x700fafe + #xee000d03 + #xc1004f1 + #xf7f7e8f3 + #x900fef7 + #x606060d + #x1505fe01 + #x810181b + #xfef9fe02 + #xfb0505fb + #x1409f7f0 + #xf8ebe6ff + #xfffa03fe + #x5090c10 + #x1604fefc + #x610191f + #xf6fd0602 + #x400fef7 + #xefbeffb + #xf0e6f40b + #xf7fe0bfd + #xa0f100a + #x1406faf7 + #x40f1b1f + #xf6050bff + #x3f6fcfa + #xfef0f309 + #xe9f0070c + #xf90909f4 + #x13110aff + #x1204f2f9 + #x50d1d1f + #xfb0e08fb + #xf8f100ff + #xf1f1fc0c + #xf0050dfb + #x40cfbec + #x170b03fc + #xe00f105 + #x40d1f1c + #x21004fc + #xf2f70504 + #xf2f60007 + #x1605ec + #xb00eef1 + #x10020103 + #xafdfb10 + #x10f1f16 + #x80d00fd + #xf5ff0609 + #xfaf9fe00 + #x1219f6e8 + #x5eeee01 + #x2ff070e + #x8010811 + #x121d0f + #xc09fefe + #xfd03070c + #xfcf5fc00 + #x150ff0f0 + #xf5e5fe0f + #xfa060f0e + #xc0b0e03 + #x1111009 + #xd0400fe + #x203090d + #xf4f1fe02 + #x1109f5f6 + #xe8ec0f13 + #x100e04 + #x121106f7 + #x20b060a + #xb0401fd + #x301090e + #xecf40207 + #xe0bfbf3 + #xe9fc150d + #xf1204f7 + #x150efaf5 + #x30411 + #xd0600fc + #x1000b13 + #xedfc0607 + #x1412f8e9 + #xf6040c0a + #x1609fbf7 + #xf06f600 + #xff000913 + #x1003fefd + #x20f14 + #xf6020705 + #x1a0fefe6 + #xfe00060f + #x10fdfa00 + #x501fd09 + #xfe000d0d + #xefcfc00 + #x306110c + #x60602 + #x1905eaee + #xfbf70816 + #x3fa030b + #xfd040507 + #xff010b03 + #x3f70106 + #x60a0dfa + #x40405 + #xdf5effc + #xf1001518 + #xfe060eff + #x5090300 + #x502fd + #xf5000902 + #x50501f9 + #xff010508 + #x2f8f9fe + #xf20b150b + #xa0f09f4 + #xc09fafd + #x204ff00 + #xfb070904 + #xfe00 + #x20405 + #x2fffcfd + #xfd0d0800 + #x180cfff4 + #x8fef90b + #x3030206 + #x3080807 + #xfcff0004 + #x600ffff + #x400fa00 + #x106ffff + #x1603fcfa + #xfefa051a + #x4060703 + #x6060909 + #xfc000304 + #x8f9f9fb + #x3fefc05 + #xfcfe0003 + #xe0000fe + #xf701131d + #x70b08f9 + #x4060b09 + #xfd010303 + #xf1f6fb + #xfefe020a + #xf5fe0801 + #xd0601f8 + #xfd0b1618 + #xd0d00f3 + #x3070c0b + #xfd020503 + #xf6eef7fa + #xfc030607 + #xf5040bfb + #x1409faf1 + #x40d1316 + #x100afbf9 + #x3070d0e + #xfe050700 + #xf1f0f6f7 + #x602fe + #xfd0d06f6 + #x1d01eef0 + #x406121c + #xd05fe03 + #x9110f + #x10403fc + #xf3f2f3fc + #x400fbf7 + #x30c00fc + #x19f5edf8 + #xfc06181f + #xa070a05 + #xfe111209 + #xfeffff + #xf6f1f603 + #x3faf6f5 + #x408ff02 + #xcf0f7ff + #xf60b1b1f + #xa0d11fd + #x5180c03 + #xf7f7ff08 + #xf7f30009 + #xfbf7f4f3 + #x4070403 + #xf70200 + #xfd141b1a + #xe120df4 + #x11150003 + #xeaf6050f + #xf9fd0c04 + #xf7f9efef + #x50607ff + #xff0204ff + #xa14120f + #x111204f7 + #x150afd0a + #xe6fd0b0f + #x80ff6 + #xf9f8e6ee + #x60507fb + #x3080302 + #x120c0c09 + #x100dff02 + #x1002000f + #xed050a08 + #xa0e06ea + #xfcefe0f5 + #x30206fc + #x9090309 + #x11040807 + #xb09020e + #x702090e + #xf8050302 + #x1109fced + #xf7e3e401 + #xfd030aff + #xd07070a + #x9030606 + #x6090c14 + #x3090b04 + #xfcff0003 + #xc00faf8 + #xede0ee0a + #xfc0a0cfc + #xe080a05 + #x6050306 + #x60c1414 + #x70e05fe + #xf4f80109 + #x2fe02ff + #xe6e6f907 + #xf09f3 + #xf0a08fe + #x906ff06 + #x9101810 + #xc0afcfc + #xecfa090a + #x509f9 + #xecf3f7fd + #x90f00ed + #xd080401 + #xe04fe08 + #xb121711 + #xa02f8ff + #xee020c05 + #x70d05ef + #xf5f4edf9 + #xb07fbf1 + #xa050509 + #x10000008 + #xb131616 + #x1fbfb03 + #xf80809fb + #x120bf9eb + #xf9eae901 + #x200fefa + #x6060b0f + #x10010002 + #xb12171b + #xf8fc0103 + #x205fff5 + #xefdf0f6 + #xf1e2f40d + #xf90104fd + #x90c1108 + #xf03fbfd + #xa111c1c + #xf6040501 + #x1fdfaf7 + #x1f1f304 + #xe9ea040f + #xfa0a05f6 + #x10100ffd + #xf02f4ff + #x8111f1c + #xfb0b0300 + #xf8f7fbfd + #xf4ee0009 + #xebff0c03 + #x50ffdec + #x140e05f7 + #xefbf108 + #x6111f1a + #x40eff00 + #xf0fbfe03 + #xf1f50602 + #xfc1002f3 + #xd04f1ed + #xe070100 + #xaf5fb13 + #x4141f18 + #xb0cfd00 + #xf2000108 + #xf6fa05f9 + #xe12f4ed + #x8f4effa + #x502040c + #x6f70813 + #x51a1e12 + #xe06fdfe + #xfb04050c + #xfaf800f8 + #x1707ebf4 + #xf6e9fa09 + #xfe050e11 + #x7030e08 + #x81a150c + #xd04fefc + #x4090b + #xf4f5fffd + #x14fef1fa + #xe7f10b11 + #x10d1103 + #xe0e07fb + #x9110a0c + #xa03fffb + #x40c0b + #xecf60202 + #x1000f9f7 + #xe6001210 + #xe110af4 + #x140efaf9 + #x6080811 + #x904fffb + #x30e0d + #xebfc0604 + #x1206f7ed + #xf30a0d0d + #x160affee + #x1204f303 + #x2040c14 + #xb03fcfc + #xff05120f + #xf4010803 + #x1907eee8 + #xfd070610 + #x1000fbf7 + #xafdfa0f + #x40f10 + #x9fefbfd + #x8150a + #xfd040702 + #x1affe8ee + #xfc000818 + #x3fa0001 + #x3ff030f + #x60d06 + #x1faff00 + #x50a12ff + #x50503 + #x13f6ebf9 + #xf4ff111a + #xfc000b03 + #x1070604 + #x506ff + #xf6fd0602 + #x70c03f7 + #xff040606 + #x2f0f8fd + #xf60c1714 + #x10f09f1 + #xb0600fe + #x304fd02 + #xfa070600 + #x405fcff + #xff040806 + #xfff8fcfc + #x130e08 + #xf0f00ed + #xcfefa05 + #x302fe08 + #x3090502 + #xff00ff04 + #x2040400 + #x2fdfbfe + #x70b0103 + #x1206faf6 + #x2f60316 + #x4030308 + #x7070705 + #xff010104 + #x3fefffc + #x3fcfd05 + #x301ff04 + #xa00fefd + #xfbfb121c + #x6080400 + #x4060907 + #x20202 + #xfdf6fbfa + #xfb030b + #xfaff0404 + #x50301fb + #xfc081b18 + #xb0afff7 + #x2080b08 + #xff020202 + #xf3f3fafa + #xfe000908 + #xf90506fe + #xc07fdf4 + #x40f1813 + #xe07f8f8 + #x30a0c0b + #xff030302 + #xedf3f9f9 + #x40900 + #xff0b01f9 + #x1402f5f1 + #x70e1418 + #xe01f900 + #x30c0e0e + #x1060200 + #xeff3f5f9 + #x50201f8 + #x70cfafc + #x13f6eff4 + #x109181f + #x8010303 + #x3100f0e + #x203fb01 + #xf2f0f5ff + #x4fdfaf6 + #xa08fb03 + #x6f0f5fc + #xfc0e1d1f + #x7080bfc + #x9140b0a + #xfcfdf90a + #xf2f1ff03 + #xfef9f7f6 + #x8050104 + #xfbf6feff + #x141f1a + #xa0f08f5 + #x14110207 + #xf3fb0013 + #xf2f90afe + #xf9f8f4f5 + #x60606ff + #xf90101ff + #xb151d10 + #x1012fef6 + #x1a08fe0b + #xeeff0814 + #xf8070df0 + #xfbf6edf3 + #x70705fb + #x2060002 + #x12111409 + #x120df902 + #x14010110 + #xf2050a0d + #x10f05e5 + #xfdece7f8 + #x50702fc + #x9050107 + #x10090c07 + #xf06fd0e + #xa00080f + #xfb080605 + #xb0cf8e6 + #xf9e1e902 + #x10703ff + #xc040708 + #x8050808 + #x9040712 + #x4050b09 + #xff020004 + #xb02f4f1 + #xeee0f50c + #xb06fe + #xc070b01 + #x407060a + #x709120f + #x70b0503 + #xfafc0009 + #x2fefcf9 + #xe5e3ff0c + #x41104f5 + #xb0a08fc + #x706030c + #x80f150c + #xd0afe00 + #xf1fb050d + #xfd0305f6 + #xe7ef0003 + #xe11feec + #xc0a03fe + #xb01020c + #xb12140c + #xe00f903 + #xf1020a08 + #x30c03ec + #xf2f3f7fe + #xf0af6ee + #xa060306 + #xbff040d + #xe131311 + #x5fafa05 + #xf90908ff + #xc0cf9e8 + #xf8ebf101 + #x803f6f7 + #x705090c + #xa000509 + #xf131516 + #xfcfaff07 + #x20900f7 + #x1000eff0 + #xf2e1f70d + #x1fefe + #x60a1108 + #xa020003 + #xd121a18 + #xf8000105 + #x301f6f8 + #x4f3f2fe + #xe7e70511 + #x902f8 + #xb1210fd + #xc00f902 + #xb121f17 + #xfe060005 + #xfdfbf4ff + #xf6f0fe03 + #xe7f90d09 + #x70dfdee + #x101206f6 + #xdf8f609 + #x8151f17 + #x707fe05 + #xf5fbf706 + #xeef708fe + #xf60b06fa + #x1008f2ea + #x100bfefe + #x8effe13 + #x8191f18 + #xe05fe04 + #xf6fffc0c + #xf10007f3 + #xa0bf7f2 + #xaf8edf5 + #x804010c + #x1f20b13 + #xa1d1e14 + #x1003fe00 + #xfb01000d + #xf50000ef + #x1400eff5 + #xfbeff406 + #x1040b0f + #xff1009 + #xe1e180e + #xf01fdfd + #x3060c + #xf4fbfcf6 + #x12f5f2fb + #xeaf30312 + #x20c1203 + #x70b09fe + #x11170f0c + #xa01fcfc + #x1040a0a + #xeefafffe + #xbf6fbf9 + #xe9010d14 + #xc120cf0 + #x100dfcfc + #xd0d0b0f + #x802fbff + #x70c0a + #xecfd0300 + #xcfdfaef + #xf50c0c11 + #x131000e7 + #x1203f605 + #x7070e14 + #x902faff + #x80f0c + #xf1020600 + #x1200f1e9 + #xb0712 + #x1004f8ed + #xcf7fc11 + #x2071114 + #x8fef9fe + #x10b1307 + #xfa0506ff + #x15f9e9ed + #x40819 + #x3fdfcfa + #x3f80713 + #x30a0e0d + #x1fbfbff + #x40e12fe + #xfe050400 + #x11f0ebf6 + #xf901101f + #xfb0005fd + #x1000c0a + #x3090803 + #xf9fd0000 + #x70e08f7 + #xff050505 + #x6edf4fd + #xf508171a + #xfd0b0bf5 + #x70704ff + #x3050000 + #xf7050500 + #x908faff + #x70805 + #xf9f5fbfa + #x212170d + #xb0ffbed + #xa00fe00 + #x400fd09 + #x4070201 + #x401fc06 + #x2080702 + #xfdfbfbfa + #xc100a06 + #x1108f4f4 + #x3f5010e + #x300010d + #x9060302 + #x1000105 + #x30501fd + #xfafc01 + #xa040106 + #xa00f7ff + #xfaf91016 + #x5030507 + #x5050605 + #x1010202 + #xfffefcfc + #xfff90307 + #x1ff0306 + #x401fe00 + #xf9061b13 + #x80601fd + #x2080906 + #x2010001 + #xf4f9fafd + #xfcfe0d06 + #xfc020501 + #x605fef9 + #x1131a0e + #xd04f9fa + #x40b0a0a + #x10003 + #xeff8f9fc + #xff040dfd + #x108fffd + #xe04f7f3 + #x9131511 + #xbfff8ff + #x70c0b0d + #x1030004 + #xf0f8f7fb + #x30706f5 + #x908f9ff + #xdfaf2f6 + #x80f171a + #x6fcfe03 + #x80d0d0f + #x403fb05 + #xf2f3f5fc + #x402fef4 + #xd03f904 + #x3f3f3fd + #x20e1e1e + #x30307ff + #xc100d0d + #x2fff80d + #xeff1faff + #xfffdfaf5 + #xa010005 + #xf8f6f901 + #x2161f17 + #x70d03f8 + #x150d0709 + #xfcfafe16 + #xedf904fc + #xfaf9f8f5 + #x8030600 + #xf7fefd02 + #xb1a1f0d + #xd10faf8 + #x1905020a + #xf6fb0817 + #xf00607f1 + #xfbf6f4f3 + #x70704fb + #x2fe04 + #x11181905 + #x120af402 + #x13fe050d + #xf7010d0f + #xfd0fffe7 + #xfcedf0f5 + #x708fffc + #x8020007 + #xf131005 + #x1002fa0b + #x8fe0a0f + #xfe060a07 + #x90df2e7 + #xf8e3f0fe + #x607fe00 + #xa010506 + #x90d0b09 + #xa00050e + #x2040c0d + #x2040304 + #xc02ecf1 + #xece0f908 + #x6090100 + #x8050901 + #x50a090c + #x6040f0b + #x5080808 + #xfffe0009 + #x4fcf3f9 + #xe2e6030b + #x90d03f7 + #x80b06fc + #x607080d + #x60d1208 + #xc070105 + #xf8fc050e + #xfe00fdf7 + #xe2f10705 + #xf0efeed + #xa0c01fd + #x903080e + #xb130f08 + #xd00fd05 + #xf4000a0b + #x9ffee + #xecf700ff + #x140af4eb + #xb06ff06 + #x8000a0e + #xf130e0d + #x7f9fd07 + #xfb070902 + #xa0bf5e8 + #xf4f0f900 + #xe00f2f4 + #x704050d + #x6010a0c + #x10131211 + #xfdf70009 + #x30902fa + #xf02ecee + #xf0e7fb08 + #x5fff8fc + #x5090d09 + #x5030707 + #xf121711 + #xf9fb020b + #x704f7fa + #x7f4edfb + #xe5e80611 + #x20401f9 + #x7120fff + #x9010004 + #xc141c12 + #xfe00020a + #x2fcf200 + #xf8f1f900 + #xe2f8100b + #x90a00ee + #xf1405fa + #xaf9fe08 + #xb181d14 + #x6010108 + #xfcf8f508 + #xeef904fd + #xef070cfe + #x1108f5e8 + #x120dfb00 + #x4f1020f + #xa1d1d15 + #xc000105 + #xf9f9fc0d + #xef0404f3 + #x40afff3 + #xefcecf1 + #xd03fd0d + #xfbf20c12 + #xf1f1c13 + #xdff0102 + #xfdfc010e + #xf605fcef + #xffef4f2 + #xfff1f103 + #x6020811 + #xf800120c + #x151f190c + #xb000000 + #xfe060c + #xf800f6f4 + #xdf2f5f6 + #xf1f2fe12 + #x40b1105 + #xff0c0c02 + #x161b1408 + #x900fd01 + #x1090a + #xf4fcf8fc + #x4f0fcf8 + #xeefe0a16 + #x9140ef1 + #xb0efffe + #x12110f0b + #x7fffa03 + #x1060b09 + #xf1fefeff + #x1fafdef + #xf9090e11 + #x121400e6 + #x1001f806 + #xb0b1011 + #x7fefa04 + #x2090c0a + #xf40202fe + #x8fff4e9 + #x40b0c12 + #x1209f3eb + #xaf6ff10 + #x60b1215 + #x7fcf902 + #x40c0f08 + #xfb0602fd + #xdf9ebea + #x7050b17 + #x8fff3f8 + #xf50b13 + #x50c1210 + #x3f9f900 + #x7100e00 + #xff0601ff + #xaefebf3 + #x2121e + #xfe00fefd + #xfdff110b + #x70c0b08 + #xfcfafc01 + #xa1107f9 + #x50202 + #xebf2f8 + #xfa071a1c + #xfd0803f7 + #x1070c01 + #x7080403 + #xfaff0001 + #xb0cfcfc + #x70605 + #xf9f0fafa + #xff101a12 + #x51100ee + #x904fffd + #x402fd06 + #x1070200 + #xa01fb07 + #x6090705 + #xf7fbf8fa + #xb131503 + #x1306eff7 + #x3fbfe06 + #x2fd030c + #x9030003 + #x4fe0108 + #x7090301 + #xfdfbf9fe + #xd090a03 + #x10fcf002 + #xf9f80a12 + #x1ff080a + #x7030204 + #x2000303 + #x303fd00 + #xfcf90003 + #x4010705 + #x6fcfb06 + #xf5061710 + #x4020700 + #x3050606 + #x2000101 + #xfcfdfb00 + #xfafd0902 + #xff020703 + #x401ff00 + #xfe14180a + #x702fffa + #x4090808 + #xff0005 + #xf5fafb01 + #xfc070cfa + #x10502fe + #xa03faf8 + #x919120a + #x8fef9fd + #x80b0a0c + #x7 + #xf5faf9ff + #x10c06f2 + #x904fcff + #xbfef3f9 + #xc131413 + #x3fafd02 + #xb0c0c0e + #x300ff09 + #xf6f6f7fe + #x409fef1 + #xc00fb03 + #x3f5f301 + #x9121d19 + #xfffe0102 + #xd0d0e0c + #x4fdfb0d + #xf2f2f700 + #x103faf3 + #x7fc0105 + #xf9f4f707 + #x6161f14 + #x30701fd + #x110c0c08 + #xf70114 + #xecf6fe00 + #xfdfefaf3 + #x4000601 + #xf7f9fb08 + #xb1d1f09 + #xc0cf8fb + #x14070806 + #xfaf80c15 + #xef0100f8 + #xfcfaf8f0 + #x50604fd + #xfffdfd07 + #x121f1901 + #x1106f301 + #xe00070a + #xf7ff140e + #xfc0bfaf0 + #xfbf4f4ef + #x808fffd + #x6fe0007 + #x131c0f02 + #x10fef80a + #x4000a0e + #xfd051004 + #xa09edee + #xf5ebf3f7 + #x905fd00 + #x6ff0407 + #xe140a09 + #x9fd040c + #xff030d0f + #x1050802 + #xfffe7f4 + #xeae6f902 + #x9040000 + #x5030704 + #x90e0b0c + #x4020c09 + #x80c0c + #x1000307 + #x9f5ecfb + #xe1eb030a + #xa0705f6 + #x50a0500 + #x80a0d0d + #x40a0e05 + #x7070707 + #xfbfc060c + #xf8f6fb + #xe0f70906 + #xf0a00ea + #xa0bff01 + #x8060d0c + #x9110b06 + #xa010205 + #xf7ff0d0b + #x1f9f4 + #xe8ff05ff + #x1307f6e6 + #xc07fd09 + #x6050d0c + #xf12090a + #x5fb0007 + #xfa050e02 + #x907f2ed + #xf2fafdfe + #x1000f0ee + #x9010211 + #x3060e0c + #x11110d0c + #xfcf8020a + #x30905fb + #x11ffe9f1 + #xf0f0fd06 + #x8faf7f8 + #x5050b0f + #x3070b09 + #x1011120b + #xf7fa040c + #x805fcf9 + #xbf3e9fb + #xe5ef050e + #x2fe00f7 + #x60f0c06 + #x6050605 + #xe14150b + #xfafe060c + #x5fcf4fe + #xfceef301 + #xe1fa0f0d + #x60502ec + #xd1405ff + #x8fe0106 + #xe19180f + #xff060a + #xfff6f805 + #xf1f6ff00 + #xec080e00 + #xe07f8e4 + #x150cfb04 + #x2f7040c + #x101d1812 + #x5000606 + #xfbf50008 + #xf10200f9 + #xfe0b04f4 + #xfffedeb + #x1301fb0f + #xf8f70a11 + #x121f1a0f + #x5000502 + #xfaf70708 + #xfb07f8f5 + #xb02f8ef + #x4f3edfe + #xafe0813 + #xf302100e + #x181f1a07 + #x3000102 + #xfcfa0a08 + #xf1f8 + #x6f6f6f3 + #xf6f1fb0d + #x5061109 + #xfa0e0c06 + #x1c1d1500 + #x300fe06 + #xfdff0c08 + #xfdfaf2fe + #xfdf3f9f4 + #xf1fa0a11 + #x9130ff7 + #x60f0302 + #x18161102 + #x4fdfc0a + #xff030b08 + #xf8faf900 + #xf8fafbf0 + #xf904110e + #x1116ffea + #xe04fd05 + #xf100f0b + #x4fbfd0b + #x2080c08 + #xf8fefefe + #xfe00f4eb + #x309110a + #x160befef + #x9f7000f + #x90e1213 + #x4f9fd07 + #x50b0d07 + #xfd03fffe + #x6fdeceb + #x7071010 + #xffeedfb + #xfef60b13 + #x80f1411 + #x1f7fc04 + #x90e0d02 + #x104fd00 + #x5f1e9f1 + #x1041517 + #x4faf601 + #xf701140e + #x90f1107 + #xfdf6fc04 + #xc1006fc + #x303ff02 + #xfceceff7 + #xfd081d17 + #x1fefc + #xfd0b0f02 + #x90b0901 + #xfaf9ff05 + #xe0dfefd + #x2040205 + #xf4f1f6f9 + #xff101f10 + #x60afcf4 + #x40b03fd + #x6050303 + #xff000104 + #xc05f904 + #x4080705 + #xf4f9f8f9 + #x9151a06 + #x110af2f3 + #x700fc01 + #x3ff000a + #x8050002 + #x6fd0308 + #xa080407 + #xfbf9f600 + #xe140ffd + #x12f6ef03 + #xfbfb020f + #xff0b07 + #x6000104 + #x1ff0604 + #x9050004 + #xfcf8fb04 + #x8080901 + #x8f3f90a + #xf4020f12 + #x20cff + #x2010406 + #x201 + #x2fffe05 + #xf9fd0403 + #x50901 + #x3fa0105 + #xfc14130a + #x20405f7 + #x2060707 + #xff0004 + #xfcfbfe04 + #xfa0707fc + #x606fe + #x500fefe + #x91a0f07 + #x400fdf9 + #x7090909 + #xfefe0009 + #xfafafe02 + #x10f02f5 + #x70400fc + #xafef7fd + #x11160d0d + #x1fcfb01 + #xc0b0b0b + #xff010b + #xfaf8fb00 + #x70efaf2 + #x8feff00 + #x4f7f404 + #xe121713 + #xfefc0005 + #xc0b0e09 + #x1fd020c + #xf7f4f901 + #x706f7f4 + #x3fb0203 + #xfcf3f90c + #xb191f11 + #xff020002 + #xd0c0e04 + #xfff8040f + #xf0f3fc03 + #x201f8f3 + #xfe0801 + #xf8f5fd0c + #xd1f1e06 + #x806faff + #xe0b0b01 + #xf7f70f0f + #xeffcfe00 + #xfffef7ee + #x20504fe + #xfdf90009 + #x141f1500 + #xf02f501 + #xa070807 + #xf4ff1809 + #xfb03f9f8 + #xfdfaf4ec + #x607fffd + #x2fb0107 + #x181f0e01 + #xefaf908 + #x204090d + #xf9071401 + #xa01eff4 + #xf6f4f0f2 + #xa04fe00 + #x3fd0508 + #x171a0907 + #x6f8020b + #xfd060c10 + #xff090aff + #x11f7e8f8 + #xeceff400 + #x90102fd + #x1010708 + #x11110b0b + #x1ff0909 + #xff080d0d + #x1050402 + #xbeeebfe + #xe3f1ff0a + #x80306f4 + #x3070506 + #xd0c0e0a + #x2080907 + #x3090a07 + #xfdfe0607 + #xeff4ff + #xe2fc080a + #xa0803e7 + #x9090006 + #xa0b0f09 + #x90e0606 + #x6050604 + #xf8000d07 + #xfef8f8f9 + #xea030601 + #xf07f7e2 + #xe03fe0d + #x70a0e0b + #xf0e0508 + #x2000305 + #xf9060f00 + #x5fff3f2 + #xf30200ff + #xf00efe7 + #xaff0314 + #x40b0e0d + #x110d0908 + #xfbfc0309 + #xa09f9 + #xffaeaf3 + #xf4fafb04 + #x7f9f2f2 + #x5010c14 + #x40c0d0b + #x100e0d07 + #xf5fd060d + #x607fff7 + #xbefe8fb + #xebf6020e + #xfafef3 + #x50a0e0c + #x70a0906 + #xf120f07 + #xf6ff090d + #x6fff9fa + #xffeaf103 + #xe5fd0d0f + #x10001ea + #xd100805 + #x7040405 + #xf15100b + #xfa010a0a + #xfff6faff + #xf1f0fc05 + #xec090f04 + #x907f9e1 + #x160bfe05 + #x3fd030a + #x131a130f + #xfe020906 + #xf7f30201 + #xf3fdff00 + #xfc0e06f6 + #xc01ece6 + #x15fffc0f + #xf9fd0911 + #x181d170c + #xfe030705 + #xf6f70901 + #xfd02f9fb + #x807fbf0 + #x7f6e9f7 + #xafb0714 + #xf3040e12 + #x1b1e1902 + #xfe040205 + #xf6fc0b01 + #x5fdf2fb + #x5fdf3f3 + #xfaeff608 + #x304130d + #xf90e0e0c + #x1d1d14fa + #xff02ff0a + #xf7000b02 + #x3f5f1fe + #xfbf8f5f7 + #xf3f6080c + #x71010fc + #x60f0606 + #x1b1a0dfc + #xfffe10 + #xfa040c03 + #xfdf3f7ff + #xf5fcf7f6 + #xf6021306 + #x111401f1 + #xe050007 + #x16150a06 + #xfb0011 + #x70c03 + #xf9f8fdfe + #xfa02f4f1 + #xa1300 + #x180bf0f2 + #x8fa010e + #xf120e0f + #xfff9020b + #x40a0d02 + #xfdfefdfe + #x2feebef + #x60a1005 + #x14fbecfe + #xfdf90b14 + #xc12130e + #xfdf80006 + #x80d0c00 + #x200fc00 + #x3f3e8f3 + #x309140e + #x9f4f304 + #xf6031212 + #xd121305 + #xfaf6ff05 + #xc0e08fb + #x4fffd05 + #xfbececf9 + #xfd0a1d11 + #x1f9fd00 + #xfa0f1008 + #xc100dfc + #xf6f70007 + #xe0c00fa + #x3000007 + #xf2eff3fb + #x131f0a + #x602fcf8 + #x5100500 + #x90a06fe + #xf9fb0207 + #xe05fd00 + #x4030309 + #xf2f7f5fb + #x7181c00 + #xf03f4f8 + #x906fc01 + #x4030305 + #x305 + #x8fe0007 + #x9090508 + #xf8faf6fe + #xe1713fd + #x15fbeeff + #x1fcff0b + #xff080a + #x6020004 + #x1000803 + #xb050309 + #xfcf4fa07 + #xf1307ff + #x4eefa0a + #xf8ff0a14 + #xfe050dff + #x303 + #x30500 + #x7000206 + #xf9f80008 + #x60b0700 + #xfdf50408 + #xfb0d110f + #x808f5 + #x20703 + #x10002 + #xfc0305 + #xfa030401 + #x20a07fc + #xfe0300 + #xa170d08 + #x206fdf7 + #x4070904 + #xfeff0008 + #xfbfb0302 + #x10c00fa + #x50801f9 + #x400fcfe + #x14140a0a + #x100f900 + #xa0a0a06 + #xfdfe040b + #xfbfb00ff + #xb0cf7f6 + #x601fefd + #x4f8f804 + #x1410100f + #xfefcfc09 + #xb0b0c05 + #xfeff060b + #xf9f7fd00 + #xd04f4f8 + #xfd0102 + #xfef3fc0b + #xf16190e + #xfeff0008 + #xb0d0c01 + #xfdfc080c + #xf3f4fd02 + #x9fff7f8 + #xfcff0504 + #xf8f4030a + #x101f1a07 + #x301ff03 + #xb0e09ff + #xf7fb0e0c + #xeff70003 + #x3fff8f1 + #xff050400 + #xfaf80507 + #x161f1100 + #x9fff902 + #xa0c0502 + #xf2021307 + #xf7fdfefc + #xfdf2eb + #x608ffff + #xfcfb0505 + #x1c1f0900 + #x9f9fa09 + #x408050c + #xf60c1100 + #x4fcf6f5 + #xfcf9edf1 + #x904feff + #xfdfe0607 + #x1e190806 + #x3f7010e + #x70910 + #xff1008fe + #xbf4eff5 + #xf3f3ef00 + #x80002fc + #xfd01070a + #x19120b09 + #xfefc050e + #x90d0d + #x20b0100 + #x5ebf0fb + #xeaf3fa0c + #x50206f2 + #x5060a + #x130e0f08 + #x4050b + #x40a0b06 + #x40304 + #xfbeaf6ff + #xe8fa050d + #x60801e6 + #x706030a + #xe0f0e06 + #x6090309 + #x6090802 + #xfa010905 + #xf6f2fcfb + #xef040905 + #xc09f5e0 + #xc01020d + #xb0f0c09 + #xd0a0308 + #x4050404 + #xf9070d00 + #xfff9f7f4 + #xf9050200 + #xd01eae4 + #x9fe0713 + #x80f0d0d + #xf080607 + #xfe010309 + #xff0d07f9 + #x6f7eff3 + #xfb00fd05 + #x7f8ebee + #x2ff0e15 + #x80f0e0d + #xf0a0905 + #xf800060d + #x70bfff6 + #x7edebfa + #xf4f9010e + #xfef7f6f2 + #x108120f + #xa0e0c08 + #xe0d0a05 + #xf701090e + #x703f9f7 + #xfbe7f202 + #xedfd0c11 + #xfe00fcea + #xa0e0d07 + #xa0a0605 + #x10100a08 + #xf9040b0c + #xfbf9fa + #xefebfb06 + #xf0071209 + #x406f6e1 + #x130a0405 + #x6030309 + #x13130d0c + #xfc070a09 + #xf7f600fc + #xeff70003 + #xfd0f0af9 + #xc03e8e3 + #x15ff000c + #xfd000713 + #x1717140a + #xfe080707 + #xf2fa03fd + #xfbfdfdfd + #x80bfcf2 + #x8f7e4f3 + #x8fb0911 + #xf7050e16 + #x1b1a15ff + #xff07020b + #xf30005ff + #x4faf7fa + #x801f4f6 + #xfeeff002 + #xff02140f + #xfb0c1010 + #x1d1b10f7 + #x4ff0f + #xf6040500 + #x3f3f6fa + #xfdfaf3fe + #xf3f30407 + #x1101202 + #x60e0c09 + #x1d1a07f8 + #x2000014 + #xf9060601 + #xfbf0fafa + #xf8faf6fe + #xf4001000 + #xf1505f6 + #xe070507 + #x1a160303 + #x1fd0316 + #xfd090800 + #xf6f4fdf9 + #xfafdf5fa + #xfd0c10fa + #x190bf6f5 + #xafe040e + #x1512070d + #xfefd0510 + #x30b0aff + #xf8fafdfb + #x2fceff5 + #x5100bfd + #x17faeffc + #xfefa0a17 + #x12120e0d + #xfbfc0409 + #x60c0afc + #xfffcfc00 + #x3f2ebf7 + #x50e0c05 + #x9f0f604 + #xf7031217 + #x11131203 + #xf8fb0208 + #x90e07f8 + #x1fbfd04 + #xfdebedfd + #x20f140b + #xfff4ff02 + #xfb0e120e + #x10130cfa + #xf4f90208 + #xd0c02f6 + #xfb0108 + #xf3ecf2ff + #x1151d06 + #xfffd00fb + #x8120905 + #xd0e04fa + #xf3fc0509 + #xd07fff9 + #x1ff040a + #xf2f2f5ff + #x91d19fd + #x900f7f8 + #xd0a0004 + #x8080101 + #xf9000506 + #x8010000 + #x404050b + #xf7f5f500 + #x111e10f8 + #xef8f2fe + #x8fffe0c + #x3030508 + #xff010304 + #x2ff0704 + #xb07040a + #xfcf5f905 + #x121709fd + #x9f0f507 + #xfbfb0714 + #xfe020c05 + #x1000203 + #x10605ff + #x8020606 + #xf7f4010b + #x110f03ff + #xf4f40309 + #xfb051310 + #xb06f8 + #xfe020600 + #x2050000 + #x1ff0704 + #xf8fc0508 + #x90c05fc + #xf5ff0601 + #x7101107 + #x40bfcf6 + #x607ff + #x5 + #xfb000701 + #x60200 + #x80a01f9 + #xff0200fe + #x14100b06 + #x503f600 + #x70a0700 + #xfefe040a + #xf90004fe + #xa07fbfb + #x705fcfb + #x2fdfc02 + #x150d0c0b + #x1fdf90b + #xa0b0802 + #xfd00070b + #xf9fe00fc + #x1000f6fb + #x200fc05 + #xfef60008 + #x1010140c + #xfefd000d + #xb0c0900 + #xfc00090a + #xf5faffff + #xbfaf8fb + #xfd000009 + #xf8f70607 + #x121c1507 + #xff0109 + #xb0e06fe + #xf9000b0b + #xf1f80000 + #x6fbfaf6 + #xfd040207 + #xf6fc0a00 + #x181f1000 + #x4fe0007 + #xc0d0201 + #xf5050f0a + #xf2fb01fc + #x2fef5ee + #x4070003 + #xf8ff0800 + #x1f1f09ff + #x3f9fc0b + #xb09010a + #xf90e0a05 + #xfcfcfdf3 + #xfaecf0 + #xa04fe01 + #xf8010704 + #x1f170803 + #xfef60014 + #x705060f + #x1110302 + #x1f6f5f1 + #xfbf3eefe + #x80001fe + #xfa03070a + #x1e100b05 + #xfbfa0416 + #x5070b0c + #x80efe02 + #xfeeef3f6 + #xf2f0f90b + #x30203f6 + #xfe05090b + #x160f0e03 + #xfd000413 + #x70a0d06 + #x506ff05 + #xf3ecf7fc + #xeff6060e + #x408feeb + #x4060809 + #x11110d03 + #x304040f + #x80a0801 + #x30306 + #xedf1fcfc + #xf3000c06 + #xa09f1e4 + #x802060a + #xe120b07 + #x804040c + #x7070404 + #xfd070803 + #xf4f8faf5 + #xfd0607ff + #xe02e5e6 + #x7ff090f + #xd110b0d + #xb030509 + #x3030309 + #x10d05fe + #xfff8f3f2 + #x10002 + #x8f7e4f0 + #x1113 + #xd100e0d + #xb050706 + #xfe01050e + #x70dfdf9 + #xfff0eef5 + #xfbfb030b + #xf3eef5 + #xff071510 + #xd100e08 + #xb080605 + #xfb01090f + #xb07f7f8 + #xf6e8f100 + #xf4fc0e10 + #xfbfbf6f0 + #x50f1206 + #xe0d0904 + #xd0b0609 + #xfc050b0e + #x4fef6fa + #xebebfb05 + #xf4051408 + #x203f1e7 + #xf0d0902 + #xa080408 + #x100d0a0c + #xfe080a0c + #xfbfaf9fc + #xe9f40103 + #xfe0f0ffb + #xb02e5e6 + #x10030506 + #x3030611 + #x14101009 + #x10a070d + #xf5fcfdff + #xf3fc01fd + #x90f00f3 + #xcf7e0f2 + #x8fe090f + #xfd030f17 + #x16151300 + #x308020f + #xf600fd00 + #xfefcfdf6 + #xb03f6f7 + #x1ecea00 + #xfc04130e + #xfe091512 + #x1a190cf8 + #x5030115 + #xf904fd02 + #xfff6faf4 + #x3faf400 + #xf5effd05 + #xfd101506 + #x70d1208 + #x1c1802f9 + #x6ff0318 + #xfd070003 + #xf7f2fbf4 + #xfbf7fa04 + #xf3fe0a00 + #xb1608fa + #xd0a0904 + #x1c13fc01 + #x3fc0919 + #x80201 + #xf0f6fdf4 + #xfcf9fbff + #xfc0b09fa + #x170dfbf6 + #x902060b + #x190e020b + #xfe0a17 + #x30a04fe + #xf1fafcf7 + #xf8f7f9 + #x61103fb + #x16fdf4fb + #xff0b17 + #x150e0b0b + #xfc000911 + #x70c05fb + #xf8fcfbfc + #x2f2f2f8 + #xb0f0202 + #x8f2f801 + #xf902131b + #x13111003 + #xfafe040c + #xa0d03f8 + #xfdfafd01 + #xfceaf2fd + #x80f0b09 + #xfaf40001 + #xfe0d1712 + #x13130af9 + #xf6fd030d + #xc0dfff4 + #xfbfa0005 + #xf4e9f600 + #x7161305 + #xf8fc01fd + #x7121008 + #x120f00f8 + #xf4fd050c + #xd09fcf4 + #xfbfe0509 + #xf0eefa00 + #xc1d13fc + #xfbf9 + #x100b0504 + #xe09fc02 + #xf601060a + #x904fefa + #xff02060b + #xf5f2fa00 + #x151f0af8 + #x7faf5fd + #xc00020a + #x8040009 + #xfc030406 + #x40201ff + #x504070a + #xf9f1fa03 + #x191b02fa + #x2f1f605 + #x2fb0812 + #x2040708 + #xff020303 + #x1050600 + #xa040608 + #xf8f1000a + #x14120200 + #xf8f10009 + #xf9ff1114 + #x80aff + #xff010401 + #x50700fe + #x2030802 + #xf3fb070a + #x110a03fb + #xf0ff050a + #xd1602 + #x60afdf9 + #xff0604fd + #x401ff01 + #xfc040801 + #xfb020704 + #xc0b01f8 + #xfa050102 + #xe100eff + #x906f500 + #x40a02fd + #xff0208 + #xfa0705fe + #x60300fd + #xc06fafc + #x100fd03 + #x120b0a03 + #x6fdf80c + #xa0a0201 + #xfd00070b + #xfc0500fc + #xcfefcfb + #x700f905 + #xfffa0006 + #xf0c0f08 + #xf90011 + #xc0b0401 + #xfd02090b + #xfa00fefc + #x9f7fcfc + #xffff0e + #xf7fb0604 + #xf151306 + #xfefd060d + #xc0b0300 + #xfc03090c + #xf5fcfffd + #x3f8fdf8 + #x1030d + #xf50009fe + #x191d0f00 + #xfe030a + #xe0b0000 + #xfa060a0d + #xf3fe00f9 + #xfcfaf2 + #x4050308 + #xf70506fc + #x1f1a08fe + #xfc000f + #xf060006 + #xfd0c090c + #xf700fff2 + #x1fbf0f0 + #x8020004 + #xf8050300 + #x1f1607ff + #xfdf90016 + #xc02040c + #x60f0208 + #xfbfcf7ef + #xfff2eff9 + #x6000102 + #xfb040509 + #x1e100a00 + #xf8fa051b + #x9040b08 + #xd0bfe06 + #xf8f5f2f5 + #xf7edf905 + #x30101fd + #xff05080b + #x190f0dff + #xf9fe081b + #x8070d03 + #xc04fe07 + #xeff0f5fd + #xf1f10808 + #x307fdf3 + #x2060a08 + #x12130aff + #x10815 + #x90a0900 + #x4000208 + #xeaf3faff + #xf4fe0f01 + #xa08f0ec + #x6050906 + #x12130803 + #x4010810 + #x9080402 + #x40507 + #xeef9fbf9 + #xfc070bf9 + #xf00e4ec + #x4030a0b + #x11110a0a + #x501070c + #x7040308 + #x30b0402 + #xf7faf5f3 + #x20503fb + #xbf3e1f4 + #xff031011 + #x110f0e0d + #x502060a + #x200060d + #xa0bfdfe + #xfbf4eef6 + #xfe0304 + #xeeeafa + #xfc0a1510 + #x11101006 + #x6050409 + #xff010a0e + #xd04f7fc + #xf4ecf0ff + #xf8fd0d0a + #xfbf3f2f7 + #x3111408 + #x10100c01 + #x906040b + #xff040c0e + #x9fef4fc + #xe9ebf806 + #xf6051705 + #xfdf0ef + #xc120c00 + #xf0b0505 + #xb07080d + #x80c0d + #xf9f5ff + #xe6f40004 + #xfd1013f8 + #x9fee5ec + #xe0a0602 + #x805070e + #xd0b0d0c + #x409080e + #xf9faf702 + #xeefc02fd + #x71205f0 + #xdf4e0f3 + #x603080c + #x2030f14 + #x10110f04 + #x8060612 + #xfafff805 + #xf9fffff5 + #xd09f9f4 + #x3e8e600 + #xfc051011 + #x71711 + #x15160bfc + #x9010515 + #xfe00fa06 + #xfbfbfbf2 + #x7fcf8fe + #xf6e9f806 + #xfd101409 + #x50d1606 + #x1b16fffc + #x8fe0818 + #x1fd05 + #xf5f9f9f2 + #xfef6fd02 + #xf1f70403 + #xa160dfe + #xb0e0d00 + #x1c0ff902 + #x4fd0d1a + #x2020002 + #xeff9f8f4 + #xfbf702ff + #xfb0703fc + #x160ffff6 + #xa080506 + #x1908fe0a + #xff101a + #x50501ff + #xf0fcf7f7 + #xfef900f7 + #x70efdfc + #x1501f8f9 + #x1030a15 + #x1508090a + #xfd010f17 + #x80800fd + #xf5fcf7fb + #xfff5f9f4 + #xe0bfc02 + #x8f7f900 + #xfb05141b + #x130d0e01 + #xfc010a14 + #xb0afffa + #xfafbf900 + #xfbedf7f9 + #xd090208 + #xf9f50003 + #xfd0c1b15 + #x13110af9 + #xfbfe0712 + #xd0afcf7 + #xf9faff04 + #xf2ebfafe + #xc0f0d05 + #xf4fd0100 + #x6131707 + #x130ffff9 + #xf7fe0712 + #xe07f8f5 + #xf8fe0307 + #xeeeefefe + #x10180efd + #xfb01fdfd + #xf100c01 + #x1107f900 + #xf700080f + #xc04f7f8 + #xfa02060a + #xf0f2fffd + #x191c07f7 + #x2fdf500 + #xe050505 + #xb02fd0b + #xfc04060c + #x702fbfd + #x105070a + #xf4f2fdff + #x1e1800f9 + #xf4f608 + #x4fe0a0d + #x501050c + #x30408 + #x404ffff + #x6040707 + #xf4f30005 + #x1c10fefe + #xf5f2fd0e + #xfd00140f + #x2060804 + #x10303 + #x50700fe + #x5030804 + #xf2f7060b + #x130b03fe + #xeefb050b + #xfc071606 + #x50b02fc + #xff0404fe + #x701fd00 + #xff080703 + #xf5020a05 + #xf0801f4 + #xf902030e + #x7150df6 + #xa03f9fe + #x3080000 + #x2fd0007 + #xfe0a0501 + #x505fd + #xd07fcf8 + #x202ff09 + #xe1006fb + #x8fbf909 + #xb09fe03 + #xfeff060c + #x10900ff + #x600fffa + #xa00f903 + #x2fd0009 + #xc0d0903 + #x1f80210 + #xd060005 + #xfe02090c + #x304fcfd + #x4fbfdfa + #x3fb000e + #xfbfc0407 + #xc110e04 + #xfdfb0a0e + #xc060103 + #xfe04090c + #xfefffcfd + #xfefafef9 + #xfe080e + #xf6030700 + #x14180e00 + #xfcff090b + #xd060100 + #xfe05090e + #xf8fefefa + #xfdfefbf4 + #x2020909 + #xfa0802fc + #x1e1908fb + #xfd000310 + #xe040002 + #x80a0f + #xf801fdf5 + #xfffef4f0 + #x7020705 + #xff08ff01 + #x1f1105fb + #xfcfd0319 + #xc000304 + #x60a070b + #xfb00f7f1 + #xf6f0f4 + #x5000405 + #xff050009 + #x1d0e05fb + #xfafb081e + #x7000a04 + #xe070407 + #xfaf9eff8 + #xfaedf7fd + #x1000302 + #x4070b + #x191106fb + #xf9fd0f1f + #x4070eff + #xd010306 + #xf3f3f001 + #xf2f10400 + #x204fffb + #x3070b07 + #x141406fd + #xfc00111a + #x50a0afe + #x6fd0408 + #xecf3f705 + #xf1ff0dfa + #x905f5f2 + #x5080a05 + #x15140400 + #xff000e12 + #x7090500 + #x1000608 + #xeff8f900 + #xf90b0af2 + #xefce9f0 + #x4070909 + #x150f0607 + #x10b10 + #x7050404 + #x2050505 + #xf6faf6fa + #x10c02f2 + #xbf0e5f6 + #x70d11 + #x140d0c08 + #x103080f + #x4010608 + #x9080101 + #xfbf6effa + #x20400fb + #xe8ebfd + #xfe0b1313 + #x12100f04 + #x203060d + #x10b0b + #xe02fbfe + #xf6eeee01 + #xfc000902 + #xf7ecf4fd + #x313140a + #x12120bff + #x403050e + #xff040e0a + #xafbf7fe + #xecebf508 + #xf8071200 + #xfaf5f4f6 + #xd150e01 + #x110f0501 + #x604080f + #x70d0b + #x1f7f600 + #xe6f1ff09 + #xfc1511f4 + #x4f8ebef + #x100f0501 + #xd070409 + #x7070c0e + #x5090c0c + #xfcf7f805 + #xecfa0201 + #x71705eb + #x9efe4f5 + #x908050a + #x6030e11 + #xb0d0e09 + #x8070a0e + #xfbf8fa08 + #xf600fff8 + #xd0efaee + #x1e5e800 + #x1070c13 + #x209170e + #x11130801 + #x9020b11 + #xfefafb07 + #xfbfff9f4 + #xb01f7f8 + #xf4e4f607 + #xfe0f1310 + #x4101602 + #x1813fffe + #x6ff0d15 + #xfb0005 + #xf8fbf5f6 + #x1f9ffff + #xeef20206 + #xa151001 + #xa130cfd + #x1a0cf902 + #x1001118 + #x2fd0301 + #xf3faf3fa + #xfafa05fc + #xf6010200 + #x171104f8 + #xb0e0403 + #x1804fd08 + #xfd03141a + #x2fe03fe + #xf3fbf3fc + #xfafe03f4 + #x508fcfd + #x1605faf8 + #x5070611 + #x11020609 + #xfc051419 + #x50200fd + #xf8faf3ff + #xfbfdfcf0 + #xf05fa00 + #x9fbfa00 + #x7131a + #xe080b02 + #xfc051117 + #x803fefc + #xfbf7f502 + #xf8f7f7f3 + #xe010003 + #xfbf9ff08 + #xff0e1c13 + #x100f07fa + #xfd020e15 + #xb05fcfa + #xfaf8fb05 + #xf2f1f9f9 + #xa050903 + #xf5fe0107 + #x6161a05 + #x120efff8 + #xfaff0d15 + #xd03f8f7 + #xf8fb0009 + #xecf4fefa + #xf100dfb + #xfb01fe03 + #xf1610fe + #x1106f800 + #xf9010d13 + #xc00f5f9 + #xfb00030b + #xedf8fff8 + #x181606f5 + #x1fff805 + #xf0f07ff + #xcfffd0a + #xfd030b11 + #x900f5fe + #x4050b + #xf0f9fdfa + #x1f14fff5 + #xf6f60d + #x7050806 + #x5ff050e + #x103080c + #x700fa00 + #x5040609 + #xf1f7fe00 + #x1d0bfff9 + #xf7f2fc15 + #xfe041209 + #x2030a08 + #x2010508 + #x702fdff + #x4040705 + #xf0f90305 + #x160702f9 + #xf0f80316 + #xfc0c1701 + #x40706fe + #x20402 + #x803fdff + #x60703 + #xf1000907 + #xf0804f6 + #xf4000510 + #x11311f8 + #x907fcfc + #x10701fe + #x3fdff07 + #x3090507 + #xfc0807ff + #xd07fbf3 + #x1000510 + #xd1600f5 + #x7fdfc02 + #xa03fc06 + #xfefd040d + #x70a0103 + #x30600fa + #xb01f8fd + #x4fc020e + #xd0e0000 + #xf7020b + #xe01ff0a + #xfd02090d + #xb04fdff + #x100fbfc + #x4fb0007 + #xfefc060c + #xb0e0703 + #xfafb0b0c + #xb000207 + #xff050b0b + #x6fffcfe + #xfdfefbfe + #xfffb0b0b + #xfa010605 + #x10130aff + #xfa010c0a + #x9020302 + #x60a0c + #xfffcfdfc + #xfa00fbfa + #xfe011005 + #xfe070100 + #x191506fa + #xfc03070f + #xa0302ff + #x1060c0d + #xfcfffbf9 + #xff00f5f4 + #x2040c01 + #x306fd01 + #x1e1101f9 + #xfe000619 + #x9000200 + #x5070e0a + #xfe00f6f8 + #xf9f0f3 + #x3020803 + #x601fe08 + #x1a0d00fb + #xfcfe0b1f + #x40106ff + #x8060b05 + #xfffaeffd + #xfdf1f3f8 + #x10605 + #x401050b + #x160f01fb + #xfafe111f + #x609fc + #x8010803 + #xf9f1ef07 + #xf2f2fffc + #x10403ff + #x4060b06 + #x1512fffc + #xfa00181b + #x10c08fa + #x4fe0704 + #xf3eff60a + #xefff06f7 + #x604fcf6 + #x5090b04 + #x16120000 + #xfc031615 + #x50b04fd + #xffff0806 + #xf1f3fc07 + #xf70e04ef + #xbfdf2f0 + #x50a0709 + #x180d0204 + #xfe040f13 + #x6070300 + #xff030805 + #xf7f7f900 + #x110fdee + #x7efecf5 + #x3090a12 + #x160b0906 + #xff050b13 + #x4040602 + #x4040502 + #xfbf5f3fe + #x509faf5 + #xfde7effd + #x20b1114 + #x130f0c01 + #x40812 + #x40903 + #x80200ff + #xf9eef002 + #x300fe + #xf2e8f7ff + #x512150e + #x131308fd + #x2030711 + #xfe060c05 + #x7fcfcfe + #xefe9f60c + #xfc090bfd + #xf3f1f9fa + #xe160f01 + #x131102ff + #x2020911 + #xff0a0d06 + #xf7fa00 + #xe9edff0d + #xff140cf3 + #xfcf5f3f3 + #x13130600 + #x110a0207 + #x3050d11 + #x30b0c07 + #xfaf5fb04 + #xebf80405 + #x91b02ea + #x2efeaf4 + #x10090309 + #xa040a0f + #x50b0e0d + #x7090b07 + #xf9f5fe07 + #xf4ff00fd + #x1213f6ea + #xfce4ecff + #x7060a13 + #x308130d + #xd110906 + #x6060c0a + #xfaf60106 + #xfcfffafa + #x1003f3f2 + #xefe3f608 + #x40b1210 + #x4131404 + #x15110101 + #x3040e0e + #xfbf70302 + #xfbfbf4fa + #x5fbfafa + #xe9ee0109 + #xa131403 + #x9190afd + #x1809fa01 + #xfe051214 + #xfbf906fe + #xf9f7f2ff + #xfcfe01fa + #xf1fd0302 + #x16140af7 + #xe120001 + #x1401fe06 + #xfb091518 + #xfdfd04fc + #xf9f6f300 + #xf90202f4 + #x3fffd + #x170afef7 + #xb09010f + #xf000508 + #xfb0c161a + #xff0001fc + #xfbf5f401 + #xfc04faef + #xa00fcfd + #xcfffa00 + #x4060f19 + #xa040803 + #xfd0b1517 + #x301fffc + #xfcf3f503 + #xfafff5f2 + #xafc0000 + #xfffbff0b + #x30e1c15 + #xd0c03fd + #xfe091314 + #x600fdfb + #xfbf3f906 + #xf5f9f5f7 + #x60008fe + #xf9fe030d + #x7191c06 + #x110bfcfa + #xfc061213 + #x800fbf8 + #xf8f6ff0a + #xf0f8fafa + #x7090cf9 + #xfc00020a + #x101d10fc + #x1005f7ff + #xf9041214 + #x8fef7f9 + #xfafc030d + #xeffcfcf7 + #x121106f2 + #x2fffd0a + #x131505fd + #xbfffb08 + #xfb071113 + #x7fbf6fd + #x50d + #xf1fefaf7 + #x1a1000f1 + #x1f7fb10 + #xd0c0402 + #x4fd050d + #x60d0f + #x5fbf800 + #x402070b + #xf3fcf9fc + #x1b0afdf4 + #xfaf2ff1b + #x3090c06 + #x10c08 + #x2030b09 + #x6fdfc00 + #x4020709 + #xf1fbff02 + #x140501f5 + #xf3f6061d + #xf11ff + #x2070900 + #x20804 + #x6fefdff + #x1050708 + #xf2000604 + #xd0601f1 + #xf5fd0a18 + #x3180cf6 + #x60702fb + #x50402 + #x5fefd03 + #x1090608 + #xf8060801 + #xc08fef1 + #xfe010712 + #xa1902f3 + #x800fcff + #x707fe03 + #xfefd030c + #xa080607 + #x30900ff + #xc02f4f7 + #xb10 + #x130cfaff + #x1fc0007 + #xbfeff0a + #xfd000a0c + #xe040101 + #x403fa00 + #x5fbfb01 + #xfefc0a0f + #xe080105 + #xfafc070a + #x7fc0509 + #xff060c08 + #xafffffe + #xfffa04 + #xfdfc0905 + #xfa000a09 + #xf0d0701 + #xf8030b09 + #x3000701 + #x1080c07 + #x1fbfdfd + #xfcfffb03 + #xfb031002 + #xff050402 + #x151104fb + #xfd07080b + #x40204fc + #x2070d09 + #xfdfdfdfc + #xff00f8fc + #xff090dfe + #x603ff00 + #x1a0ffffa + #x40716 + #x50301fb + #x3081007 + #xfffef8fb + #x2fcf3f8 + #x2090800 + #x9ffff05 + #x180bfdfe + #xff010d1d + #x20101fd + #x5090f02 + #x1f9f3ff + #xf4f2f9 + #x1060604 + #x5fd0407 + #x140bfd00 + #xfc00161f + #xff0503fc + #x4060b00 + #xffeff206 + #xf5f1f8fc + #x50701 + #x3030b05 + #x140ffe00 + #xfa031b1b + #xb03fa + #x20602 + #xf6ecfa0b + #xeffdfef8 + #x50602f7 + #x40a0b03 + #x180cfd00 + #xfb061a17 + #x40b00fa + #xfc020605 + #xf1f00007 + #xf70afef3 + #x800f9f0 + #x60b0707 + #x1a090003 + #xfc081317 + #x70800fc + #xfd040705 + #xf4f60000 + #x40ef7ef + #x5f5f1f2 + #x7080910 + #x15070505 + #xff090e18 + #x60502fd + #x60602 + #xf9f5fafe + #xb08f4f4 + #xf9ebf2fc + #x60a1013 + #x120b0802 + #x60c16 + #x20505fe + #x40403ff + #xf9eff602 + #x702f9fb + #xeeeaf801 + #x810160c + #x121105ff + #x1040c14 + #x80700 + #x400fffd + #xf1e9f90a + #x10602fe + #xecf1fcfe + #xe161200 + #x151200ff + #x1020c13 + #xb0801 + #xfffbfb00 + #xe9ec010c + #x41205f5 + #xf4f6f8f7 + #x151408fc + #x1409fe07 + #x50f14 + #x30d0902 + #xfaf7fc03 + #xe9f50708 + #xd18feec + #xfbf2f0f6 + #x140c0302 + #xd04050f + #x30a1012 + #x70d0902 + #xf6f60006 + #xf1fe05ff + #x1712f3e9 + #xf7e9edff + #xd05090d + #x508100f + #xa0e0c0b + #x70a0903 + #xf6f70304 + #xfafffefc + #x1504eff0 + #xece5f509 + #x708130d + #x5131007 + #x120e0504 + #x3090a09 + #xf6f90600 + #xfefbf8fd + #xcfbf5f7 + #xe5ed000d + #xa111701 + #xb190801 + #x16080001 + #xff0a0e11 + #xf6fc06fc + #xfcf5f5ff + #xfdfcfa + #xebfb0406 + #x13160ff3 + #x1316ff03 + #x1100fe04 + #xfd0d1218 + #xf7ff01fb + #xfaf2f700 + #xfc04fdf6 + #xfa0101fe + #x160f02f3 + #x1207000f + #x9fe0309 + #xff101519 + #xf900fefd + #xfaf1f9ff + #xff07f8f4 + #x400fefb + #xf03fbff + #xa030a18 + #x7030607 + #x1111616 + #xff01fcfe + #xfaf1fa00 + #x103f2f6 + #x4fb00fd + #x3fcff0a + #x40a1915 + #x9080200 + #x20f1512 + #x100fcfd + #xf7f0fc03 + #xfdfbf3fa + #xfd05fd + #xfdfe060e + #x9181b08 + #xf09fafe + #xd1511 + #x2fffcfa + #xf5f30007 + #xf7f8f7fa + #x10607f8 + #xfe00080b + #x121f10fe + #x1001f600 + #xfd0c1413 + #x3fef9f8 + #xf6f8040b + #xf4fcfaf8 + #xa0f03f2 + #x2000409 + #x181b03fc + #x9fbf907 + #xfc0c1413 + #x3fbf6fc + #xfcfd080c + #xf7fff8f8 + #x150efdef + #x2fb0210 + #x150e0002 + #x2fb020d + #xc120f + #x2f8f800 + #x90c + #xf8fdf7fc + #x1608faf0 + #xfbf40519 + #xb090605 + #xff000a0c + #x1090f09 + #x1f9fdff + #x101090b + #xf7fbfa02 + #x1005fcf2 + #xf3f60d1f + #x50e0c00 + #x60b03 + #x70b03 + #x1fafefe + #x3090b + #xf6fd0105 + #xb06fdf0 + #xf4fc121b + #x81708f8 + #x40804fd + #xfe070701 + #xfbfe00 + #x106080b + #xf9040602 + #xa08f9ee + #xfa001113 + #xf18fff5 + #x705fffd + #x3060203 + #xfffc0009 + #x709070a + #x902ff + #xd06f4f4 + #x1000b11 + #x1312f8fa + #x3fefe03 + #xa01fe08 + #xfc010a09 + #xd070700 + #x704fc06 + #x8faf4ff + #xfb030f0f + #x1300fe02 + #xfeff000e + #x4fd0505 + #xff060d04 + #xb0102fc + #x3fdfc0c + #xfff90003 + #xf9020e0c + #xd040603 + #xfc03060b + #xfeff0900 + #x2090c01 + #x1fefffc + #xfb000b + #xfa030a01 + #xfd060a03 + #x110c05fd + #xff08060b + #xff0405fa + #x3090b03 + #xfcfdfefd + #xfc0004 + #xff0d08fd + #x40502fe + #x160dfffc + #x2070711 + #x20600f9 + #x30a0d05 + #xfdfdfbfe + #x3fbfafe + #x50e02ff + #x7ff0000 + #x1607fa01 + #x3040c19 + #x303fefc + #x40c0d02 + #xfaf7fe + #x1f5f5fd + #x50a0204 + #x3fc0403 + #x1306fd05 + #xff03161b + #x3fefe + #x50d0900 + #xfef1f702 + #xfaf2f6ff + #x3080603 + #xff010901 + #x1206ff04 + #xfc071c18 + #x5fffd + #x4090301 + #xf6edfe07 + #xf2f7fbfe + #x40807fa + #xa0a00 + #x1606ff02 + #xfc0c1b17 + #x508fefb + #x60106 + #xeef10502 + #xf702fbf7 + #x705fef1 + #x70c0605 + #x18020003 + #xfe0d161a + #xa05fdfa + #xfe060307 + #xeef806fe + #x408f6f2 + #x5fcf4f2 + #xa09070c + #x15030204 + #xc121c + #x904fefa + #x70405 + #xf4fafffb + #xe02f2f4 + #xfbf2f1fd + #x808110f + #xf070504 + #x2091119 + #x60400fb + #x4070201 + #xf5f4fbfe + #xcfcf6fa + #xeeeef704 + #x90f1707 + #x110d0301 + #x2061116 + #x30600fe + #x404ff00 + #xf0eefc04 + #x5fffefd + #xebf3fc03 + #xd1615fb + #x150d0002 + #x41114 + #x3080300 + #xfffb01 + #xe7ee0308 + #x50902f7 + #xf0f9fcfc + #x14170af5 + #x1607fe07 + #x51116 + #x70c0400 + #xfbfafb05 + #xe5f70a04 + #xf11fdee + #xf8f7f3fb + #x160f03fc + #xf000310 + #xa1216 + #xa0c04ff + #xf7f8ff07 + #xecff08ff + #x190ff4e9 + #xf6efee02 + #xf070704 + #x7040c13 + #x70e1111 + #xa0c0400 + #xf4f90206 + #xf60101fa + #x1b00eded + #xece9f30f + #x7081205 + #x60f100d + #x100d0b07 + #x80a0306 + #xf4fc0402 + #xfcfdfcfa + #xff8f1f5 + #xe5eeff13 + #x81117fb + #xe170805 + #x12070402 + #x40a070f + #xf4ff01ff + #xfcf6fbfa + #x3f9f8fa + #xe9f8050d + #xf1911ef + #x16110006 + #xe010005 + #x30c0d17 + #xf702feff + #xf9f2fcfb + #xff01fbfa + #xf6000402 + #x161603ed + #x1806000f + #x6fe020b + #x50f131a + #xfb02f901 + #xf5f4fef9 + #x204f7f8 + #xfffc + #x1208fbfa + #xf000b18 + #x201040d + #x8111614 + #xfd00f802 + #xf4f4fefa + #x700f3f9 + #x1fdfdfd + #x700fe06 + #x5061716 + #x5050207 + #x912160f + #xf902 + #xf2f4fefd + #x4f8f5fc + #xfdfd0000 + #xff080b + #x7151a0b + #xb05fc00 + #x711130f + #xfefaff + #xf0f50001 + #xfef5f9fc + #xfd0402fd + #xff020c06 + #x131f0f00 + #xdfff802 + #x4101411 + #xfef8fc + #xf0f80405 + #xf9f8fbf8 + #x50bfff7 + #x1040a04 + #x1c1b05ff + #x8f8f90a + #x2111413 + #xfcf5fd + #xf5fd0807 + #xfafcf9f7 + #x100df9f2 + #x1000609 + #x1b0f0002 + #xf70010 + #x4111310 + #xf9f600 + #xfb000b08 + #xfdfbf6fb + #x1407f5f3 + #xfbfb0a15 + #x12070405 + #xfdfe0711 + #x50f1008 + #xfef7fb00 + #xfd020b08 + #xfbf8fa00 + #xf03f5f3 + #xf3fa111b + #xa0a0900 + #x5090a + #x30d0c03 + #xfdf9fdfe + #xfd040c08 + #xf9f80103 + #xa04f6f4 + #xf0001918 + #xc1207fa + #x4080502 + #xb0700 + #xfcfbfdff + #xff060c09 + #xfa000501 + #xa06f4f1 + #xf6051812 + #x1414fef5 + #x707ff01 + #x30a0301 + #xfbfcfe05 + #x4070b07 + #x60300 + #xe04eff3 + #xfb06130e + #x180bf7f9 + #x502fc06 + #x7030105 + #xfcff050a + #xc080904 + #x607fe02 + #xbfdf1fc + #xfd040f0f + #x1501fb00 + #xffff0b + #x7fe0207 + #xff060c00 + #x90805fb + #x6fd000d + #xf6fa04 + #xfa09100f + #xafd03fe + #x412 + #xfb010800 + #x30a0afc + #x20200fb + #xf80710 + #xfbff0303 + #xfc0a0e05 + #x90605fb + #x105060e + #xfa0605fa + #x60a0700 + #xfb00fdfd + #xfefa0907 + #xb0400 + #x20906fc + #x100a00fc + #x506060f + #x8fffa + #x60b0703 + #xfbfffcff + #xfc03ff + #x80eff00 + #x50300fb + #x1306fd02 + #x5040b15 + #x505fbfd + #x60c0904 + #xfefcfaff + #xf8fcfe + #xd0afe05 + #xff0100 + #x1100ff07 + #x1041418 + #x400fb00 + #x80f0601 + #xfdf5fa00 + #xfaf2fb00 + #x9070306 + #xfb010601 + #xf000306 + #xff0a1817 + #x200fd00 + #x90d0002 + #xf5f1fe01 + #xf5f4fd00 + #x70807ff + #xfd090700 + #x10000303 + #xfe0f1816 + #x501fefd + #x707fe07 + #xebf50400 + #xf6fbfffb + #x80901f4 + #x50c0301 + #x13000101 + #x111161a + #xa01fdfa + #x305010a + #xeafe06fc + #x1fff9f4 + #x602f5f4 + #xb080508 + #x10000204 + #x410161d + #xa00fcf9 + #x3050408 + #xf00000f9 + #xbfcf5f2 + #xf8f0ff + #xa080d0c + #xc040405 + #x40c171b + #x800fcfb + #x5060206 + #xf4fcfafb + #xaf6f6f6 + #xf5f2f509 + #x80f1504 + #xd090305 + #x40a1716 + #x602fcfe + #x604ff04 + #xf0f4fc00 + #x4f7fdfb + #xeef4fd09 + #xd1714f8 + #x12090004 + #x81515 + #x603ff00 + #x400fb05 + #xe8f30104 + #x30101f7 + #xf1faff03 + #x131a0af0 + #x1503ff09 + #xff091418 + #x9050000 + #xfffbfb08 + #xe4fa0802 + #xc0a00ed + #xf8fbf8ff + #x181300f3 + #xffe0310 + #xb1419 + #xc0801fd + #xfaf9fe0a + #xe90207fd + #x1709f5e7 + #xf8f3f106 + #x120902fd + #x6000c15 + #x60e1514 + #xd08fffd + #xf6fa020a + #xf40502f9 + #x1800efe9 + #xf1ecf412 + #x9080c00 + #x50a1011 + #xc0f110b + #xc07ff03 + #xf5fd0207 + #xfc01fdf6 + #x10f5eff1 + #xe9ed0019 + #x51214f7 + #xd120c0a + #xf0b0904 + #xa05010e + #xf700ff05 + #xfbfbfcf6 + #x4f5f6f9 + #xeaf60914 + #xc1b0deb + #x170f0407 + #xb040206 + #x9060916 + #xfa01fb04 + #xf7f8fdf4 + #xfffcfafb + #xf3ff0908 + #x151a00e9 + #x1803020c + #x400010f + #xa0a1116 + #xfe00f707 + #xf2f8fef3 + #x200fafa + #xfd010200 + #x170df7f3 + #xffc0a15 + #x1010313 + #xd0e1613 + #xfff809 + #xf1fafdf5 + #x8fdf8f9 + #xfffefc01 + #xe01fb00 + #x5041616 + #x304050d + #xe12160c + #x1fcfa08 + #xf0fafcf9 + #x7f6f8fa + #xfdfdfd04 + #x3000606 + #x3121a0d + #x7030104 + #xd12140c + #xfbfb06 + #xeef9fefd + #xf4fcf9 + #xfc01ff04 + #x50e02 + #x111d1103 + #x9fdfc02 + #xa11120f + #xfcf903 + #xeefb0100 + #xfaf6fdf5 + #x307fdfe + #x1090bfe + #x1c1a0500 + #x3f7fc0b + #x9121412 + #xfbf503 + #xf0ff0501 + #xfafafbf3 + #xc07f9f9 + #x2070703 + #x1e0e0102 + #xfef60015 + #xa13140f + #xf8f405 + #xf6020803 + #xfdfaf8f6 + #x1105f4f7 + #xff02080e + #x15050405 + #xfbfa0617 + #xc131109 + #xfdf6f805 + #xfa050a05 + #xfdf6fbfc + #xe00f2f9 + #xf6001217 + #xc070900 + #xfe010a12 + #xa100c02 + #xfbf8fb02 + #xfc060b05 + #xf9f600ff + #xbfff3f9 + #xf2041916 + #xc0d06f9 + #x206080a + #x70e0700 + #xfafafa01 + #xfd080c04 + #xf8fd05ff + #xb01f2f6 + #xf50d1a0f + #x140efff4 + #x7060107 + #x70b0202 + #xfafcfb05 + #x10a0d03 + #xfd0303fe + #xe00eff5 + #xfa10150d + #x1908f9f6 + #x703fe0b + #xa060003 + #xfbfd0108 + #x60b0cff + #x304ff00 + #xdf9effb + #xfd0d100f + #x16fefafb + #x400ff13 + #x8000104 + #xfe030b04 + #xa0a08fd + #x700000a + #x4f5f601 + #xfa091011 + #xdfa0100 + #x113 + #x602 + #x30a07fb + #x607fffc + #xfa090d + #xfaf80006 + #xe1008 + #x20402f8 + #xb0e + #xfb060300 + #x80b02fd + #x3fcff + #xfbfc0f08 + #xff040202 + #x30e09fd + #x90afef7 + #x303090c + #x109fffd + #x8090204 + #xfe00fc01 + #xfc010aff + #xa09ff00 + #x60800fb + #xe05fc00 + #x5030b11 + #x805fa00 + #x80a0407 + #xfefb00 + #xfe0001fc + #xf05fe03 + #x202fe00 + #xe000005 + #x3051115 + #x800fa03 + #xb0c0504 + #xfef9fa00 + #xfbf9fdfe + #xd020305 + #xfb010106 + #xaff0705 + #x91615 + #x3fcfd03 + #xd0b0102 + #xf6f6fc01 + #xf5f60000 + #x8050801 + #xfd070304 + #xa010700 + #x10f1615 + #x2fd00ff + #xd06ff04 + #xeef80002 + #xf4fa02fb + #x80905f9 + #x50a0104 + #xb0204fe + #x4121517 + #x4fffffb + #x7010108 + #xeb0002ff + #xfcfdfff2 + #xa06f9f6 + #xc070107 + #xa000102 + #x712161b + #x6fffcf8 + #x5020709 + #xf203fefd + #x4faf8ed + #x4fcf100 + #xb070909 + #x7030206 + #x8101c18 + #x6fefafb + #x6040607 + #xf800f8fd + #x5f6f6f0 + #xfcf3f60a + #x80e1204 + #x9060307 + #x60f1c13 + #x5fefafe + #x7030206 + #xf6f9f800 + #xf6faf5 + #xf3f3000d + #xb180ff9 + #xf060206 + #x30e1813 + #x5fefc00 + #x6000006 + #xeef7fe04 + #xfefd00f4 + #xf3f90307 + #x151b06f0 + #x11010108 + #xd1616 + #x600ffff + #x1fbff08 + #xe8fb0303 + #x406ffec + #xf8fcff03 + #x1a14fcf0 + #xdfd0410 + #x10f1719 + #x90300fc + #xfcf8000b + #xeb030500 + #xf08f7e4 + #xfbf7f708 + #x1709fbf8 + #x4fe0c16 + #x5111816 + #xb04fdfb + #xf8f9030c + #xf60700fa + #x1200eee5 + #xf5eef914 + #xc0704fc + #x2081214 + #xb12160c + #xc02fc00 + #xf7fd050b + #xfe04fcf6 + #xcf7eced + #xedec041c + #x70f0bf7 + #xa0f110d + #xd100d05 + #xb00ff09 + #xf9000209 + #xfefffaf4 + #x1f4f2f5 + #xeaf41117 + #xc1b07ec + #x140e0907 + #xb090409 + #x8000712 + #xfd00fe08 + #xf8fcfaf2 + #xfdf8f8f9 + #xf1fe100c + #x181afbe8 + #x1505050a + #x5030211 + #x8041113 + #xfdfc09 + #xf4fdf9f3 + #xfcfbf8 + #xfa020903 + #x1d0ef3f0 + #xdff0a11 + #x1020517 + #xa0b160c + #xf9fd0b + #xf1fef8f5 + #x6fcfbf6 + #xff000003 + #x1601f5fc + #x2011316 + #x2030812 + #xd101608 + #xfff7000c + #xf4fdf6fa + #x6f7fbf6 + #xfdfdfe09 + #x8000100 + #x111711 + #x5020705 + #xd131308 + #xfff8000a + #xf4fcf8fe + #xfff5fdf5 + #xfcfe000a + #x1060aff + #xc1b1307 + #x5ff0102 + #xd12110c + #xfef8fe09 + #xf2fcfc00 + #xf8f8fef2 + #x10004 + #x20d08fc + #x1c190802 + #xf9fe0a + #xc12130f + #xfff8fa09 + #xf3ff0000 + #xf8fcfbef + #x903fdfe + #x60d0400 + #x1e0e0302 + #xf9f60215 + #xe13150c + #xfff5f80a + #xf6020201 + #xfbfcf7ef + #xdfff8fb + #x407050b + #x18050403 + #xf7fa081b + #xf141305 + #xfcf3fa0b + #xfa050503 + #xfbf8f8f5 + #xbfcf5fd + #xfe050d14 + #xd050701 + #xfa000d17 + #xf120c01 + #xf9f5fc09 + #xfd070703 + #xf7f7fdf9 + #x8faf6fd + #xf8091614 + #xb0c06f9 + #x40d0f + #xd0e0700 + #xf9f8fc08 + #xa0a01 + #xf6fc01fa + #x8faf6fb + #xf9111810 + #x100e00f3 + #x306080b + #xc0b0301 + #xfaf9fa09 + #x20c0bff + #xf90401fa + #xafaf3f7 + #x16140d + #x1606f8f2 + #x6040210 + #xd060004 + #xfbfaff0b + #x60e0afd + #x5fefd + #xaf5f1f9 + #x3130f11 + #x12fef9f7 + #x5000316 + #xb010005 + #xfdff0606 + #x90e06fa + #x500fe04 + #x3f1f500 + #x30f0f13 + #xafbfffa + #x3ff0819 + #x3000204 + #x1070afe + #x80b01fb + #x3fa060d + #xfbf4fd06 + #xd120f + #x20001f9 + #xff0a12 + #xfc040400 + #x70afffe + #x802fb01 + #xfa020e07 + #xf9fe0402 + #x8110d00 + #x309faf9 + #x31006 + #x1050002 + #xa08fd04 + #x400fc04 + #xfa090b00 + #x50501ff + #xa0c01fc + #xb07f9fd + #x2040c0a + #x904fc02 + #x9060109 + #x3fdfd04 + #xfe0902fc + #xd0200ff + #x603fb03 + #xb00ff03 + #x2060f10 + #xafefc05 + #xa080507 + #xfafc04 + #xfd02fefe + #xaff0401 + #xfe0b + #x7ff0603 + #x10a1313 + #x4faff04 + #xe090401 + #xfbf7fc05 + #xf8fcff00 + #x5010a00 + #xff02020c + #x40409ff + #x20e1511 + #xfffb0200 + #xe050100 + #xf3f8fd07 + #xf5fc02fb + #x60808fa + #x6060208 + #x50703fb + #x6111512 + #xffff01fd + #xa000303 + #xf1fdff08 + #xf80000f2 + #xa09fff6 + #xc040107 + #x605ff00 + #xa121714 + #xfefb + #x3000805 + #xf701fd04 + #xfffff8eb + #x900f5fc + #xc03050a + #x5030108 + #xa131c13 + #x1fffafb + #x2020a04 + #xfefff802 + #xfaf3ed + #xf5f906 + #x80a0d06 + #x6040409 + #x9131d0f + #x1fcf8ff + #x4030804 + #xfef8f703 + #xfbf8f5f3 + #xf7f3040a + #xb140dfe + #xb040407 + #x613190f + #xfbfb00 + #x4000403 + #xf5f5fc05 + #xf9fcfaf4 + #xf3f90b05 + #x151803f5 + #xd010308 + #x5131614 + #xfdffff + #x1fc0405 + #xeff90006 + #xff04faed + #xf7fe0601 + #x1d11f9f2 + #x8fe040f + #x4121817 + #x200fffb + #xfdf90508 + #xf1000203 + #x807f5e5 + #xfbfbff05 + #x1b07f6f7 + #x2000b17 + #x7141b13 + #x601fcf9 + #xf7f9070b + #xfa0500fe + #xe02ece3 + #xf7f2ff10 + #x1103fdfc + #x61318 + #xc17190c + #x800fafd + #xf6fd090a + #x103fcf9 + #x8f8e7eb + #xeeef0b19 + #x80902f8 + #x70f1410 + #xf151005 + #x7fcfd06 + #xf9000808 + #x200f9f5 + #xf3ecf4 + #xe9f51718 + #xe1501f0 + #x10100e08 + #xe0f0507 + #x3fb050c + #xfdff0505 + #xfdfcf6f5 + #xfaf5f4f9 + #xed001a0b + #x1b16f8ea + #x13090708 + #x9070211 + #x102100d + #xfffb0206 + #xf9fdf5f6 + #xfdfaf9f7 + #xf7070f03 + #x1f0aefef + #xb020810 + #x4030717 + #x30a1509 + #xfef70308 + #xf8fdf3fa + #xfbfaf4 + #xfd040503 + #x1bfff2f8 + #x1050f17 + #x3030e12 + #x7121404 + #xfaf5050a + #xf9fcf2fd + #x2faf9f2 + #xfeff0009 + #xdfcfdff + #xff0f1516 + #x3040c06 + #xa151004 + #xf8f7070a + #xfbf8f4ff + #xfdfaf9f2 + #xfcfd050a + #x40405fd + #x918130d + #x2010500 + #xc130f08 + #xf9f9040a + #xfaf8f900 + #xf7fcfaf2 + #xfeff0804 + #x40c05fb + #x19180b05 + #xfffc0007 + #xd13110b + #xfaf8000b + #xf8fbfd00 + #xf800f8ef + #x20004fe + #xa0e00fe + #x1e0f0403 + #xf9f90115 + #xe141407 + #xfbf6000d + #xfaffff00 + #xfbfff4ee + #x7fffffb + #xb090108 + #x17060505 + #xf5fb0a1c + #x10161300 + #xf9f2000e + #xfd010002 + #xfcfbf3f1 + #x6fafbfc + #x6050811 + #xe070603 + #xf8001119 + #x11140dfc + #xf6f2000d + #x40303 + #xf8f9f7f5 + #x3f7fafe + #x91214 + #xa0b04fd + #xfd041212 + #x100f07fd + #xf5f5000c + #x2070700 + #xf5fefbf8 + #x1f7fcfa + #xff111610 + #xe0dfef6 + #x70d0c + #xe0b04ff + #xf7f7000c + #x50b08fe + #xf803fcf9 + #x3f7faf6 + #x616130f + #x1308f8f3 + #x306080f + #xd060201 + #xf9f7010d + #x80e06fb + #x5fafb + #x3f5f6f7 + #xc140f12 + #x10fff4f6 + #x4030816 + #xb020103 + #xfafa0709 + #xc0f02fb + #x401fb00 + #xfff1f6fd + #xb0f1015 + #x7fdf8fa + #x3000d18 + #x5000205 + #xfe010902 + #xd0cfffc + #x2fd0207 + #xf8f1fc04 + #x90e1310 + #x1fcfa + #x1311 + #xff000305 + #x50903fd + #xa07fcff + #xfdfe0c0a + #xf7f90206 + #x7101205 + #x8fbf8 + #xff021209 + #xff050202 + #x805fc03 + #x9fdfe05 + #xfc0d0a06 + #xfd0004fc + #xd1006fb + #xa01f600 + #xb0c05 + #x6010101 + #x802000a + #x5fc0007 + #x1110200 + #x50101fa + #xc06fd03 + #xbfefb04 + #x2090b0b + #x9fe0003 + #x8030607 + #x2fb0006 + #x408fc00 + #x6ff02fd + #x5fe000e + #x5ff0305 + #x20a0f0f + #x2fa0204 + #xa060700 + #xfdf8ff07 + #xff00fd01 + #x10106fe + #xfd0510 + #x2050500 + #x40d120e + #xfcfb0402 + #xc0604fc + #xf7f7ff0b + #xf9fe01ff + #x708fa + #x401070a + #x40b00fc + #x70f140b + #xf90003ff + #x80103fe + #xf5f9000c + #xf90200f5 + #x80b00f5 + #x9010507 + #x709fc00 + #xa11160d + #xfd02fffd + #x2000500 + #xf9fc000b + #xfd03f8ee + #xc05faf8 + #x900050a + #x603fe07 + #xb13190c + #xfaff + #x30901 + #xfbfd06 + #xfffff0ef + #x4f9fa00 + #x6050a0b + #x602050b + #xc171c0b + #xfdf800 + #x1060800 + #xf6fa04 + #xfafaeff5 + #xf8f50503 + #xa0f0b03 + #x8020709 + #xd18160c + #xfef9f901 + #x2040600 + #xfaf4fd05 + #xf8fbf5f8 + #xf3fc0d00 + #x151404fa + #xa020508 + #xa161310 + #xfdfbfd00 + #x10600 + #xf3f60106 + #xfd00f8f3 + #xf6020afd + #x1e0ef9f5 + #x600040e + #xb161714 + #xfdfffefc + #xfbfe0602 + #xf4fc0305 + #x504f2ea + #xfb010300 + #x1b02f5f7 + #xa19 + #xb161b11 + #x100fafb + #xf7fe0906 + #xfb000200 + #xc01e9e7 + #xfafa020a + #x13fef9fc + #xff06131c + #xe1a1a08 + #x4fef7fe + #xf6000b07 + #x201fffb + #x9f8e3ed + #xf1f50b13 + #xa02fffc + #x30e1715 + #x131a1203 + #x3faf903 + #xf8020c04 + #x3fffaf6 + #x1f1e7f7 + #xe9fb1a13 + #xd0bfef3 + #xd12120b + #x13130605 + #xfff9020a + #xfb020a00 + #xfcf6f6 + #xfcf0f0fc + #xec061c0b + #x190ef7ec + #x110e0909 + #xf0a040e + #xfbff0c0b + #xfdff07ff + #xfdfaf4f9 + #xfaf5f7fa + #xf60e1402 + #x1f05efec + #xb070511 + #x9040a14 + #xfc0b1108 + #xfafb0701 + #xfcf9f3fc + #xfefaf8f6 + #xff0c0902 + #x1bfbf0f4 + #x2060c1a + #x5041110 + #x2130f04 + #xf6fa0706 + #xfef6f3ff + #xfffbf6f4 + #x40406 + #xef8f8fb + #xd141c + #x3051104 + #x9160b04 + #xf4fc0909 + #xfff3f600 + #xfdfcf4f4 + #xfdff0708 + #x30001fc + #x8161613 + #x20509fe + #xd140a06 + #xf4fd070b + #xfcf3f9fe + #xf9fef4f5 + #xfb000d02 + #x60902fb + #x16160f09 + #xff000005 + #xe120d07 + #xf6fd050b + #xf9f6fdfd + #xf900f4f4 + #xfe020bfd + #xd0bfefd + #x1d0f0705 + #xfafc0013 + #xf151103 + #xf7fa040d + #xfafbfffe + #xfefff2f2 + #x10203f9 + #x1005fe04 + #x15080407 + #xf7fc0a1d + #x11180efc + #xf5f6050f + #xfdfd0000 + #xfefaf0f3 + #x1fffefb + #xb02050b + #xd070508 + #xf700141a + #x131609f7 + #xf3f5060f + #x200 + #xfbf8f1f6 + #xfffafefd + #x5070f0e + #xa0a0504 + #xfb061612 + #x121104f8 + #xf1f7050e + #x20205ff + #xf8fcf5f9 + #xfdf9fffa + #x30f140e + #xd0cfffc + #xa110d + #xf0c02fb + #xf3f8050c + #x40706fb + #xfb00f7fb + #xfdf9fdf5 + #xa15130c + #x1107f7f8 + #x20a0b0e + #xc0802fe + #xf5f7070c + #x90c04fa + #x2f7fe + #xfef8f8f4 + #x1214100f + #xf00f3fa + #x4070c14 + #x9040200 + #xf5f90b09 + #xe0c00fb + #x5fff800 + #xfaf4f5fb + #x120f1211 + #x6fbf4ff + #x4041115 + #x5010103 + #xf8000c03 + #x100afdfc + #x2fcfe06 + #xf5f3fa02 + #xe0d170e + #xfef700 + #x5160e + #xff0305 + #xff0506ff + #xf03fcff + #xfe000609 + #xf3f70103 + #xa111603 + #x103f7ff + #xfe081505 + #xfe000404 + #x707fd00 + #xc00fd04 + #xfa080a07 + #xf9ff0500 + #xc120dfc + #x704f6fe + #xff0a1003 + #x4030201 + #x7000006 + #x2fd0406 + #x60e0509 + #x300f9 + #x100afffe + #xaf7fa07 + #x50e050a + #x40102fe + #x4000606 + #xfd0407 + #xb0a0006 + #x200fefb + #x9ff000a + #x4fa0109 + #x60a090d + #x1fd0201 + #x50409ff + #xfcfc0307 + #x800ff05 + #xff010000 + #x1fc090d + #x1030504 + #x60c0f0b + #xfafe0501 + #x80704f9 + #xf8f9020a + #xfd0101 + #x702fe + #xff000c08 + #x50a00ff + #x70f1108 + #xf7010400 + #x70400fa + #xf5f9050d + #xfc0101fb + #x60bfff8 + #x3030a03 + #xa07fa00 + #x9101208 + #xfb050000 + #x20200ff + #xf8fb060c + #xff04faf4 + #xc08f9f7 + #x4020707 + #xa01fd07 + #xb13140a + #x103fb00 + #x40301 + #xfcfb0506 + #x100f0f3 + #x9fff9fb + #x203080c + #x7fe040b + #xd171409 + #x2fdf803 + #x1080500 + #xfff80102 + #xfff8eefa + #xfdf902ff + #x40a0c0a + #x6000909 + #x111a1309 + #xfff8f904 + #x30803fd + #xf8f50001 + #xfaf6f3fd + #xf4ff09fd + #x110f07ff + #x6030708 + #x1219100d + #xfbf9fb03 + #x10503fc + #xf2f70203 + #xfcfaf7f9 + #xf60607fa + #x1b0bfef6 + #x502050f + #x1016140f + #xfbfdfc00 + #xfe0303fe + #xf2fb0502 + #x3fff4f1 + #xfe0902fd + #x1a01f6f6 + #x10a1a + #x1017190d + #xfffff8ff + #xf9020502 + #xf80005ff + #xafeebed + #xfe010105 + #xffbf8fb + #xff05141f + #x121b1807 + #x2fcf500 + #xf9050804 + #xfe0101f8 + #xaf5e5f1 + #xf6fc080e + #x7fdfdfb + #x10d1a19 + #x161c1101 + #x1f7f504 + #xfb060b01 + #x1fffdf4 + #x3ece6f9 + #xee001511 + #x804fff5 + #xa14160e + #x18180702 + #xfcf6fd0a + #xfd070afb + #xfffcf7f5 + #xfceaefff + #xef0d1b0b + #x1408f8eb + #x10120b0c + #x150c030a + #xf7fc060d + #xfd0505f9 + #xfdf9f5f8 + #xf9eef6fe + #xf9161304 + #x1a02f2e8 + #xe0b0614 + #xd040a11 + #xf9070b0c + #xfa0203fd + #xfdf6f5fc + #xfaf6f9fa + #x3140900 + #x16f8efee + #x6060b1c + #x605130e + #x1110a08 + #xf6000304 + #xfef3f7fc + #xfdfaf5f8 + #x50b0503 + #x9f6f5f7 + #x309161f + #x4081204 + #xb130706 + #xf401040a + #xfdf1fafa + #xfdfaf3f9 + #x40904 + #xfdfcfb + #x8111b18 + #x30909fe + #x10110607 + #xf503050d + #xf9f2fcf8 + #xfcfcf4fb + #xfc030e01 + #x205fffa + #x1315150c + #x204ff03 + #x11100a07 + #xf701050e + #xf5f5fef6 + #xfdfbf4fa + #xfd070bfc + #xd07fcfb + #x19100b08 + #xfeff0012 + #x12130d01 + #xf800050f + #xf5f9fef8 + #xfbf3f7 + #x803fa + #x1202fcff + #x160a060a + #xf9fd0a1a + #x14160bfb + #xf6fd0612 + #xf9fcfffa + #x1f7f2f7 + #x105fefd + #xd000304 + #xc07070e + #xf8001419 + #x161603f6 + #xf3fc0813 + #xfcfd01fa + #xfef4f1f8 + #xff00fefe + #x6030c07 + #xb08070b + #xfb071713 + #x1711fef6 + #xf1fd0911 + #xfe0004f8 + #xfbf5f3fb + #xfcfefffc + #x50d1106 + #xd090404 + #xc130e + #x130afef9 + #xf2fc080d + #x504f6 + #xfcfaf7fd + #xfbfefef7 + #xa131206 + #x1006fcfe + #x40d0e0f + #xd08fffa + #xf3fc090b + #x50902f6 + #x1fcf800 + #xfcfdf7f6 + #x12131108 + #xefff500 + #x60a0d13 + #xa07fffd + #xf3fd0c09 + #xb0a00f7 + #x4faf903 + #xfaf9f3fb + #x13101309 + #x7f9f505 + #x6081214 + #x604ff00 + #xf3010d04 + #x1006fdf8 + #x3f8fd07 + #xf6f5f602 + #xe101805 + #x1f8f809 + #x30a160d + #x1000004 + #xfa0608ff + #x1001fdfa + #xfefc020c + #xf3f7ff03 + #xa1417ff + #x2fcf906 + #x10e1405 + #xfd000404 + #x20700fe + #xbfdfefe + #xfc04070d + #xf6fd03ff + #xc170ff8 + #x7fcf804 + #x2100c02 + #xfe020600 + #x702fd03 + #x6fe0104 + #x10e070a + #xfe0203f9 + #xf1102fa + #xbf9f905 + #x50f0607 + #x30303fd + #x3ff0503 + #xfd010606 + #xe060708 + #x102f900 + #xe02ff01 + #xf6010c + #xc09050d + #x20000 + #x20309ff + #xfc010606 + #xdff0406 + #x100fa05 + #x2fd0808 + #xfffe0609 + #x9080b0b + #xfc000202 + #x50704f9 + #xf9ff0507 + #x3fc0502 + #x4fe05 + #xfc020f03 + #x4060302 + #x80c0e06 + #xf9030301 + #x706fdf9 + #xf6fd070a + #xffff03fc + #x608fe00 + #xfe080c00 + #xb05fe00 + #x90f0d06 + #xfc060101 + #x503faff + #xf5ff0a09 + #x2fef7 + #xe08f9fa + #x1070703 + #xdfefd04 + #xb110e0b + #x304fd02 + #x202fd03 + #xf7000a05 + #x300f5f6 + #xc00f7fc + #x5070b + #x7fb0508 + #xe150f0c + #x6fffa03 + #x2050003 + #xf8ff0700 + #x3f7f2fa + #x1fcfc00 + #x1070b0c + #x3ff0b07 + #x13180d0a + #x2f8fb06 + #x50801ff + #xf5fc02fe + #xfdf0f7ff + #xfa0003ff + #xa0c0c04 + #x3040906 + #x16170d0a + #xfcf6fd07 + #x60600fc + #xf0fb0200 + #xfbf4fcfc + #xfc0801fb + #x150b03f8 + #x304060d + #x1515110c + #xfaf9fd07 + #x305fefd + #xf0fd0400 + #xfafaf4 + #xafdfd + #x1502faf5 + #x1020919 + #x1216160a + #xfdfbfa05 + #x40000 + #xf40005fd + #x6faf2f0 + #x406fd03 + #xdfbf7f9 + #xff03151f + #x141a1604 + #x1f9f605 + #xfe050403 + #xfa0201f8 + #x7f2eaf2 + #xfd00040c + #x3fbfcfc + #x10c1e1b + #x191d0e00 + #x1f5f609 + #xff080800 + #xfe01fdf3 + #x2e8ebf9 + #xf6030f10 + #x200fff6 + #x8151b10 + #x1c170600 + #xfbf3fa0e + #xa07f9 + #xfefff7f3 + #xfae4f2ff + #xf50f160d + #xb04fbeb + #x1016100b + #x180e0307 + #xf5f70312 + #x10902f7 + #xfcfaf5f7 + #xf4eaf9ff + #x191205 + #x1401f2e6 + #x110e0914 + #x1005090e + #xf7010812 + #x7fdfb + #xfbf6f6f9 + #xf5f2fbfd + #xa170901 + #xffaedeb + #xb060d1e + #x706110d + #x10a080f + #xfc04fc05 + #xfaf4f9f9 + #xf9f7f8fb + #xe0f0501 + #x5f5f0f6 + #x5061a1e + #x30b1106 + #xd0c060a + #xfa03ff0d + #xf8f3fcf5 + #xfcf7f6fd + #x7070802 + #xfefaf7fd + #x80e1f18 + #x50d0700 + #x130a0608 + #xfb040210 + #xf3f5fcf1 + #xfcf6f7fe + #x60b00 + #xfbfc + #xf151c0e + #x508ff04 + #x130a0806 + #xfc030410 + #xf0f9fbef + #xfef6fafd + #xff0b0bfe + #xa04fbfa + #x16141008 + #x100fd0f + #x120e0b02 + #xfd010612 + #xf1fbfbf2 + #xf5fafa + #x30d01fe + #xf00fafb + #x140d090c + #xfcfc0918 + #x151208fc + #xfa000715 + #xf5fdfbf5 + #x1f4f7f7 + #x508fc00 + #xbff00ff + #xe080911 + #xf9001617 + #x191100f8 + #xf7000918 + #xf8fefef6 + #xfef2f5f8 + #x303fc01 + #x4020701 + #xa070c11 + #xfb081811 + #x1a0cf9f6 + #xf5000b16 + #xfa0000f3 + #xfaf1f6fb + #xff00 + #x40a0c01 + #xc080a09 + #xe140e + #x1606f9f9 + #xf5010b11 + #xfc0401f1 + #xfaf3f8fd + #xfe00fefb + #xa120d00 + #xf050304 + #x30e0f10 + #x1004fbfa + #xf6000a0c + #x9fff0 + #xfef6fbff + #xff00f8f9 + #x10130d01 + #xcfffc03 + #x70c0e13 + #xc05fbfc + #xf4000b0a + #x809fcf2 + #xf6fc01 + #xfefcf2fe + #x12121002 + #x6f8fa0a + #x80a1213 + #xa03fb00 + #xf4050b07 + #xd06fbf3 + #xf6fe07 + #xfbf6f503 + #xe131400 + #x1f5fd0e + #x60d150e + #x600fd03 + #xf9090801 + #xd01fcf3 + #xfcf9020c + #xf6f6fd05 + #xa1814fb + #xf5000b + #x5101206 + #xff0204 + #xa01fd + #x8fffdf6 + #xfbff070f + #xf6fb0200 + #xd1c0df6 + #x3f7ff07 + #x8130905 + #xfd010501 + #x605fefe + #x1fe00fe + #x6090e + #xfb0001fa + #x121703f7 + #x5f5fe07 + #xc110309 + #xff0504fe + #x4ff0202 + #xfe010405 + #xb09080a + #x103fbfc + #x110afefe + #x2f3000b + #xc0b020d + #x20500fd + #x1020500 + #xfe050506 + #xc020a02 + #x2fdf80b + #x6000301 + #xf9fc070d + #xb040c07 + #xff08 + #x30803fb + #xfd040505 + #x4fe0700 + #x1fdfe0d + #xfc040b01 + #xff030705 + #x7070d04 + #xfc020206 + #x707fbfb + #xfa010706 + #xfe0106fc + #x5020106 + #xfc0c09fe + #x80401ff + #x80c0b05 + #xff060103 + #x702f700 + #xf8020907 + #xff0400f7 + #xb03fe00 + #x20d0400 + #xbfe00ff + #xa0f090b + #x505ff02 + #x5fffa06 + #xf7050b05 + #x300f9f5 + #xe00f8fe + #x307030b + #x5f90403 + #xe110b0f + #x9fffc04 + #x400ff06 + #xf8050701 + #x3f8f7f7 + #x5fcfa01 + #x2060a0f + #xfe0903 + #x13140c0c + #x4f8fc06 + #x6020101 + #xf7030200 + #xfef1fafa + #xfefefe03 + #x50a0d07 + #x70903 + #x17130b08 + #xfdf5ff0b + #x70400fb + #xf3000000 + #xf8f1fff9 + #x60000 + #xf0d08fb + #x3080609 + #x15110e07 + #xf8f7000c + #x703fdfb + #xf2ff0001 + #xf9f9fef3 + #x809fbfd + #x1106fef7 + #x2040b16 + #x13141207 + #xfaf9ff0c + #x402fdff + #xf40201ff + #xfbf8ef + #xa04fa01 + #x9fef7fb + #x3151d + #x13191203 + #xfff7fb0a + #x2020102 + #xf90400fb + #x2f4eff0 + #x400000a + #x1fafaff + #xc1f19 + #x191c0c00 + #xfff2fa0b + #x20505ff + #xfe03faf7 + #xfeeaeff6 + #xfc010c0f + #xfffefdfc + #x7181e0f + #x1e1803ff + #xf9effc12 + #x40905f8 + #xff00f5f7 + #xf6e5f4fb + #xfc0c130d + #x402fbf1 + #x101b150a + #x1b0d0104 + #xf3f30218 + #x60b00f4 + #xfefbf3f8 + #xeee9fbfe + #x4171306 + #xc01f2e9 + #x14130d0f + #x1005060b + #xf4fb0a19 + #x607f8fa + #xfbf6f5fa + #xeef2fdfc + #x10170c00 + #xbfbeaee + #xf07101a + #x7070e0e + #xff030c14 + #x402f704 + #xf8f5f8f9 + #xf3f7fcfc + #x131007fe + #x2f4eafa + #x8061a1c + #x50d0e0a + #xa060a0d + #x100fc0e + #xf4f6f9f5 + #xf8f7fafd + #xd0908ff + #xfcf5f102 + #x50f1f15 + #x70f0604 + #x10050908 + #x211 + #xf1f9f8f2 + #xfaf4fcfd + #x5090900 + #xfffbf801 + #xb181e0a + #x90aff05 + #xf050a06 + #x10811 + #xf0fbf5f1 + #xfaf3fffb + #x30c07ff + #x6fffafc + #x121a1407 + #x501ff0d + #xe0a0a03 + #x10811 + #xf1fcf3f4 + #xfcf4fff7 + #x70e0100 + #xdfff9f9 + #x14140b0c + #xfefc0714 + #x120f08ff + #xfe000b16 + #xf5fbf4f6 + #xfcf6fcf5 + #xb0afd01 + #x8fdfbfd + #xf0b0d13 + #xf9001415 + #x180e00fa + #xfb000e1a + #xf8fdf7f6 + #xfbf4f9f5 + #x903fe03 + #x1000000 + #xa081012 + #xfa0a1810 + #x1a07f9f7 + #xfa011019 + #xf900faf3 + #xf7f3f9f7 + #x4000001 + #x2080501 + #xa09110c + #x10130d + #x1600f7f8 + #xf9021014 + #xfc02faf0 + #xf6f3fbf9 + #x10000fe + #x90e0600 + #xc090a06 + #x510100f + #xffff9fa + #xf9030e0f + #x5f8ef + #xf8f5fcfa + #x100fbfc + #x101107ff + #xb030307 + #x70d1112 + #xb00fafd + #xf9030b0d + #x606f6f0 + #xfbf6fdfd + #x2fdf6ff + #x121209ff + #x5fb000b + #x80c1312 + #xc00f900 + #xf8050a0b + #xc04f6f0 + #xfaf7ff04 + #xfff5f702 + #xf130b00 + #xfff6030f + #x80e150d + #xafcfb05 + #xfc090806 + #xb01f8ef + #xf9f8020b + #xf9f3ff04 + #xe190dfd + #xfcf5060d + #x9121008 + #x3fb0006 + #x30a03ff + #x600f8f1 + #xf8fd080e + #xf5f70400 + #x111c08f8 + #xfdf80708 + #xc120a05 + #xfdff0404 + #x806fefd + #xf9f8 + #xfe020d0e + #xf9ff01fc + #x181700f6 + #xfef70207 + #x100f0509 + #xff050301 + #x701fe00 + #xfe01fe01 + #x5050e09 + #x1fbfe + #x190dfcfa + #xfdf7010b + #x1109060c + #x2060003 + #x1000402 + #xfd050306 + #xd040a04 + #x3fff706 + #xe02ff00 + #xf8f8060e + #xc040909 + #x303fd05 + #x2050100 + #x4040404 + #x40707fe + #xf8020d + #x40501 + #xf9030a09 + #x5060dfe + #x1ff030c + #x707fcfd + #x1040504 + #xfe0603fc + #xfffb080a + #xff0d05ff + #x30605fe + #x50a0a01 + #x30407 + #x800f701 + #xfd040707 + #xff0800f8 + #x5000601 + #x60e0002 + #x70000fb + #x80c0809 + #x6050104 + #x5fbfa08 + #xfd070807 + #x205fbf5 + #x800ffff + #xa09000a + #x3fd00ff + #xc0e0b0f + #xa00fe04 + #x2fb0009 + #xfe080605 + #x3fdf7f5 + #x5fbfb02 + #x7040711 + #xfc000501 + #x12100e0b + #x6fafd07 + #x2fe0502 + #xfe070203 + #xfef6f9f6 + #xfbfe05 + #x6070e0c + #xfd070600 + #x15100d06 + #xfdf6000b + #x40003fb + #xfd03ff04 + #xf7f7fef6 + #x2 + #x90d0b00 + #x20b0404 + #x140f0c02 + #xf6f80310 + #x500fff8 + #xf8fffe05 + #xf4fcfef2 + #x603fefd + #xf0b00fa + #x506080f + #x12110f04 + #xf6fa0410 + #x400fcfb + #xf8000004 + #xf9fff8ee + #xb01fcfd + #xa00f900 + #x2051619 + #x13170d03 + #xf9f9010e + #x3ff00ff + #xfc02ff00 + #xfffaf2ee + #x8fe0003 + #x1faf905 + #xd1f16 + #x191a0800 + #xfaf5ff0d + #x20005fc + #x2fafe + #xfcf1eff3 + #xfe090a + #xfefcfe02 + #x6191e0d + #x1e1702fd + #xf5f00012 + #x40605f4 + #x2fff5fd + #xf2ebf4f8 + #xff07120a + #x100fcf9 + #x111f1606 + #x1c0d0001 + #xeef2061a + #x70800f1 + #xf9f2fe + #xebeef9fb + #x5121403 + #x700f3f1 + #x17180e0a + #x1306020a + #xeef80d1c + #x907f7f5 + #xfef5f4ff + #xe9f5fcfc + #x111611fb + #x9fae9f5 + #x130c1114 + #x906090f + #xf7001217 + #x800f500 + #xf8f4f7fe + #xeffafcfb + #x16110af7 + #x3f2e801 + #x9091c17 + #x60d0b0e + #x205110d + #x4fafd09 + #xf4f6f7fc + #xf5f9fcfb + #x110b07f9 + #xfdefef0a + #x4111f10 + #xa0f0608 + #x8040e07 + #x1fb060c + #xf3f9f5fa + #xf7f6fffa + #x80a07fc + #xfdf3f809 + #x81d1e09 + #xe0a0004 + #x7060d05 + #xfe0c0b + #xf4faf1f9 + #xf7f600f7 + #x70d05fe + #x3f9fb01 + #x111f1304 + #x8010008 + #x60a0b05 + #xff000d0d + #xf6f9effa + #xf6fa00f3 + #xb0d02ff + #x7fbfafd + #x15190b09 + #xfd080f + #xb0e0801 + #xfe010d12 + #xf9f6effb + #xf7fbfcf1 + #xe08ff00 + #x7fbf8fd + #x130f0e12 + #xf9011212 + #x120d02fc + #xfc011218 + #xfbf7f2fa + #xf7fbf9f3 + #xc020100 + #xfdfb03 + #xd0b1512 + #xfb0a140f + #x1505fbf7 + #xfb031717 + #xfbfaf5f7 + #xf6f8f8f5 + #x7000400 + #x20005 + #x90d160c + #x11110c + #x11fef7f7 + #xfb051811 + #xfdfef5f4 + #xf4f7f9f7 + #x20003fd + #x7080203 + #xa0f0f06 + #x7110e0c + #x9fbf8f9 + #xfb06140c + #x100f2f3 + #xf4f8fbf7 + #x201fffb + #xf0b0201 + #xa0b0707 + #x80f110f + #x5fdf9fd + #xfc060f0b + #x600f1f3 + #xf6fafbfa + #x3fcfbfc + #x120c0301 + #x602050d + #x80f140f + #x7fdf900 + #xfd060d0d + #xbfff2f1 + #xf7fafc00 + #xf6fc00 + #x11100502 + #xfb0811 + #x911140b + #x8f9fa03 + #xff080c08 + #xbfef2f0 + #xf6fb0009 + #xf8f30100 + #x11130501 + #xfafa0b0e + #xb131006 + #x2f70006 + #x3090800 + #x6fef2f1 + #xf7fd070d + #xf4f806fe + #x171804fd + #xf9fd0909 + #xe120b04 + #xfcfa0406 + #x90601fd + #x2fef2f8 + #xfa020e0c + #xf5fe04fa + #x1e14fff8 + #xf8000409 + #x120e0803 + #xfb020506 + #x701fe00 + #xfff601 + #x61007 + #xfd01fdfc + #x1e0bfaf9 + #xf8fd020e + #x10080a06 + #x2050108 + #x3ff0004 + #x100fc06 + #x5080d01 + #x2fef904 + #x1502fcfe + #xf6fd0512 + #xc050d03 + #x601ff0d + #x1030203 + #x4040306 + #x60707ff + #xf8fe0d + #x5010201 + #xf6000b0e + #x6050fff + #x3ff000e + #x403ff00 + #x6030503 + #x20b0000 + #xf9fa0e07 + #x2070301 + #x70902 + #x30c07fb + #xff010a08 + #x700fa01 + #x2040606 + #x10afefe + #xfc010d00 + #x90b0001 + #x606fffa + #x60c0503 + #x4040604 + #x4f9fb08 + #x1060709 + #x406faf9 + #x20204fe + #xf05ff08 + #x200fbff + #xa0c0a0b + #x9020003 + #xfff7030a + #x3080708 + #x400f7f7 + #x3ffff00 + #xc00060f + #xfd00ff03 + #xe0d0f0a + #x7fdfe06 + #xfcfc0903 + #x5060406 + #xfbf6f7 + #xfffb0004 + #x5040f0d + #xfc060103 + #x120f1001 + #xfdf8000c + #xff0006fa + #x3020105 + #xf8faf8f8 + #xfefd0302 + #x70c0e05 + #x30a0102 + #x120e0cff + #xf4f80411 + #x10100f4 + #xff0006 + #xf500f9f5 + #x20003fb + #xc0d0500 + #x8060408 + #x100f0801 + #xf3fc0812 + #x2fffcf6 + #xfdfd0107 + #xf903f5f2 + #x700fff8 + #xd05fb03 + #x5040f12 + #x11130a04 + #xf6fe080f + #xfdfef9 + #xfeff0005 + #xfefef0f0 + #x4fcfffc + #x5fbfb0b + #x10f1c13 + #x19180600 + #xf7fb040e + #x3f8 + #x1fffd02 + #xfdf6eef3 + #xfd0603 + #xfef90009 + #x41b1e0b + #x1f1400fd + #xf3f60213 + #x10404f1 + #x4fcf800 + #xf5f0f1f8 + #xfe041005 + #xfffe0000 + #x131f1504 + #x1d0cfe00 + #xecf5081b + #x508feec + #x2f6f601 + #xecf2f6fc + #x40f14fe + #x400f7f9 + #x1a1c0d05 + #x1305ff08 + #xeafa111e + #x904f5ee + #xfff2f602 + #xeaf7f9fe + #xe1511f5 + #x7f9edfc + #x19110e0c + #xb050411 + #xf0021718 + #x8fff4f7 + #xf9f2f803 + #xeffbfbfe + #x14130af0 + #x5efea07 + #xd0c1712 + #x90b0911 + #xfa08160d + #x4f8fc00 + #xf5f4f903 + #xf5fafcfb + #x110f04f2 + #xfee9f210 + #x6161e0d + #xd0d080a + #xa1106 + #xfef70703 + #xf5f7f601 + #xf7f9fef8 + #xc0d02f7 + #xfaecfc0f + #x91f1a06 + #xf080404 + #xa0d06 + #xfafc0d03 + #xf8f6f200 + #xf5fb00f6 + #x90d02fa + #xfcf40007 + #x131f1004 + #xb010205 + #xd0b08 + #xfb020d05 + #xfbf3f0ff + #xf4fefdf3 + #xd0c01fb + #xf9fd00 + #x1a1c0b08 + #x1fe070b + #x60f0805 + #xfc040d0c + #xfcf0f1ff + #xf601f9f2 + #x100801fb + #xf9f903 + #x18110d0e + #xfa010d10 + #xe0e03fe + #xfc051114 + #xfbeff4fd + #xf801f5f4 + #xc0203fc + #xfff9f908 + #x100c1510 + #xfd0b1110 + #x1207fdf7 + #xfb061914 + #xfaf3f5fa + #xf8fdf5f6 + #x50005fb + #xfffcfd0b + #xb11170b + #x4110f0c + #xdfef8f6 + #xfb0a1c0d + #xfcf6f5f7 + #xf7faf6f8 + #x20205fa + #x4000108 + #xb141305 + #x9110c0b + #x4faf7f9 + #xfd0d1806 + #xf9f2f6 + #xf5fbf8f8 + #x20302f8 + #xb040204 + #xd120906 + #xb0e0e0c + #xfbf8fd + #xfe0c1105 + #x4f8f0f6 + #xf6fcf7fb + #x300fff8 + #xf060103 + #xa09070d + #xa10120c + #x1fcf800 + #xff0a0f08 + #x7f7f0f5 + #xf7fcf801 + #xfafff9 + #x10080205 + #x4020b11 + #xb14120a + #x3f9f901 + #x91007 + #x8f8f0f3 + #xf8fcfe08 + #xf8f602fa + #x110c0405 + #xfc000d10 + #xf160f05 + #xfff5ff04 + #x3090eff + #x6f8eef4 + #xf8fd050d + #xf2fa05f9 + #x180f0400 + #xf8040c0c + #x11120a01 + #xf7f90406 + #x60807f9 + #x3f7eefa + #xfa010c0b + #xf40102f8 + #x1e0e00fa + #xf905050e + #x110d0800 + #xf6000609 + #x70300fc + #x3f7f002 + #xfe080f07 + #xfb03fef9 + #x1f08fcf7 + #xfa030112 + #xf0a0afe + #xfe04040c + #x2ffff03 + #x4f8f807 + #x10c0b02 + #xfffbff + #x1701fbfb + #xf9ff0519 + #xa080dfd + #x501030f + #x105 + #x5fb0006 + #x40d0500 + #xf90006 + #xafffe01 + #xf8000c15 + #x5090cfa + #x4fd0510 + #x2030001 + #x7020503 + #x30b0100 + #xfaf80b0a + #x1050202 + #xfc050c07 + #x30a09f9 + #xff090c + #x400feff + #x2040603 + #x706ff05 + #xf7060e02 + #x90501fe + #x5090300 + #x70b00fe + #xff070b02 + #x1fafd05 + #x2050708 + #x804fd00 + #xff0a06fe + #xf030000 + #x502f900 + #x90a0506 + #x6060300 + #xfcf80409 + #x4060808 + #x800f8fd + #x204ff00 + #xcff0607 + #xfffb08 + #xc0c0e06 + #x6000004 + #xf9fc0a04 + #x6050705 + #x3fcf6fd + #xffff03 + #x4010e0a + #xfe000009 + #xf0f0e00 + #xfffa0009 + #xf90109fa + #x6030601 + #xfdfaf5fd + #xfcfe0401 + #x20b1105 + #x3050105 + #x101009fd + #xf5fa0510 + #xff0400f3 + #x2000402 + #xfafdf6fd + #xfe0105fb + #xa0f0901 + #x9040106 + #x100e0400 + #xf3fe0a12 + #x101f9f4 + #xfffe0504 + #xfc00f4fa + #x20201f5 + #xf080104 + #x803080b + #x100e0305 + #xf6010c0f + #xfefaf7 + #xfdfe0405 + #x1fff1f6 + #x2fefdf8 + #xafdff0c + #x20a1310 + #x15110504 + #xf900080d + #xfefffef6 + #xfefe0203 + #x1f7eef6 + #xfefd0000 + #xfffa050b + #x51a180b + #x1d1100fe + #xf5fc0514 + #xfe03fff1 + #x1fbff00 + #xfaf2effb + #xfc030901 + #xfcfe0704 + #x121f1404 + #x1d0afcff + #xeff9081c + #x308fae9 + #xf6fc00 + #xf1f1f400 + #x10d10fc + #xfefd + #x1e1d0b02 + #x1403fc08 + #xeafc131f + #x906f1e9 + #xfbf3fb02 + #xeff5f801 + #xb150df2 + #x4faf5ff + #x1d130a07 + #xb020112 + #xed061a19 + #x9fdeff0 + #xf6f2fc06 + #xf2f8fb00 + #x121605ed + #x3eff108 + #x130f100c + #x9050715 + #xf60e190e + #x2f6f6f9 + #xf3f3fd08 + #xf7f9fdfd + #x1313feef + #xfce7f811 + #x917170d + #xd090a0d + #xfd101108 + #xfaf801fe + #xf4f5fc06 + #xf8fafef9 + #x100efcf4 + #xf4eb0211 + #xe1f1607 + #x10060704 + #x100b0a + #xf70006ff + #xf7f3fa03 + #xf7fdfdf6 + #xe0cfdf8 + #xf3f4070a + #x161f1003 + #xb010402 + #x110090d + #xf8060601 + #xfaf0f7ff + #xf600faf6 + #x100b00f7 + #xf7fb0205 + #x1e1a0905 + #xff040b + #x710090b + #xfc080709 + #xf9edf8fd + #xf903f6f7 + #x100801f6 + #xfbfbfc07 + #x1d110d0a + #xfc020911 + #xf0f0401 + #xfd080b11 + #xf5edf9fb + #xfc01f4f8 + #xd0501f6 + #xfcf7fc0d + #x160e150c + #xfd090c14 + #x1208fef9 + #xfe0b1512 + #xf4f0f9fa + #xfefef5fa + #x60303f8 + #xfdf7ff0f + #xd121608 + #x50f0c0f + #xe00f7f6 + #xfe0f190a + #xf5f3f8f8 + #xfcfaf6f9 + #x20501f9 + #xfb030a + #xd191104 + #xc0e0b0b + #x3faf5fb + #xff131603 + #xfaf4f5f6 + #xfafaf7fa + #x20600f7 + #x4000505 + #x11170b06 + #xc0c0c0a + #xfef9f6ff + #x3150f00 + #xfff3f3f6 + #xf9fbf7fd + #x405fef6 + #x9020304 + #x100e080c + #xb0e0e0c + #xfefaf801 + #x3100c03 + #xf2f2f6 + #xfafaf702 + #x1fffdf6 + #xb030306 + #x9070d11 + #xd130e0a + #xf9f802 + #x20d0f03 + #xf3f1f6 + #xfbf9fc08 + #xfbfdfff7 + #xd050506 + #x1061011 + #x12150c06 + #xfdf7fb04 + #x20c11fc + #xf3eff6 + #xfbfa050d + #xf5ff00f7 + #x13090701 + #xfe090d0e + #x14120900 + #xf4f80007 + #x50d0af5 + #xf2eefc + #xfb000c0b + #xf604fff7 + #x190a04f7 + #xfe0a0712 + #x130d07fd + #xf200050c + #x60900f6 + #xf0f002 + #xfd070d07 + #xfc05fbf8 + #x1907fff3 + #x5061a + #xe0a06fa + #xfa05060e + #x303fcff + #xeff806 + #x10e0905 + #x201fafc + #x1401fbf7 + #xffff0a1d + #x90a07fa + #x204070f + #x3 + #xf40106 + #x60f0404 + #xfffbff00 + #xafffcff + #xfcff111c + #x70c05f9 + #x2000a0e + #x300 + #xfb0502 + #x80b0005 + #xf9fb0702 + #x3000001 + #xfd041311 + #x60e01f7 + #xfe000e09 + #x30100fe + #x3030602 + #x7080005 + #xf5021003 + #x5060200 + #x1090802 + #x70c00fc + #xfd060e04 + #x1fdfe01 + #x1060605 + #x9000305 + #xff0f0404 + #xb0200f7 + #x705ff06 + #xb07ff03 + #x40b0501 + #xfcf90208 + #x3070806 + #x8feff01 + #x70bfe04 + #xaff01fe + #x3fbfd0d + #xb090706 + #x8050002 + #xf7fd0a05 + #x5070901 + #x5fafa01 + #x502fe06 + #x1010a04 + #xfa030e + #xe0e0b02 + #x1fe0008 + #xf90409fc + #x40608fe + #xf7f903 + #xffff0205 + #xff0a0f03 + #x1fe0508 + #x101105fd + #xf8fb030d + #xfe0700f4 + #x10406fc + #xfdf8f902 + #xfd0204ff + #x6110c00 + #x7000304 + #x110e0000 + #xf4fe0a11 + #x204f8f4 + #xfd0205ff + #xfffaf900 + #x400f9 + #xe0d0500 + #x7000408 + #x100b0006 + #xf8030d10 + #x1fff5f8 + #xfc020601 + #x2f8f6fc + #x202fafa + #xc020406 + #x4060c0e + #x120b0306 + #xfc050b0e + #xfffdf8fa + #xfc010501 + #x3f5f4fa + #xfffa00 + #x2fd0909 + #x414130d + #x160b0200 + #xfc010612 + #xff01f9f4 + #xfcff03ff + #xfef0f3fc + #xfd000102 + #xfa010d03 + #x121e1105 + #x1807fd00 + #xf5fc091c + #x205f4ee + #xfcfb00fe + #xf6eff600 + #x908fe + #xfd0405fd + #x1e1c0c01 + #x1401fa09 + #xeffe131f + #xa04ece9 + #xf8f7fe00 + #xf2f1fb02 + #x91308f5 + #x2fffbfe + #x1f140703 + #xafeff15 + #xef071c1c + #xafce9ee + #xf2f5ff06 + #xf5f4ff00 + #x1316fff0 + #xf3f806 + #x170e0c09 + #x8000918 + #xf7111a11 + #x3f5edf7 + #xf0f6000a + #xf8f700fc + #x1613f7f2 + #xf8ebfe0f + #xe14110a + #x9040e11 + #x15120c + #xfaf5f7fe + #xf1f60208 + #xf8f9fff8 + #x160df4f5 + #xeeed0811 + #x111f1306 + #xb050b06 + #x6130a0e + #xf5fefd00 + #xf5f60201 + #xf8fdfdf6 + #x1309f8f8 + #xeaf80c0c + #x1c1f0f01 + #x8030505 + #x80f0912 + #xf906fd04 + #xf5f3fffb + #xf800f9f7 + #x1206fbf6 + #xefff0709 + #x1f190b00 + #x100010b + #xc0e0a0f + #xff08fe0b + #xf2f1fdf7 + #xfd00f6fa + #x1106fdf4 + #xf7fe000c + #x1f0f0d02 + #xfb010416 + #x120d0804 + #x2080412 + #xeef1fcf8 + #xfef7fb + #xd05fdf5 + #xfaf90010 + #x170e1205 + #xff070919 + #x150900fb + #x10a0e13 + #xecf3fbf7 + #x2f9f8fa + #x705fcf8 + #xfaf60311 + #x10151505 + #x60b0c14 + #x1000f8f9 + #x211170c + #xeef4f9f6 + #xf7faf9 + #x507fdfb + #xfbfa090c + #xf1c1002 + #xb0b0b0c + #x6f9f4fc + #x6171202 + #xf2f5f7f6 + #xfdf7faf9 + #x608fbfb + #xfd000905 + #x15190a04 + #xb0a0b0b + #xfef6f503 + #x9170aff + #xf6f4f4f6 + #xfcf8f9fb + #x706faf9 + #x20603 + #x16110908 + #xa0b0b0d + #xfdf7f804 + #xb140700 + #xf8f2f4f7 + #xfcf7fb00 + #x502f9f8 + #x5020406 + #xf0a0d0d + #xc100c0e + #xfff7fa03 + #x90f0a01 + #xf7f2f3f9 + #xfcf5ff05 + #xff00faf9 + #x7030706 + #x70b120e + #x14120b09 + #xfdf5f905 + #x6100dfc + #xf8f2f1f9 + #xfbf70507 + #xfb01fafa + #xb060900 + #x30f100f + #x160f0802 + #xf6f6fc0b + #x71208f3 + #xfaf0f0fa + #xfafc0c09 + #xfc04fafa + #x100906f6 + #x40e0c12 + #x120a06fe + #xf2fc0310 + #x90ffdf4 + #xfbedf200 + #xfc060d07 + #x4f8f9 + #x120900f1 + #x6060b1a + #xe0904fc + #xf9030712 + #x807f7fb + #xf9ecf902 + #x10c0a06 + #x300f8fa + #xe05faf4 + #x3ff111f + #xb0a00fc + #x105090f + #x401fb02 + #xf6f10103 + #x80d0606 + #x2fcfbfe + #x900f9fe + #xfefe181c + #xa0cfffd + #x4040c0c + #x100 + #xf6fa0500 + #xc090407 + #xfbfc0101 + #x300fe00 + #xfc041a14 + #xc0cfcfb + #xff050e08 + #x10102fc + #xf9010600 + #xb030406 + #xf6020503 + #x40101fd + #xc1109 + #xc0afafb + #xfc0a0e04 + #x2fffefe + #xff070503 + #xa000406 + #xfc0c0704 + #xa0400f8 + #x6090103 + #xb07fc00 + #x10d0900 + #xfefdff08 + #x5070503 + #x5000501 + #xb0a0008 + #x601fcf7 + #x5fd010c + #xa020106 + #xc08ff05 + #xf9fd0708 + #x6090700 + #x3fc0002 + #xb03ff09 + #x10100 + #xfff50810 + #xc0a0704 + #x700fe07 + #xf9040900 + #x40906fa + #xfff8ff04 + #x3ff0308 + #xfd080803 + #xfdfb0c08 + #x100e0400 + #xfdfb020d + #xff0901f7 + #x20903f7 + #xfcf6ff04 + #x10403 + #x4100a00 + #x1000801 + #x120cfe00 + #xf7fd0810 + #x505f7f5 + #x700fa + #xfcf70001 + #x10400fe + #xe1005fe + #x4010304 + #x1107fe06 + #xf8030e11 + #x4fff3fa + #xfe0602ff + #xfff7fdfe + #x403f9ff + #xd080401 + #x202070c + #xf060308 + #xff070c0f + #xfaf5fe + #xfe060300 + #xf4fafb + #x3fff703 + #x4020804 + #x40c0f0e + #x10070502 + #x40a12 + #xfffcf8fb + #xfd0403fe + #xfdf0f8fb + #xfdfd06 + #xfb060d02 + #xf181107 + #x1206ff00 + #xfdfe0a1a + #x300f3f3 + #xfb0000fc + #xf7eff9fd + #x30301 + #xfd0b09fd + #x1d190b00 + #xe00fa0a + #xf4ff131f + #x9ffecee + #xf8fdfdff + #xf3f0fdff + #x70d03fa + #x306fffd + #x1f130600 + #x9fcff17 + #xf2071d1c + #xbf8e5ef + #xf3fafe06 + #xf3f301fe + #x1213fdf4 + #x2fafb03 + #x190e0704 + #x3fc0a1d + #xf9131d14 + #x3f0e7f9 + #xf0f9020b + #xf5f803f8 + #x190ff4f4 + #xf7f3000c + #x12100d08 + #x4021115 + #x416140d + #xfbf1ee01 + #xf0fa0509 + #xf6fc00f4 + #x1908f1f7 + #xecf40811 + #x13171104 + #x6060f0b + #xc120c10 + #xf7f8f506 + #xf2fa0600 + #xf7fffcf3 + #x1502f5f8 + #xe7fe0d10 + #x1c1c10fc + #x5050708 + #xf0d0c14 + #xfb00f709 + #xf2fb03f7 + #xfa00f9f6 + #x1200faf7 + #xee04090f + #x1f160bf7 + #x30010 + #x100b1010 + #x201f90e + #xeff9fef4 + #xfefef9f9 + #xf02f9f5 + #xf7020411 + #x1d100af8 + #xfe02031a + #x130b0e06 + #x6010014 + #xebf8faf7 + #x2fafbf9 + #xc03f7f8 + #xfcfc0413 + #x160f0dfe + #xff040a1d + #x150a05fb + #x5030d15 + #xe9f8f8f9 + #x2f8fdf6 + #x903f6fc + #xf9f80912 + #x10160f00 + #x5070f17 + #x1102fbfa + #x40b140f + #xebf8f7f9 + #xf7fef3 + #x804f700 + #xf6fc0d0b + #x121c0e00 + #x9090f0e + #x7f9f600 + #x9151304 + #xeff8f6f7 + #xfdf7fcf2 + #x904f900 + #xf7010c05 + #x191c0a00 + #x9080c0b + #xfef3f705 + #x111809ff + #xf2f6f3f9 + #xfbf8fbf6 + #xb03fafe + #xfc050705 + #x1b120903 + #x8090a11 + #xfbf4fb07 + #x121303ff + #xf3f4f2fc + #xfcf7fcfb + #xa01f9fc + #x40407 + #x150c0c07 + #xa0d0b13 + #xfcf6fc05 + #x100e0500 + #xf3f3f2fe + #xfbf600fe + #x4fff7fc + #x2030707 + #xb0d1009 + #x100f0b0e + #xfcf4fb07 + #xc0e08fc + #xf4f2f1ff + #xf9f80700 + #xfff7fd + #x5060901 + #x912100b + #x150d0907 + #xf7f3fc0e + #xb1204f5 + #xf5eff0fd + #xf7fe0a00 + #xf8fc + #x80b07f9 + #xa110f0f + #x12090601 + #xf3f60116 + #xf12f9f4 + #xf6edf2fd + #xf9060c02 + #x300f8fb + #xc0cfff3 + #xb091016 + #xb070200 + #xf8fe0916 + #x1008f2fb + #xf2ecf800 + #xd0b03 + #x5fdf9fa + #xd07f7f9 + #x601161a + #x908ff02 + #x30c10 + #xa00f602 + #xeef1ff02 + #x70c0a03 + #x2fbfafc + #xa01f500 + #xff011c18 + #xb08fc01 + #x5050c0c + #x4feff02 + #xedfa0301 + #xc070a02 + #xfcfcfc02 + #x5fefb01 + #xfa0b1f14 + #xe07fbfe + #x2080d09 + #x10000fe + #xf2020200 + #xb030a00 + #xfa010006 + #x40000fd + #xfe12170b + #xe04fafc + #xc0c08 + #x100fdfe + #xfa060200 + #x80009ff + #xff080009 + #x50300f5 + #x40f0907 + #xd01fbfe + #x3100807 + #xfefc05 + #x2080403 + #x6000601 + #x80c0009 + #x803fdf4 + #x802010a + #xa01ff04 + #xb0d0204 + #xfcfd030d + #x9070400 + #x30202 + #xd010407 + #x2fff702 + #xfffb0a0b + #x8030406 + #xe00fe0a + #xfb020905 + #x80903fa + #xfefd0104 + #x6fd0608 + #xff030008 + #xf7fe0f06 + #xd0a0501 + #x2fb000d + #x803fc + #x609fff7 + #xfafa0303 + #x704 + #x40a0504 + #xfa050bff + #x110900ff + #xfafb0811 + #x506faf7 + #x509fcf9 + #xf9fa0300 + #x1030301 + #xe0f0400 + #x50300 + #x1003ff02 + #xf8000d12 + #x7fff4fa + #x405fc00 + #xfafb01fe + #x602fdff + #x110a0100 + #x20309 + #xc010305 + #xfe070f11 + #x1f8f6ff + #x305ff01 + #xfbf9fdfb + #x5fdfb02 + #x8060403 + #x1060b0e + #xb040603 + #x2070c10 + #xfef7fa00 + #x2050000 + #xf9f6fafb + #x1faff05 + #x90803 + #x80f1109 + #xc050201 + #x20d14 + #xfbf9f9 + #x4fffd + #xf5f2fafb + #xfefe0502 + #xff0e0800 + #x17160cff + #xc00fb08 + #xf800141c + #x5faf0f1 + #xfd00fc00 + #xf1f3fdfc + #x40605fd + #x70b01fe + #x1f1204fe + #x5fb0018 + #xf3091e19 + #x8f4e8f1 + #xf9fcfb07 + #xf0f600fa + #xe0cfef7 + #x601fc02 + #x1a0d0302 + #xfb0c1e + #xf9141f13 + #x2ebe5fa + #xf5fa010d + #xf1fc01f5 + #x1709f7f5 + #xfcf9000b + #x120c0806 + #xff001419 + #x619170d + #xf9e9eb04 + #xf4fc070b + #xf401fff1 + #x1800f5f6 + #xeffa0714 + #x14110e01 + #x1081110 + #xf13110d + #xf5eef20b + #xf4000900 + #xf602faf0 + #x14fcf7f6 + #xeb010c17 + #x1a150ef8 + #x40a080f + #x110c110f + #xfaf6f80c + #xf30103f7 + #xfa01f8f3 + #xdfcfaf5 + #xf2070b17 + #x1f1609f0 + #x3060114 + #xe0a150d + #x1f8fc0e + #xf200fbf6 + #xfffdf9f5 + #xafef9f6 + #xfc050917 + #x1c1204f1 + #x1041c + #xe0e1302 + #x3f80312 + #xf0fef7fa + #xfbfdf4 + #xa00f5f9 + #xff0916 + #x151103f7 + #x10e1f + #x110e0afb + #x1fc0e14 + #xeffaf500 + #xfafff0 + #x900f300 + #xfbfd0e12 + #x101606fd + #x3051518 + #x1006fefb + #x205160f + #xf0f9f5ff + #xfdfbfdec + #x9fef603 + #xf500110d + #x151b08fd + #x608120f + #x7fbf800 + #x70f1505 + #xf3f7f4fd + #xfbfdfbec + #xafefb02 + #xf5060e09 + #x1b1907fc + #x6090d0e + #xfdf3fa07 + #x10150dfd + #xf4f5f2fc + #xfafdf8ef + #x9fefd00 + #xfa080808 + #x1f1407fc + #x6090913 + #xf6f3ff07 + #x161104fb + #xf4f3f102 + #xfafbfaf4 + #x8fefdfd + #x5050a + #x190f0900 + #x80b0b18 + #xf7f70005 + #x140b03fd + #xf3f1f207 + #xf9fafff8 + #x6fdfafe + #x204070a + #x100f0c03 + #xc0c0e13 + #xf8f6fe05 + #xe0906fb + #xf4f0f407 + #xf6fc02f8 + #x2fcfafe + #x2060906 + #xd130d05 + #x100c0c0a + #xf6f3fe0d + #xd0e03f5 + #xf4eff304 + #xf50206f9 + #x3fbfbfc + #x50b06ff + #x10130d09 + #xf090606 + #xf1f20416 + #x110ffaf3 + #xf3edf401 + #xf70907fb + #x3fafcf8 + #xa0cfefc + #x110d100d + #xa070207 + #xf2f90d17 + #x1406f1f8 + #xf0edf602 + #xff0e08ff + #x2fafbf8 + #xe07f6fe + #xa071612 + #x8070007 + #xfb011210 + #x10fbf400 + #xebf1fb07 + #x70d0afe + #xf9fafb + #xefff404 + #x91d13 + #xa06fe06 + #x2070f09 + #x6f7fd03 + #xebf9ff07 + #xb0a0bfb + #xfdfbfa00 + #x9fafa04 + #xfc121d10 + #xc02ff01 + #x4090c09 + #xfc0101 + #xf1000004 + #xa080bf6 + #xfbfefd08 + #x4fc00fe + #xfe1b180c + #xc00fffa + #x30b0a0c + #x100fc01 + #xfb04ff01 + #x50608f5 + #x1000b + #x301fff7 + #x6170e08 + #x9fefdfa + #x70e080c + #x1fffa07 + #x3040002 + #x20704f9 + #x804030b + #x403faf7 + #x90a0709 + #x6fefe00 + #xe0c050b + #xfefcff0d + #x9060302 + #x1040200 + #xd030309 + #x401f6ff + #x4fc080c + #x6000306 + #x1006000a + #xfc00090b + #xa0501fd + #x30106 + #x5000a03 + #x1f9fc0e + #xf8030e05 + #x6050500 + #x7fc030c + #x70700 + #xa07fef8 + #xfc000306 + #xff000a02 + #x201040b + #xf70a09fe + #xc0802fa + #xfcf90811 + #x506fef9 + #xa05f9fa + #xf9000303 + #xff0407ff + #xc080402 + #xff0c00ff + #xd0200fb + #xf7ff0f13 + #x6fff7f9 + #xa02f900 + #xf9000000 + #x30302fe + #x12090100 + #x1060007 + #x9000200 + #xfb061112 + #x1f8f7fe + #x900fc04 + #xf900fcff + #x5ff00fe + #xe050004 + #x3070e + #x5020701 + #x10a0f0f + #xfcf6fc00 + #x701ff02 + #xf9fcfafe + #xfa0300 + #x7070406 + #x40a0e0b + #x8050300 + #x1070e10 + #xfbf8fefc + #x501fe00 + #xf6f9f9fe + #xfbfc0800 + #x60c0603 + #xe120d02 + #x902ff05 + #xfc051213 + #xfff9f7f4 + #x200fb00 + #xf3f7fbfc + #xfe0309fc + #xb0d0200 + #x1a1403fd + #x5fbff13 + #xf50a1b16 + #xf3ecf2 + #xfffbfb08 + #xf1fafdfa + #x80802f7 + #xc04fe02 + #x1a0c0002 + #xfdfa0c1e + #xfa171f0f + #xfdeae7fb + #xfbf9000e + #xf1fffef7 + #x1106fbf4 + #x2fdff0a + #x14090306 + #xfc01171b + #x51b1a09 + #xf5e5eb06 + #xf7fc0a0c + #xf403fbf2 + #x13fff9f3 + #xf6fc0615 + #x110c0b03 + #xb1413 + #x10161307 + #xf1e7f50c + #xf6010b02 + #xf904f7f1 + #xdfafaf3 + #xf2010c1c + #x16120bf6 + #x40d0a11 + #x10101307 + #xf3edfd0c + #xf70505fa + #xfd00f5f1 + #x7fafaf4 + #xf8060f1c + #x1b1504ed + #x5070417 + #xb101606 + #xf8f1010a + #xf804fbf9 + #xfef7f3 + #x4fdf8f5 + #x106101a + #x1a14fced + #x301071e + #x9131501 + #xfbf3080d + #xf9fff500 + #xfbfbf1 + #x5fef4fb + #x3021216 + #x1512faf6 + #x100121f + #xc150afb + #xf9f81010 + #xf9faf503 + #xfefdfbee + #x7fbf500 + #xfd001312 + #x1312fefd + #x1051a18 + #xe0efffb + #xf902170e + #xf8f5f703 + #xfb01f8eb + #x6f8fa01 + #xf605140e + #x171402fd + #x30a1610 + #x9fff900 + #x10e1604 + #xf8f4f700 + #xfb02f4ea + #x5f8ff00 + #xf60a0f0c + #x1d1504f9 + #x40b0d0f + #xfdf6fc05 + #xc130ffa + #xf7f3f500 + #xfb00f2ee + #x4fa01fe + #xfd0b0a0d + #x1f1203f7 + #x5090917 + #xf4f50105 + #x131105f6 + #xf6f0f406 + #xfcfff3f1 + #x3fc00fc + #x107070e + #x1b0f02fa + #x6090b1c + #xf2f90302 + #x120a02f8 + #xf4eef60e + #xfafdf8f4 + #x2fcfffc + #x304080d + #x141005ff + #xa0b1118 + #xf5fb0003 + #xe0803f8 + #xf3edf90f + #xf8fffdf5 + #x1fbfefc + #x2060b0a + #x11130801 + #xd0c0f0f + #xf4f6ff0a + #xb0b02f4 + #xf3eefb0a + #xf704fef5 + #xfafff9 + #x40b0705 + #x14130903 + #xd0a080a + #xf0f40612 + #x110cfbef + #xf1edf907 + #xfb0900f8 + #xfa00f6 + #xb0c0003 + #x150f0c06 + #x908020d + #xecf91113 + #x1404f4f1 + #xeeedf708 + #xc02f9 + #xfffafdf6 + #x1005fa05 + #xf0d100b + #x705010f + #xf103160c + #x10f8f4fb + #xeaeffa0e + #x80d06f8 + #xfdfbfaf9 + #x11fcf907 + #x410150f + #x904020b + #xfc0b1206 + #x4f3fd01 + #xebf4fe11 + #xb0c08f4 + #xfbfbf900 + #xaf7ff05 + #x191811 + #xa010401 + #x20c0c08 + #xfdf80203 + #xf2fa000c + #xa0d06ef + #xfcfbfc07 + #x3f80100 + #x41f160e + #x80002f9 + #x40b0a0d + #xfcfeff03 + #xfcff0005 + #x60f01ef + #xfffd020a + #xfa + #xc1c0f0a + #x3fffef7 + #x70b0b0f + #xfefc09 + #x4000002 + #x40dfdf4 + #x3000708 + #x302f9fb + #x11110b08 + #x1fefcff + #xe0b0a0d + #xfffbff10 + #x8000002 + #x30afcfd + #x7000905 + #x5fef503 + #xa050a09 + #x1ffff05 + #x1106060a + #xfcfd070f + #xa050200 + #x1060004 + #x7000a04 + #x2faf70b + #xfc000d07 + #x4030404 + #xdff020b + #xfd050c03 + #x80300fb + #x201030a + #x60800 + #xfef8060b + #xfb0e0902 + #x70602f7 + #xfdfd0a0b + #x40904f9 + #xa01fafa + #xfe020408 + #xff0707fd + #x4020904 + #x11000ff + #xa04fef5 + #xf5ff1011 + #x602fbf6 + #xbfef900 + #xfd030006 + #x20704fb + #xd060300 + #x606fc07 + #x600fffc + #xf7071311 + #x2faf8fb + #x8fcfc04 + #xfd02fe06 + #x30201fa + #xe040003 + #x300030f + #x3000200 + #xff0d120e + #xfaf7fc00 + #x6fd0003 + #xfdfefb05 + #xffff03fc + #xa030307 + #x1040d0f + #x4040300 + #x30c0f0b + #xf7f900ff + #x5ff0000 + #xfafafb04 + #xf9ff07fc + #x9060705 + #x80f0c07 + #x7030001 + #x9100e + #xfafcfcf8 + #x4fefeff + #xf7f9fb02 + #xfa0307f9 + #xd090500 + #x12120302 + #x5fe000c + #xfb0c150f + #xfdf7f1f4 + #x2fafd04 + #xf4fafbff + #x20904f6 + #x110600ff + #x180dfe05 + #xfefb0a18 + #xfc161b0e + #xf9ede8fc + #xfdf80209 + #xf4fffafb + #xb07fef3 + #x800ff07 + #x1405020a + #xf901181b + #x81e1905 + #xf2e5ec07 + #xf7fb0b09 + #xf802f8f7 + #xe00faf0 + #xfdfd0413 + #x10070805 + #xfd0c1716 + #x121b1301 + #xebe4f70d + #xf6020e01 + #xfd01f5f5 + #x8fcf9f1 + #xf9000e1a + #x110e09fa + #x6100e13 + #x12141001 + #xeaea010b + #xfa0708fa + #x1fef3f3 + #x2fcf7f3 + #xfe05151b + #x161400ef + #x9090a17 + #xb141202 + #xeef00607 + #xfd06fff9 + #x1fbf4f3 + #xfef5f8 + #x3071716 + #x1912f5f0 + #x6010d1c + #x8191201 + #xf1f40709 + #xff00f8ff + #xfbf6f2 + #x3fef3fc + #x4061812 + #x180df2f8 + #x161d + #xd1c0afd + #xf0fa0d0f + #xfff7fa02 + #xfdfff5f1 + #x4f9f5ff + #xfe08180e + #x1609f7ff + #xff071c17 + #x1313fefd + #xf204130f + #xfbf2fd01 + #xfd02f2f0 + #x3f6fc00 + #xf90b150e + #x1809fefe + #x10e1711 + #xf04f800 + #xfb0f1507 + #xf8f3fefc + #xff02eef0 + #xf602fe + #xfa0f120e + #x1d0c02f9 + #x40e0d14 + #x1f9fc03 + #x8150efb + #xf6f2fafd + #xffedf2 + #xfefa04fc + #x10e0d0e + #x1e0efff5 + #x60a091a + #xf6f80103 + #x111304f3 + #xf4f0f905 + #xfbeff4 + #xfefe02fb + #x6090b0e + #x1b0dfdf7 + #x6080e1f + #xf2fd0301 + #x120cfef4 + #xf3edfb0e + #xfffbf3f4 + #xff00fc + #x6040c0e + #x160efefd + #x809131c + #xf5ff0000 + #xc08fef6 + #xf0ed0011 + #xfcfef6f4 + #xfffdfffb + #x2070e0a + #x140f0100 + #xb0c1314 + #xf6fafe07 + #xa09fff4 + #xefef030d + #xfb02f9f5 + #xfefc00f8 + #x40a0c07 + #x160f0401 + #xc0c0c10 + #xf1f7030e + #xd0afbec + #xeef10109 + #x5faf6 + #xfcfcfff5 + #xa0b0506 + #x160e0601 + #xb080512 + #xebfb0f10 + #x1205f4ea + #xebf0fd0b + #x506fdf7 + #xfafefbf5 + #x10050005 + #x110e0907 + #x9040614 + #xec07160a + #xefaf2f1 + #xeaeffc13 + #xa0800f5 + #xfbfef7fa + #x10fd0004 + #xa120d0f + #x802090f + #xf6121205 + #x1f2f9fd + #xeaf00117 + #xc0b02f0 + #xfcfdf600 + #x8f70203 + #x8191113 + #x7010904 + #x1120905 + #xf9f80002 + #xf0f50611 + #xb0f00ec + #xfcfbfb06 + #xfff904fe + #xc1d1412 + #x50105fc + #x60c080c + #xf8fe0004 + #xf8fa0607 + #xa11f9ed + #xfdfb0208 + #xfcff01fc + #x141c120c + #x201fdfa + #x70a0b0e + #xfdfffe07 + #xfffd0400 + #xa0ef4f4 + #xfffe0905 + #xfbfe + #x19130e08 + #xf701 + #xb0b0e09 + #xfefb010d + #x2fe0201 + #xa09f5fe + #xa03 + #x4fcf703 + #x100b0c07 + #xfb07 + #xe090b07 + #xfbfb090f + #x4000200 + #x803fb05 + #x30901 + #x3f5fa0b + #x5080c08 + #x2010006 + #xc030806 + #xfb010d08 + #x80301fd + #x302020a + #x40a01 + #xfff5020e + #xfb0c0a04 + #x50503fd + #x2fd070a + #xa09f9 + #x501fdfa + #x201070b + #x20a0300 + #xf9000d02 + #x70e0301 + #x803faf7 + #xf5030f0a + #x607fff3 + #x6fefafe + #x2060b + #x40a01fc + #x30607ff + #xc07ff04 + #x600f8fb + #xf40a130e + #x4fff8f8 + #x4fafd03 + #x100030b + #x506fffa + #xa050201 + #x7fe020d + #x1fffd01 + #xfe10130b + #xfdfaf9ff + #xfa0003 + #x1fd020b + #x103fefb + #x9020404 + #x1ff0b11 + #x2020001 + #x6100f08 + #xf7fbfe02 + #xfd01fe + #xfffa0108 + #xfc0200fd + #x7040802 + #x30a0e0d + #x5040000 + #x60c0d08 + #xf9fffdfe + #xfe00fb + #xfaf90006 + #xfc0602fb + #xa0708fd + #xd100608 + #x4000005 + #x10c110c + #xfcfdf4fa + #xfbfffd + #xf8faff04 + #x10a01f7 + #xd0703fa + #x14090009 + #xfffd0711 + #x113140b + #xfbf3eaff + #xfdf90202 + #xf8fcfd01 + #x809fef4 + #xc02ff00 + #x1302020e + #xfa021419 + #xb1c1505 + #xf2e7eb0a + #xf5fd0b02 + #xfbfdfafc + #x904f9f2 + #x2ff030c + #xe03090b + #xff0d1817 + #x161c10ff + #xe9e4f710 + #xf4050ffe + #xfdf7f8 + #x700f5f3 + #xfd000d15 + #xc0a0900 + #x6101314 + #x17180cff + #xe5ea020d + #xf90c09f6 + #x3faf5f5 + #x1fff3f7 + #xfe061914 + #x1211fff5 + #xb0b0e14 + #x10160b02 + #xe7f30508 + #x900f3 + #x2f6f4f4 + #xfef1fc + #x10b1c0e + #x170ff3f6 + #x7031318 + #xe190a04 + #xeaf9030a + #x400fbf6 + #xf8f4f6 + #x2fbf100 + #x20f1c09 + #x1905effd + #x3191a + #x141a0503 + #xedfe0513 + #x1f8fdf9 + #xfefcf3f7 + #x3f7f500 + #xff10190a + #x17fef602 + #xfe091c17 + #x1c14fd00 + #xf0040c16 + #xfaf602f6 + #xfff1f8 + #xf5fdff + #xfd13150c + #x15ffffff + #x1111515 + #x1904f900 + #xf90f100e + #xf4f702f2 + #x2feeff7 + #xfbf701fd + #x14130c + #x170401f8 + #x6110d17 + #xafafb01 + #x6160dff + #xf2f8fdf5 + #x5f9eef6 + #xf8fc01fd + #x711110a + #x1909fdf5 + #x90b0b1c + #xfaf90102 + #x111502f5 + #xf1f5fa00 + #x4f4f0f6 + #xfb00fffe + #x90c1009 + #x190af8f8 + #x707111f + #xf5ff0201 + #x140efaf5 + #xeff1fe0b + #x1f4f2f6 + #xfe01fd00 + #x7091007 + #x1708f8fe + #x608181e + #xf901ff01 + #xf07f9f8 + #xecf00511 + #xfff7f5f5 + #xfeff + #x2091107 + #x1509fe01 + #x80d1818 + #xfcfdfc04 + #xb07faf6 + #xeaf4090d + #xfffbf6f4 + #xfefffefb + #x30d0f05 + #x17090000 + #xb0e1115 + #xf6f8000b + #xc07f7ef + #xe9f80809 + #x2fff8f4 + #xfc00fcf9 + #xa0c0a04 + #x170a0200 + #xb090b17 + #xeefc0b0e + #xf04f1e8 + #xeaf6020b + #x700fbf4 + #xfc01f7fa + #xf070702 + #x120b0305 + #x8030b18 + #xec08120b + #xcfceced + #xe9f20213 + #x900fdf2 + #xfd00f3ff + #xc000600 + #xe0e060f + #x6011113 + #xf8140e06 + #x2f5effa + #xe9f10716 + #xa06feee + #xfefdf404 + #x4fe07fd + #xe120d14 + #x4031009 + #x5140607 + #xf7f6f903 + #xebf50e11 + #xc0dfbeb + #xfff9f908 + #xfbff05fc + #x13171513 + #x3050800 + #xc0d040a + #xf5fefe06 + #xf1fc1002 + #xf0ef4ed + #xfdf90108 + #xf80201fc + #x1a16160c + #x105fc01 + #xb08090b + #xfb00ff07 + #xf6000afb + #x1109f0f4 + #xfcfd0706 + #xfd02fdfe + #x1b141205 + #x201f508 + #xa0a0d07 + #xfffe010a + #xfa0004fd + #x1101f3fd + #xfc020706 + #x3fcfb02 + #x160f0e05 + #x2fef70e + #xc0d0d01 + #xfbfc090d + #xfd0003ff + #xdfcfa03 + #xff060505 + #x1f6fe06 + #xb0c0b07 + #x2fefe0c + #xb0a0902 + #xf9000f09 + #x102fd + #x8fc0107 + #x80305 + #xfbf50606 + #x40e0a07 + #x4010201 + #x4040804 + #xff080dff + #x40300fa + #x300070b + #x2090303 + #xf8fd0c05 + #x3100602 + #x704fef7 + #xf9010c08 + #x60a00f4 + #x200fbfc + #x2030b09 + #x8070001 + #xfa0a08ff + #xe0602fe + #x6fdf300 + #xf70c0f0a + #x703f6f7 + #xfcfb01 + #x2010a0b + #x907fdfe + #x4090200 + #xafd0205 + #x1faf706 + #xff13110b + #xfcf600 + #xfefbff03 + #x2fe0a0a + #x703faff + #x7040303 + #xfd0b0d + #xfeff06 + #x9130e06 + #xfbfbfb06 + #xfcfd01ff + #xfffc0907 + #x202fb00 + #x4030701 + #x40f0d + #x3010002 + #xc100b05 + #xfafffe04 + #xfdff00f9 + #xfbfb0806 + #x4feff + #x50807fb + #x80d0c0a + #x501ff01 + #x80c0c07 + #xfefff700 + #xfdfefef9 + #xf9fc0504 + #x407fefb + #x90a02f8 + #x1109060b + #xff030a + #x60f1009 + #xfff8ef02 + #xfafc00fd + #xf9fc0203 + #xa08fcf7 + #xa06fefd + #x1100060f + #xfb010c15 + #xc171103 + #xf7eaee0d + #xf5ff0600 + #xfbfb00ff + #xb04f8f5 + #x5000006 + #xafe0c0f + #xfe0c1617 + #x171a0dfd + #xeae4f915 + #xf4070bfb + #xfff9fef9 + #x701f3f8 + #x90d + #x8070b05 + #x7111612 + #x1b1607fd + #xe3e90313 + #xfa0e08f2 + #x1f7f9f4 + #x4fff0fc + #xfe08160e + #xc0e03fc + #xc0d1310 + #x16130503 + #xe4f4040e + #x30d00ec + #xfff6f5f4 + #x3fcef00 + #x111b08 + #x150af7fb + #x7071413 + #x14150508 + #xeafc0011 + #x605fcec + #xfdf6f3f8 + #x4f7f301 + #x2161905 + #x17fef300 + #xff081818 + #x1b150408 + #xeffe0018 + #x2fdfced + #xfcf8f4fd + #x2f3f900 + #x1191607 + #x14f5f901 + #xfe10191a + #x1f0e0002 + #xf301071e + #xfafa00ec + #xfffaf5fe + #xfdf2fdff + #x219120b + #xff70000 + #x3161518 + #x1e02fcff + #xfb091016 + #xf2feffea + #x3f7f4fb + #xf8f800fe + #x717120b + #xd0001f9 + #xa120d19 + #x10f9fd00 + #x6110f06 + #xf0fffaee + #x5f2f4f8 + #xf8fefe00 + #xd141207 + #x1006fbf7 + #xb0b0f1d + #xf80002 + #x121304f9 + #xf1fbf6fa + #x3eff5f5 + #xfa01fc04 + #xe101201 + #x1306f4fb + #x706161f + #xf8ff0203 + #x150df9f8 + #xeff5fb08 + #xeff6f4 + #x1fc05 + #x90e1100 + #x1503f601 + #x4091c1e + #xfc01ff02 + #x1205f4fc + #xecf5030f + #xfcf3f7f3 + #x100fe03 + #x4100f00 + #x1400fb02 + #x50e1d1b + #xfdfc04 + #xc01f7fb + #xe8fa0b0e + #xfdf6f7f1 + #xff00 + #x3110e02 + #x14020000 + #xa111519 + #xfbf7fe08 + #xc03f6f2 + #xe9000a0a + #xf8f8ef + #xff00fbfe + #xa100c01 + #x14050000 + #xc0c1119 + #xf2fa060c + #xe01f0ec + #xebff050b + #x4faf9ee + #xff00f600 + #xe0c09ff + #x1207ff04 + #x806131a + #xef050e0c + #xcfbe7ef + #xedf90511 + #x4fdfbed + #xfff404 + #xa0707fc + #xf07030d + #x3031615 + #xfb110c09 + #x2f3e6fd + #xeaf60b14 + #x502faeb + #x2faf607 + #x20406fb + #x11090c14 + #x8150f + #xc120508 + #xfaf3ee0a + #xe8f9130c + #x908f7e9 + #xf6fc08 + #xfc0603fc + #x140d1410 + #x20c0c0a + #x14090209 + #xf8f9f90d + #xea0214fe + #xf0af2eb + #xfcf60109 + #xfa0600fe + #x18121807 + #x40a0009 + #x10040709 + #xfdfefe09 + #xef080cf7 + #x1401f0f0 + #xfafc050a + #xff03fd00 + #x19151401 + #x502f810 + #xa070c05 + #xfe0109 + #xf50803f8 + #x13faf3f7 + #xfb02040c + #x2fefd00 + #x16140e00 + #x4fbfa14 + #xa0d0b01 + #xfdfd060c + #xf90400fd + #xef5fbfd + #xff06010f + #xf900ff + #x10110a04 + #x3fa0111 + #xd0e0601 + #xfa000c0b + #xfc0301fd + #x7f70200 + #x307010e + #xf8f80500 + #xa0f0b06 + #x2fd0408 + #xa090403 + #xfc070d02 + #xff0300f9 + #x2fd0803 + #x6070109 + #xf30009ff + #xa0e0a03 + #x40000ff + #x60706 + #x40c06f7 + #x203fcf9 + #x1010a08 + #x7080004 + #xf6070aff + #xd0a04fe + #x6fff6fd + #xf80a0c09 + #x906f6fb + #x1fdf901 + #x1070b04 + #xa02ff01 + #x30a0003 + #xb0100fa + #xf4f80b + #x4100d0a + #x5fef203 + #xfffbfd05 + #x1030c06 + #x900fc02 + #x7060005 + #xfd0505 + #xfcf7000c + #xe140d07 + #xfefaf90c + #xfdfc0001 + #xfe020d03 + #x6fffc02 + #x4040304 + #xfc040e0a + #xfffe0304 + #x12100a03 + #xfdfcff0b + #xfcfffffc + #xfb020b01 + #x4ffff01 + #x3080400 + #x20b0f08 + #x2000100 + #xe0d0904 + #xfefe06 + #xfdfffbf9 + #xf9020801 + #x60200fd + #x70bfffc + #xc0b0b08 + #x1ff0006 + #x80d0c06 + #x1f8f605 + #xfafefbfc + #xf9000701 + #x903fdf9 + #xb08fafe + #xd030a0c + #xfe000711 + #xb120e03 + #xfbeef50c + #xf700ff00 + #xfafe05fe + #xb02f9f8 + #x901fc06 + #x7010e0e + #xfe071115 + #x13160afd + #xede5fd16 + #xf70605fe + #xfcfb01f7 + #x900f4fa + #x200040b + #x2060f09 + #x6111611 + #x1a1404fb + #xe2e90617 + #xfe0d04f3 + #xfcfafcf2 + #x7fdf3fe + #xff070f0a + #x70c0601 + #xc10150b + #x190e0103 + #xe3f40814 + #x70effe9 + #xfbf9f7f3 + #x5f7f501 + #x131607 + #x1208fdfe + #x80c130e + #x170c040a + #xeafc0116 + #xc07f8e5 + #xf9f8f3fa + #x3f3f901 + #x41b1206 + #x14fcf9ff + #x10d1416 + #x1c0e0709 + #xf2fb021d + #x500f7e5 + #xf9f7f400 + #xf1fe00 + #xa1c0f09 + #xef2fd00 + #x131519 + #x1f0b0401 + #xf6fb0a1f + #xfc00f7e7 + #xfcf5f801 + #xf9f300fe + #xe1a0e0b + #x6f500fe + #x5171319 + #x1d0300fc + #xfb01151b + #xf502f6e8 + #xf3fcfe + #xf6f7ffff + #x1218100a + #x2ff00fa + #xf141117 + #x10fafefd + #x30b170a + #xf502f1ee + #xf1fbf6 + #xf6fefc03 + #x13151102 + #x706f8fb + #xe0b1316 + #xfff80003 + #xe100bfd + #xf8fdeef9 + #xfef0f9f2 + #xfc00fd08 + #x121410fd + #xe05f400 + #x7071a19 + #xf7fd0205 + #x150cfdfa + #xf6f6f307 + #xf9f1f8f1 + #x1ffff09 + #xd140dfb + #x11fdf605 + #xb1f1b + #xfc000003 + #x1301f7ff + #xf0f5ff10 + #xf6f3f7f0 + #x2fe0105 + #x8140aff + #xffafc05 + #x3121e1b + #xfdfe02 + #xdfdf9ff + #xecfc0811 + #xf7f6f7ed + #x1ff0201 + #x9140901 + #xefc0001 + #x9151a1a + #xfef7ff04 + #x8fdfaf6 + #xed030b0d + #xfbf8f6ea + #xff00 + #xc130901 + #xd01ff00 + #xd10151b + #xf3f70409 + #x9fef3ee + #xf204060d + #xfef9f6e9 + #x200fb01 + #xf0f08ff + #xe02fd03 + #x80a1819 + #xf0010b0c + #xaf9e8f1 + #xf4000510 + #xfffdf6e9 + #x3fcfa05 + #xc0c06fd + #xe02000c + #x20a1b16 + #xfb0b0d0a + #x4f0e300 + #xf0fb0d12 + #xf6ea + #x2f6fd07 + #x50b01fe + #xe020b10 + #xe1812 + #xc0e0806 + #xfcebeb0e + #xea00140b + #x504f3e8 + #xfff40107 + #x10aff00 + #x1007150c + #x2130e0f + #x16070504 + #xf7eefa12 + #xe90913ff + #xc03f0e7 + #xfaf60508 + #x107fd02 + #x13101803 + #x70f0411 + #x11010703 + #xfaf7020c + #xf0100af6 + #x11fdefe9 + #xf8fa050c + #x403fd01 + #x141812fd + #x905ff13 + #x7030a03 + #xfffa0308 + #xf90e00f8 + #xff5f2ed + #xfa010412 + #x5fffffe + #x141a0bff + #x6fb0216 + #x70b0902 + #xfefc050b + #xff08fcfe + #x9f3f8f3 + #x30416 + #xfb00fc + #x13170703 + #xf80913 + #xc0d0404 + #xfaff090e + #x3fdff + #xf7fff9 + #x5030613 + #xf8fe02fc + #x10100905 + #xfefb0a0c + #xf080105 + #xfc060b09 + #x2fffa + #xfdfe03fc + #x702070c + #xf40204ff + #xf0e0b00 + #xfffe0306 + #x8050407 + #x30b0600 + #x102fcf9 + #xfe040700 + #x8020606 + #xf7090401 + #xf0b08f9 + #x2fdfb05 + #x1080808 + #x909fbfa + #x201f9fe + #x60a04 + #x9030103 + #xc0202 + #xe0500f8 + #x1f6f609 + #x10f0c0b + #x8fef309 + #x3f9fb06 + #x20b0802 + #x6ff0001 + #xa04000a + #x301fdfe + #xf6f4040c + #x110f0d06 + #x1f7f810 + #xfff90005 + #xb0902 + #x4fb0002 + #x702020a + #xfc030606 + #xf7fb0906 + #x15100b01 + #xfdf80210 + #xfdfcffff + #xfe0b0900 + #x1fc0200 + #x4050306 + #xc0d06 + #xfe0005fe + #x110d0700 + #xfefc040b + #xfdfefbfc + #xfc0a07ff + #x1fe03fc + #x8080002 + #x80f0c04 + #x1000000 + #xb0c0803 + #x1fbff07 + #xfdfcf8ff + #xfc0806ff + #x50100f8 + #xe05fa03 + #xb0a0a08 + #xfefe030b + #xa0f0a03 + #xfdf2fc0b + #xfbfdfb03 + #xfc0405fd + #x800fbf8 + #xcfffa07 + #x5060d0c + #xfe030e11 + #x101308fe + #xf0eb0113 + #xfb010001 + #xfc0303f8 + #x8fff8fa + #x6fc000c + #xa100c + #x30c150c + #x171102fc + #xe3ec0a17 + #x802f7 + #xfa00fcf3 + #x6faf6fd + #x20a0b + #x40f0b05 + #xb121506 + #x170bff01 + #xe2f60e16 + #xa0afce8 + #xf9fff4f4 + #x3f6fbfe + #x20f0e0a + #xd090300 + #xa111009 + #x15070308 + #xeafc0a16 + #xf07f4e2 + #xf8fbf1fc + #xf200fe + #xa170d0a + #x11fffeff + #x4110f12 + #x16080a07 + #xf3fa091c + #xa01efe3 + #xf9f6f504 + #xfaf202fc + #x11180a0c + #x8f6ffff + #x5151118 + #x1a0a0aff + #xf5f7131e + #x1ffeee8 + #xfaf4fc04 + #xf5f601fc + #x17160c0b + #xfef900ff + #xd171416 + #x170603f9 + #xf6fd1d17 + #xfd00eded + #xfbf4fffe + #xf3fbffff + #x19140f05 + #xfb01fd00 + #x12121410 + #xc00fffd + #xfb081f09 + #xfdffe9f1 + #xfaf4fef6 + #xf7fefd03 + #x181511fd + #x107f802 + #x100b150d + #xfcfbff03 + #x61014fc + #x1f8e8fb + #xf7f6f9f1 + #xfcfdff06 + #x15160df9 + #xa01f507 + #x70a1a10 + #xf5fe0208 + #xf0d03f8 + #xfff1ee06 + #xf4f7f5f1 + #xfc0506 + #x121708fa + #xef9f80b + #x10f1d15 + #xf9010304 + #x1003fafe + #xf7f0fb11 + #xf3f8f4f2 + #xfd0902 + #x101403ff + #xbf5fe08 + #x3151e18 + #x0 + #x9fbfd00 + #xf1f80614 + #xf4f9f4ee + #xff08ff + #x10130402 + #x6fa0004 + #xb191b19 + #xfdfaff00 + #x4fafff9 + #xf2010b11 + #xf7faf2e9 + #x5fd + #x12100502 + #x6ffff02 + #x10161918 + #xf4f80206 + #x3fcf8ef + #xf805080e + #xfafbf0e7 + #x1000000 + #x130f0600 + #x800fd05 + #xb101a17 + #xeffe090b + #x5f8ebf1 + #xfc010710 + #xfafceee9 + #x2fc0001 + #x100d0300 + #xafe000b + #x40f1c15 + #xf8080d09 + #x3eee5fe + #xf8ff0c11 + #xfdffefec + #x1f80402 + #xc0b0001 + #xafe080e + #x1151913 + #x70c0c03 + #xfae4ee0d + #xf003130d + #x300efeb + #xfbf60702 + #x909fd04 + #x704110a + #x7181111 + #x110707fe + #xf3e50011 + #xef0c1103 + #x9ffede6 + #xf6fa0705 + #xa05fe05 + #xa101303 + #xe130a11 + #xb0207fe + #xf2ee0b0a + #xf61208fb + #xefaece4 + #xf5fe050c + #xb00ff01 + #xf1b0e00 + #xd070712 + #x1040801 + #xf7f80a03 + #x10ffcfb + #xbf5ece7 + #xf9000514 + #x8fd01fe + #x151e0500 + #x6fd0913 + #x80704 + #xfafc0607 + #x706f800 + #x3f4f0ed + #xff010a17 + #x1fe01fa + #x18180304 + #xfffb0e12 + #x80b0406 + #xfaff080d + #x700fc01 + #xfbf8f5f5 + #x2001013 + #xfa0000fc + #x16110704 + #xfbff0e0f + #xe070306 + #xfb020c0d + #x400fefc + #xf800faf9 + #x401120a + #xf803ff01 + #x130e0aff + #xfa00080c + #xb020405 + #x1080806 + #x300fbf9 + #xfc04fffc + #x4020e04 + #xfc07ff04 + #x100e07f6 + #xfeff000a + #x5030706 + #x8090001 + #x3fff8fd + #x802ff + #x4020800 + #x4070007 + #xe0b00f4 + #xfef8fe0d + #x5090a08 + #xa01f405 + #x4fbf904 + #x20b0702 + #x6000202 + #xa070009 + #x803fbfa + #xf8f2000e + #xd0e0d09 + #x2f6fe11 + #xf80008 + #x60c0505 + #xfe0200 + #x900050b + #xfd05 + #xf2fd0d06 + #x13100cfb + #xfbf50713 + #xfcf90203 + #x50e0503 + #xfefc03fe + #x501060a + #xff080706 + #xf9030afe + #x110e06f9 + #xfbfc0a0d + #xfbfcfeff + #x40d0400 + #xfc0003fb + #x8040306 + #x70f0804 + #x201fc + #xc0b04ff + #xfefe0609 + #xfcfafa00 + #x30b03fe + #x200f8 + #xd02ff04 + #xb0f0706 + #xffff0004 + #xa0c0602 + #xfcf9000a + #xfcf8fc05 + #x20803fd + #x402fbf8 + #xdfcfe07 + #x80b080c + #xfc000a0b + #xe0f0600 + #xf3f20211 + #xfdfb0105 + #x700f9 + #x5fff9f9 + #x6f9020b + #x30c0d0e + #x91208 + #x140e01fd + #xe7f30b16 + #x103fa + #xfe07fbf6 + #x4fbfafa + #xffff080c + #x5100e0a + #x8111201 + #x1508fe00 + #xe3fa1014 + #x906ffea + #xfd04f3f8 + #xf7fdfa + #x90b0c + #xc0e0802 + #xd140d04 + #x11030106 + #xea001112 + #xe05f3e0 + #xfcfbf000 + #xfcf600f9 + #xb100a0c + #xe040200 + #xc130a0f + #xf070905 + #xf1fe1115 + #xc00ebe2 + #xfbf4f508 + #xf6f801f9 + #x16110a0c + #x6fdff01 + #xb130e14 + #x100c0bfe + #xf2fa1918 + #x6fbe7ea + #xfaf2fe09 + #xf3fc00fa + #x1b0f0e09 + #xfbfefe03 + #x10141411 + #x110b01fa + #xef001f13 + #x3f8e7f0 + #xf8f50201 + #xf3fefefd + #x1b101100 + #xf903fb09 + #x15111607 + #x904fb00 + #xf30c1f07 + #x4f6e7f2 + #xf7fbfffa + #xf7fefe00 + #x181411f9 + #x3f90d + #x110e1603 + #xfffffc09 + #xff1818fa + #x6f0e8f6 + #xf6fdf7f7 + #xfcfd0102 + #x16170bf6 + #x9fef910 + #x80b1607 + #xf7ff010c + #xb1505f8 + #x2eaee01 + #xf4fdf2f9 + #xfefc0900 + #x151603fa + #xaf4fd10 + #x212170f + #xfa020405 + #xe08fcfc + #xf9eafa0d + #xf4fbf2f9 + #xfdff0dfc + #x16130000 + #x5f3020d + #x6191815 + #xff0201fe + #x7fefeff + #xf1f20713 + #xf6f9f2f4 + #xfb020bf9 + #x170d0003 + #xf90309 + #xf1b1a15 + #xfffefdfd + #xfc01f9 + #xf3fe0d11 + #xf8f9f0ed + #xfe0406f9 + #x170c0402 + #xff0007 + #x13191b12 + #xf6fafe03 + #xfefefcf0 + #xfa030d0c + #xf9faeceb + #x303fb + #x150b0401 + #x3fffc0a + #x10151c11 + #xf0fd040a + #x1fcefee + #xff020b0d + #xfaf9e8ed + #xff03fd + #x130c0301 + #x6fc000e + #x9151d11 + #xf4050c09 + #xefe8fa + #xfc010d0e + #xfdf9e9f2 + #xfdfb06fd + #x11090004 + #x4fc080f + #x8191911 + #x20d0c00 + #xf7e4f007 + #xf604130d + #x1f9ecf1 + #xf9fc07fe + #x1004ff06 + #x1020e0c + #xc1b1410 + #xb0c07fb + #xece3030c + #xf40d1206 + #x7f8edeb + #xf5000502 + #xf000204 + #x30f0e07 + #x14160f0e + #x80701fc + #xe8ee0f04 + #xfd1108fe + #x9f6e9e4 + #xf602030a + #xcfe04fe + #xc1a0706 + #x140c0f0e + #xff060102 + #xecfb0efe + #x90cfefb + #x7f3e5e6 + #xfa020612 + #x7ff04f9 + #x151a0308 + #xb04110e + #xfc080309 + #xf4000701 + #xf02faff + #xf3e5ef + #xfe000d15 + #x1f8 + #x1c150309 + #x100f + #x40a0409 + #xf7000609 + #xbfbfeff + #xfaf6eaf8 + #x1170f + #xfc01fefc + #x1c0c0605 + #xfb040d11 + #xb060406 + #xfa020b0c + #x4fb00fd + #xf9fbf1fe + #x51a06 + #xfd03fd01 + #x160b08fe + #xfc060911 + #xa020602 + #xfe060d07 + #x2fffef9 + #xfd00f7ff + #xff0715ff + #x101fe06 + #x120e04f9 + #xfe020410 + #x3030800 + #x5080503 + #x3fef9fc + #x103fc00 + #x80bfd + #x6010007 + #x110ffdf7 + #xfcfd030f + #x3070b02 + #x903fd06 + #x4f9f903 + #x4070002 + #x10504ff + #xa000208 + #xd08f6fb + #xf6f8060f + #x90b0c02 + #x5f9fb0f + #x2f7fe08 + #x50c0404 + #x1000201 + #xb01040b + #x401f902 + #xf1fa0c0b + #x110e0eff + #xfbf70c10 + #xf7fb0506 + #xb080605 + #xfe010101 + #x3020b06 + #xfe0108 + #xf7070c01 + #xf1103f1 + #xf7fd100f + #xf7fd0201 + #xb0a0602 + #xfc0200ff + #x4030a04 + #x5090606 + #x803fb + #xe0dfef7 + #xfa020b0b + #xf8fbfe00 + #xb0904fe + #xfe04fdfe + #x9030500 + #xd0d0407 + #x102fe00 + #xc090000 + #xfc00040b + #xf9f7fe02 + #x80802fc + #x203f8fd + #x8fe0202 + #xd0b050d + #xfe000306 + #xe0b0400 + #xf6fa030f + #xf9f80402 + #x60800fb + #x500f7fd + #x2fb0506 + #x90a0b10 + #xfd050d07 + #x120b01fd + #xedf90a14 + #xfcfe07fa + #x407fafa + #x3fcf9fc + #xfcfe090a + #x90d0f0c + #x50f0c02 + #x1306fefe + #xe8fe1013 + #x10402eb + #x302f5fc + #xfffafcfa + #xfd050c0b + #xd0f0d05 + #xd130602 + #xe01ff03 + #xed04120e + #x905f5e0 + #x2faf304 + #xfbfafef9 + #x70b0b0c + #xf0a0500 + #x1011040b + #x9040605 + #xf202130d + #xafee8e2 + #xfff1f90a + #xf6fcfcfb + #x120c0d08 + #x704ff03 + #x110f0c10 + #xa0d0801 + #xf2011811 + #x7f6e4ea + #xfaef000c + #xf500fbfc + #x170c1102 + #xfd01fd0a + #x1310140b + #xe0f0000 + #xed061f11 + #x4f0e6ef + #xf5f60507 + #xf801fbfd + #x161012fa + #xfc01fe11 + #x140f1601 + #xd07f707 + #xf0131d08 + #x4ede9ed + #xf5ff0000 + #xfbfffdfd + #x13150ef4 + #x2fffe14 + #x100f11fe + #x5fff910 + #xfd1e13ff + #x3eaebed + #xf601fa00 + #xfdfd02fb + #x141807f5 + #x8f90116 + #xa100e03 + #xfefc0011 + #xc1e03f9 + #xfee6eef6 + #xf9fef401 + #xfbfd08fb + #x1715fffa + #x7f30514 + #x5120e0c + #xfd010609 + #x120efafd + #xf3e7f904 + #xfaf8f502 + #xfa020af8 + #x1a0efd00 + #xf40811 + #x9171312 + #x10402fd + #xa01fb00 + #xebf0050e + #xfaf5f7fc + #xfb0907f6 + #x1a090000 + #xfbfa0710 + #x111a1811 + #x201fbfc + #xfffe00fd + #xedfc100d + #xfaf5f4f3 + #xff0a02f7 + #x170704ff + #xfb00020f + #x17191b0b + #xfcfbf904 + #xfd01fcf3 + #xf6041108 + #xfbf6edef + #x20800f9 + #x140805ff + #xff0010 + #x14181b0a + #xf4fb000c + #xfff1ef + #xfe060e04 + #xfcf4e8f2 + #x20400fa + #x12090300 + #x2fa0212 + #xe18190c + #xf502080b + #xf3e8f6 + #xfd040e08 + #xfdf0eaf8 + #xff0103fb + #x12080104 + #xf80812 + #xe1b190f + #xff0b0b02 + #xf6e6f002 + #xf907120a + #xefeef7 + #xfa0202fd + #x11030203 + #xfd010c0f + #x141c160c + #x80e04fe + #xe9e50008 + #xf90e1305 + #x3f1eff0 + #xf8050002 + #xe0006ff + #xff0d0c0d + #x18171407 + #x90afd00 + #xe1f10d04 + #x1120cfb + #x4f3eae9 + #xfc060009 + #x90007f9 + #xb14070e + #x160f1305 + #x305fa08 + #xe6010afd + #xc0d03f4 + #x2f1e3eb + #xff03050f + #x10005f5 + #x1612050f + #xd0a1109 + #x4fe10 + #xf10802ff + #x1102fef3 + #xfeefe0f5 + #xff010f10 + #xfe0401f7 + #x1d0b070c + #x50a0f10 + #x404020e + #xf9050006 + #xafafff6 + #xfaede500 + #xfd03180c + #xfd05fdfb + #x1c070a07 + #xb0b14 + #xa050506 + #xfb030709 + #xfb02f7 + #xfaf0ee05 + #xfc0b1a02 + #x2fc00 + #x160809ff + #x90818 + #x8030600 + #xfd060c06 + #xfcfe00f7 + #xfef4f704 + #xff1213fe + #x300ff02 + #x120d02fa + #x1050817 + #x20407fe + #x2090a01 + #xfffffbfa + #x1f9fc02 + #x11108fd + #x6fe0302 + #x120dfafb + #xff000813 + #x808fe + #x6060203 + #x1fbfa00 + #x4fffe03 + #x30c02ff + #x6ff0603 + #x1207f600 + #xf9fd0a11 + #x50c0afe + #x5fe010a + #xfff6fe06 + #x7030005 + #x3060001 + #x5000704 + #xcfef706 + #xf3fe0d0e + #xb100af9 + #xfdf6070f + #xfaf90307 + #xa080507 + #x10102 + #x4020907 + #x2fcff08 + #xf4030f07 + #xe1207f1 + #xf6001010 + #xf4000401 + #xc060a00 + #xff03fe07 + #x80bff + #x606 + #xc0500 + #x120cf7f2 + #xf9070e0f + #xf6ff01fe + #xc0707fa + #x105fb05 + #x30808fb + #x9070506 + #x506fd00 + #x1106f9fb + #xff07070d + #xf7fb00ff + #xb0803f9 + #x502f805 + #x40404fc + #xe06060c + #xfe06 + #xe050000 + #xfd00050f + #xf6f90400 + #x90700f9 + #x6fef803 + #xff000301 + #xc050c0f + #xfe030509 + #xf0701fd + #xf5fd0912 + #xf50009f9 + #x905fcfa + #x4fbf901 + #xf9000707 + #xa09140d + #x20b0706 + #x1105fefb + #xf0011011 + #xfb0704ec + #x900f8fc + #xfffafaff + #xfb050b09 + #xd0e1104 + #xd100305 + #xc01fe00 + #xf207130b + #x208f7e2 + #x7f8f801 + #xfbfcfaff + #x2090d07 + #xf0e0900 + #x130d010a + #x6010106 + #xf8091108 + #x800e8e2 + #xeffe0a + #xfbfff800 + #xd0a0e05 + #xb0a0104 + #x1109070e + #x6090507 + #xf607110d + #x7f3e2e9 + #xf8f0050d + #xfc00f700 + #xf0d11fd + #x304000c + #x100b1208 + #xf0dff09 + #xf20c1612 + #x2ebe5ec + #xf3f8090b + #xfd00f9fe + #xd1210f6 + #x214 + #x110f12ff + #x1305f80e + #xf518180f + #xfee9ebe7 + #xf3010607 + #xfffdfdfa + #xe1809f3 + #x4fc0718 + #xf110afc + #xefafa15 + #x21f0e05 + #xfaeaece3 + #xf902fe05 + #xfefc01f8 + #x141901f7 + #x5f60b16 + #xa100402 + #x3f80415 + #x121d02ff + #xf4e9eceb + #xfdfcfc08 + #xfc0004f8 + #x1a13fcfc + #x2f50e14 + #x810050b + #xfe0a0a + #x1a11f900 + #xebe9f2fd + #xfef5ff07 + #xfa0504f8 + #x1d0afcfe + #xfbf90e13 + #xc120d10 + #x20406ff + #x1202fa03 + #xe5f0000a + #xfcf200fe + #xfd0c00f9 + #x1a0500fc + #xf6ff0b15 + #x1215160b + #x502fbfe + #x4feff01 + #xe7fb0b0c + #xfaf3fcf3 + #x30dfcf9 + #x130403fa + #xf9010817 + #x16181904 + #x1fbf705 + #xff01fdf9 + #xf1061003 + #xfaf4f3ee + #x80afbfb + #xf0703fb + #xffff0616 + #x16181703 + #xf9f7fd10 + #x201f2f2 + #xfb0a0d00 + #xfbf0edf2 + #x706fdfc + #xf090200 + #xfa0915 + #x13191507 + #xf6fd060f + #x3f7e9f5 + #xfd0b0b02 + #xfbebedf8 + #x304fefd + #xf070202 + #xfdfa0c14 + #x121b150a + #xfd070907 + #xfae9ec00 + #xfa0a0d07 + #xfbe9f3fa + #x6ffff + #x10030402 + #xf9ff0e13 + #x171c1608 + #x70e0301 + #xe9e7fb08 + #xfc0f1103 + #xfbedf4f3 + #x7fc02 + #xa0307fc + #xfc090d12 + #x1b191401 + #xd08fb06 + #xe1f30608 + #x3120ff7 + #xfdf1eeee + #x105fe07 + #x30407f7 + #x70e0b12 + #x19131100 + #xb00f711 + #xe6030504 + #xd1006ea + #xfdf0e4f1 + #x302050c + #xff0702f5 + #x150b0c12 + #x10100d05 + #x7fcfd17 + #xf40bfc02 + #xd07ffe6 + #xfbeae2fc + #x100100d + #xfe08fef9 + #x1a060f0c + #x810090f + #x7fe0412 + #xff07f906 + #x600fdea + #xf8e4e806 + #xfe071808 + #x5fbfd + #x18050f03 + #x70f0819 + #xa010708 + #x10009 + #xfdfffef1 + #xf7e3f30a + #xfe101903 + #x302fbfe + #x120809fd + #x80b091c + #x8020601 + #xff040905 + #xf801fdf4 + #xf9e9fd06 + #x2190f00 + #x5fffffd + #xf0d02fd + #x7050c1a + #x30504ff + #x1090901 + #xfb02fbf7 + #xfcf00000 + #x9170400 + #x3fe02fc + #x110cfc00 + #x2011016 + #x10804ff + #x6090301 + #xfffef9fd + #xfff70000 + #xd10ff02 + #x105fd + #x1303f802 + #xfb000f14 + #x40c05fd + #x5020207 + #xfdf9fd02 + #x3fc0104 + #x908ff04 + #x30600 + #xffafb06 + #xf7010f13 + #xa1005f8 + #xfffd070c + #xf7fa0105 + #x6000605 + #x4040005 + #x50802 + #x7f70108 + #xf7050f0e + #xe1201f1 + #xf7fe0f0f + #xf4ff0503 + #xb040a02 + #x2ff06 + #x70b01 + #xfb0507 + #xfe0b0a04 + #x110ff9ee + #xfb0b0e15 + #xf90102fb + #x80a07f5 + #x300ff0b + #x20d05fb + #x1020702 + #x7090000 + #x1600f1fa + #x20c0b11 + #xf9ff00fa + #x90a01f4 + #x5fefe0b + #x40b00fb + #xa030706 + #x501fb06 + #xffefa00 + #x305080e + #xf5fe03fe + #xa08fef6 + #x6fafd09 + #x106ff01 + #xa020d0a + #x10c + #xb0100fe + #xfe000b0f + #xf40106fb + #xa05fdf6 + #x3f8fe07 + #xfd030206 + #x8061307 + #x205060c + #xc04fefb + #xf601110f + #xf70a03f2 + #xa00fbf7 + #xfef9fd06 + #xfc050808 + #x9101401 + #xb0a0309 + #xa01fbfe + #xf707130a + #x10bf6e9 + #x7f8fcfc + #xfcfbfa06 + #x1090c05 + #xd130afd + #x1108010a + #x400fe05 + #xfc0b0f06 + #x902e8e7 + #xf30002 + #xfdfdf807 + #x70c0d00 + #xe0e0100 + #x1005060c + #x403010d + #xfe0b0b0a + #x8f2e0ec + #xf6f4070a + #xfdf804 + #xa0e0efc + #xa06020b + #xb070f09 + #xc08010e + #xfb0d0e15 + #xe8e4eb + #xeffc0c0b + #x1fcfdfd + #x9140bf9 + #x6000912 + #xc0e0c02 + #x1600fd11 + #xfd151215 + #xf8e8e9e5 + #xf2030b09 + #x1fb00f7 + #xd1803f9 + #x5fb0e13 + #xd110200 + #x12f60015 + #x91e100c + #xf2ece9e1 + #xfa040707 + #xfefb00f4 + #x1616fcfb + #x1fb1312 + #xd0ffd04 + #x4f30b14 + #x181b0601 + #xeeece4ea + #xfd0506 + #xfb00fff7 + #x1d0ef9fe + #xfdfe1212 + #xb0a000a + #xfdfd110a + #x1e0efe00 + #xe8eae7fc + #xfff60703 + #xfc06fefc + #x1e05fbfc + #xf7011016 + #xb0a0a0b + #xff060b01 + #x1600fc04 + #xe4edf40e + #xf9f409fb + #x20bfcfd + #x1902fff9 + #xf4050f1a + #xf0f1404 + #x505feff + #x8fd0005 + #xe6f8040f + #xf6f904ef + #x90afafd + #x100300f7 + #xf9050e1c + #x141516fe + #x4fbf808 + #x10000ff + #xef040b07 + #xf7faf9ea + #xd06fafd + #xa07fffa + #xff010f19 + #x151912fe + #xfcf3fd10 + #x401f8f5 + #xfa0c09ff + #xf8f4f0ed + #xd04fbfc + #xb07fe01 + #xfffe1216 + #x14190f03 + #xf4f70712 + #x5f8eef5 + #xd0501 + #xf7ebf0f5 + #x802fcfe + #xe060004 + #xfafd1214 + #x151a1106 + #xf9020a0c + #xfdebedfe + #xc0706 + #xf4e9f6f8 + #x503fd00 + #xd040301 + #xf7021214 + #x191b1302 + #x40a0509 + #xede6f609 + #xff0e0d05 + #xf1edf8f5 + #x604fc00 + #x90506fc + #xfa081115 + #x1a1a13fc + #xe06fd0d + #xe3f1010d + #x6120ef5 + #xf3f3f1f1 + #x8020002 + #x30903fa + #x40a1214 + #x18170bfb + #xefbfb16 + #xe900030a + #xd1305e5 + #xf8f1e9f5 + #x7ff0705 + #xafdfb + #x10081310 + #x13150403 + #x9f50119 + #xf907fe06 + #xe0efbe0 + #xf8e8e600 + #x2ff0f07 + #x208f9ff + #x11061408 + #xf13020f + #x4f70b14 + #x402fb06 + #x605f4e6 + #xf5e1ee09 + #xfd071606 + #x605f901 + #xf0a1200 + #xf100618 + #x3fe0e0a + #x5fc0007 + #xfe01f3f1 + #xf1e0fb09 + #xff131503 + #x800fbfe + #xd0f0afe + #xe0a0c1a + #x3030a05 + #xfd0605 + #xfa02f6f8 + #xefe40303 + #x81c0e00 + #x7fefef9 + #xd1000fe + #xa041219 + #x1040504 + #x60702 + #xfd02f6f8 + #xf0f004fc + #x11190400 + #x2fffff8 + #x100bfc02 + #x3031615 + #x1060305 + #x5090202 + #x100f6fb + #xf5f701fc + #x140f0001 + #xfe0200fc + #x1201fe05 + #xfd041414 + #x5090301 + #x8050007 + #xfffbf900 + #xfafb0100 + #x12070003 + #xfe050002 + #xef90004 + #xf9041216 + #xc0b00fb + #x200040d + #xf9fbff03 + #xfffe0601 + #xa020105 + #x70204 + #x5f60404 + #xfa071215 + #x110dfdf3 + #xfb010a11 + #xf6fe0201 + #x2020afe + #x4010108 + #x1090501 + #xfefb0703 + #xff0b0f0c + #x150af4f1 + #xfa080e15 + #xf70203fd + #x70809f8 + #x200ff0b + #x10c07fc + #xfe000703 + #x60c0502 + #x1703eff5 + #x50d1014 + #xfd00fff8 + #x80ffdf4 + #x2fc0709 + #xa0afd00 + #x2040401 + #x903fe01 + #xdf4f501 + #x8080e0c + #xf9ff00fd + #xb0bfaf5 + #xf9050a + #x907fb04 + #x5030805 + #x3fc000b + #x5fbfe02 + #x3020e0a + #xf5020200 + #xb05f9f4 + #xfef8040a + #x402ff09 + #x3080f03 + #x70c + #x601fdfe + #xfc03120b + #xfa0a00fb + #xa00faf2 + #xfbf9020a + #x1020509 + #x5110fff + #x505090a + #x701fafe + #xf9071409 + #x40cf7f2 + #x6fcfaf4 + #xfafa000b + #x2070a04 + #xc1707fc + #xd050608 + #x4fdfa06 + #xff0d0f05 + #xd01eaef + #xfff8fdfd + #xfdfafe0a + #x60b0b00 + #x111200ff + #xc02070a + #x2fe000e + #x20d0807 + #xcf2e3f1 + #xf5fb0305 + #xf90005 + #x81008fd + #xf070105 + #x8050a0b + #x7010411 + #x20b0811 + #xe6e4f2 + #xf0010a0a + #xf702fc + #x81405fd + #xa000a0c + #x80d0a06 + #x10ff0411 + #x30e1215 + #xf3e6e7eb + #xf3080d09 + #xfdf802f3 + #x1114ff00 + #x500120d + #xe10ff05 + #xdf70810 + #xc15170c + #xeeebe4e7 + #xfb070c05 + #xfcfcfff1 + #x1b0ffa01 + #x3130d + #xf0bfa06 + #xfff61110 + #x191610fe + #xedebe0f0 + #x1020b01 + #xfa00f9f7 + #x1f07fa00 + #xfa081110 + #xd030008 + #xf400160a + #x1e0d05fb + #xece7e103 + #xfefd0dfd + #xfd03f8fd + #x1c01fcfc + #xf70c0f17 + #xa020c04 + #xf80b0e03 + #x17010000 + #xe9e5eb14 + #xf8ff0cf5 + #x304f900 + #x1500fef8 + #xf80b111e + #xa0a13fe + #x20a0202 + #x8fb0306 + #xe8edfe18 + #xf30406ea + #xb05fbfe + #xd02fcf7 + #xfd09151f + #xe1312f9 + #x5fefa07 + #xfe0501 + #xeffd080c + #xf504fae5 + #xf01fdfa + #x804fa00 + #x51819 + #x13180afa + #xfdf4fe10 + #x20000f7 + #xfb080703 + #xf8fdf0e8 + #xcfffdfb + #xa05fa07 + #xff031713 + #x16180700 + #xf2f50812 + #x5fbf4f1 + #x40a0103 + #xf6f2eef1 + #x800fefc + #xd02fe0a + #xfa061612 + #x17170a02 + #xf2000e0f + #xffeeeffa + #x6080209 + #xf0edf4f7 + #x700fefd + #xc020207 + #xf7081413 + #x19180fff + #xff08080c + #xf0e7f506 + #x7090805 + #xecf2f7f7 + #x70000fc + #x8050302 + #xfa0b1413 + #x1a1a0ef8 + #xa040111 + #xe5ed000e + #x80f0cf7 + #xedf8f3f6 + #x7ff02fa + #x4090000 + #x20b1611 + #x1b1a06f7 + #xdf90017 + #xeafa070b + #xf1403e5 + #xf4f5ecf9 + #x4fd07fb + #x608fb04 + #x90b180d + #x1817fe00 + #x4f30818 + #xf8010604 + #x1211f5e0 + #xf7eaeb01 + #x1000dff + #xa04f806 + #xb0c1706 + #x1511fd0c + #xfcf71213 + #x3fe0300 + #xd07e9e9 + #xf3e0f309 + #xfd081102 + #xcfffc05 + #x8111000 + #x140d0514 + #xf800130b + #x3f70500 + #x5ffe8f8 + #xebe1ff08 + #x151101 + #xafdfefe + #x9170600 + #x13070f14 + #xfa060d09 + #xfef90800 + #x1fced00 + #xe5e90500 + #xb1a0dfe + #x7fefff8 + #xd130004 + #xc051611 + #xfd06080c + #xfd010800 + #x1fcf3ff + #xe5f603f9 + #x161807fb + #x2fffbf9 + #x110aff06 + #x2051811 + #x5060b + #x3060202 + #x5fcf4fc + #xecfefffa + #x190d05fa + #xff01f903 + #x11000005 + #xfd091613 + #x4060605 + #x7030007 + #x3f9f600 + #xf3fffefe + #x140505fc + #x3fb0b + #xbfb0302 + #xfc0b1417 + #xa0802fd + #x500030e + #xfef9fb04 + #xf9000200 + #xb020600 + #x303ff0c + #x1fc0600 + #xfd0b1515 + #x1108fcf7 + #xff010914 + #xfafc0002 + #xfd0306fd + #x5010602 + #x5050208 + #xfbff0600 + #xd150d + #x1504f5f4 + #xfe070d17 + #xfb0000fc + #xa05f7 + #x3000606 + #x7090202 + #xfb030500 + #x50d0e04 + #x16fcf0f8 + #x30d0e16 + #xfd0100f8 + #x60f00f4 + #x2fd0609 + #x80c00ff + #x40400 + #xa080101 + #x11f5f1fe + #xa0b1708 + #xfb00fd00 + #xe09f7f8 + #xfd000b07 + #x1001fb06 + #x2050204 + #x7ff0003 + #xfcf4fc06 + #x5061203 + #xf9010004 + #xe04f7f5 + #xfafe0909 + #xcfd0009 + #x1090606 + #xfffc0808 + #xfefdff03 + #xfe061207 + #xfd060002 + #xb00f6f0 + #xf8fe060c + #x5fe0707 + #x4120802 + #x20d05 + #x4fffb00 + #xfc0b1208 + #x808fbfa + #x6fef4f1 + #xf9fd060d + #x3030a02 + #xc1703ff + #x5060a03 + #x5fcfa04 + #xf0f04 + #x1100f0f4 + #xfffcf4fa + #xfbfc070b + #x50a09fe + #x1512fdff + #x7040707 + #x1fa000d + #x60f0703 + #xff1e9f6 + #xf8fefb06 + #xfcfa0904 + #x80f05ff + #x1408ff03 + #x505080b + #x2fd0710 + #x70a0609 + #x1e6e9f8 + #xf403040b + #xfbf909fa + #xc100202 + #xd010706 + #x50a070d + #x6ff0b0d + #x5080f0e + #xf2e5eaf5 + #xf8090c09 + #xf9fb05f1 + #x120fff05 + #x5030d08 + #xd0c000a + #x5fc0c0b + #x90f1b05 + #xebe8e3f2 + #xff0a0e01 + #xf8fefcef + #x1c08fe03 + #xc0d0a + #x1206fd06 + #xf8ff120c + #x111418f8 + #xeee7e0f9 + #x3080dfb + #xf900f5f6 + #x1e02ff00 + #xfc100d12 + #xefd0203 + #xee07160b + #x17110bf3 + #xf0e3e30a + #xff070cf7 + #xff01f5ff + #x18ff00fb + #xfe110d1b + #x5fd0cff + #xf3120e07 + #x120701fc + #xece0ed19 + #xf90b09f2 + #x500faff + #xe00fef8 + #xe131f + #x3060ff9 + #x10f0304 + #x8000205 + #xe8e3fe1c + #xf60f01eb + #x8fefffa + #x801fafc + #x20a191e + #x8120bf7 + #x802fc06 + #xff000703 + #xebf30b12 + #xfa0ff6e6 + #x9fe00f5 + #x702f704 + #x3091d19 + #x121702f9 + #xfff6ff0b + #x204f7 + #xf7010905 + #xfe04ece8 + #x8fefff6 + #xb00f90c + #xb1c12 + #x171400ff + #xf1f6080f + #x2fffaee + #x3060204 + #xfbf8eaf0 + #x5fffef9 + #xbfdff0f + #xfd0e1710 + #x18120400 + #xee000e10 + #xfff5f0f3 + #x9030109 + #xf2f1eff9 + #x4ff00fa + #xaff050b + #xfc101412 + #x19140afb + #xf9090b10 + #xf2ebf301 + #x9030808 + #xecf4f4fd + #x50002f6 + #x6020407 + #xfe0f1512 + #x1a1808f6 + #x6060612 + #xe7ecff0a + #x90a0bfa + #xedfaf3fc + #x5ff03f2 + #x6060108 + #x20f180f + #x1d1900f6 + #x8fc0616 + #xe8f60907 + #xd1203e7 + #xf5f8effe + #x1ff04f2 + #x904fd0a + #x60f160a + #x1e15f8fe + #xfef70e18 + #xf3fe0dfd + #x140ff2e3 + #xf8ecef04 + #xfd0105f9 + #xdfefc0b + #x7141206 + #x1c0cfb06 + #xf2fd1414 + #xfd000af6 + #x1504e5ed + #xf2e2f70a + #xfc0908ff + #xdfa0106 + #x7190d05 + #x1906050b + #xef07140f + #xfefb07f6 + #xff6e2fe + #xe7e4000a + #x1130cff + #x8fb04fe + #xc1a0406 + #x12030f0a + #xf40c0c0f + #xf8fd06f9 + #x8f0eb04 + #xe1f00503 + #xe170cf8 + #x3fe00f7 + #x1312ff09 + #xb05140b + #xfa0a0913 + #xf70105fc + #x5f1f400 + #xe1fd01fe + #x18150af0 + #x100fafd + #x1606000a + #x40b150f + #xff070a11 + #xff060100 + #x5f5f8fd + #xe902fafc + #x1a0e07ed + #xfff609 + #x11ff0508 + #xe1413 + #x2070b08 + #x5030005 + #x3f5f7ff + #xf301f900 + #x120705f0 + #x2fdfa14 + #x7fd0602 + #x101316 + #x70807fd + #x4ff030c + #xfff5fa04 + #xf900fe03 + #xa0505f6 + #x5fd0015 + #x400 + #x1101614 + #xd07fff7 + #xff000a12 + #xfcf8ff04 + #xfb020200 + #x30406fb + #x7ff050e + #xfc040100 + #x210190b + #x1100f7f6 + #xff051015 + #xfcfb00ff + #xff0900fa + #x20307fe + #x8030407 + #xfd060101 + #x6121302 + #xff9f2f8 + #x40a1513 + #xfdfefffb + #x40dfbf8 + #x10800 + #xb050004 + #x60103 + #xa0e09fe + #x8f1f3fe + #x90c170b + #xfd00fdfb + #xc0df8f8 + #xfeff0b05 + #x1005fc05 + #x1050103 + #x9030001 + #xf1f904 + #x80f16fc + #xfafefe09 + #x11fef8f8 + #xfb07060d + #xbfb0301 + #x205020d + #x1ff0501 + #xf5f90008 + #x20d0f00 + #xfd020308 + #xbfdf5f2 + #xfb04070f + #x4fb0800 + #x50c050b + #xfc030c00 + #xfffdff02 + #xfe100f05 + #x80401fe + #x6fcf0f3 + #xfa02090f + #x20bfd + #xf110305 + #x90900 + #x3fafd01 + #x2130c03 + #xf00f9f7 + #x1fbeefd + #xfb000c0c + #x10908fb + #x170e0002 + #x5090404 + #xf70007 + #xa120800 + #xdf4f0f7 + #xfcfaf40a + #xfaff0e03 + #x80d04fd + #x1804fe02 + #x407030f + #xfcfb080a + #xb0b0502 + #xe9effb + #xfbfe0010 + #xf8000cfb + #xe0c0101 + #xf000205 + #x6080412 + #xff000d09 + #x7060c04 + #xf0e6effe + #xfe040b0b + #xf60204f3 + #x14070103 + #x6060707 + #xc08040e + #xff040e06 + #x40b1800 + #xe9e7eafc + #x3090f00 + #xf804f8f2 + #x19040400 + #x10e070b + #xf010008 + #xf8050e09 + #x91516f3 + #xede4e4ff + #x60d0cf7 + #xfd01f0f9 + #x170105fc + #x2120714 + #x9f90601 + #xf00e110f + #x101707f1 + #xefe1e709 + #x30e08f5 + #xfef2ff + #x100004f9 + #x7100b1d + #xfa0bfd + #xf7150e0c + #x120ffafb + #xebe0f217 + #xff1103f4 + #x2fafbfe + #x802fef9 + #xa0c161f + #xfd040afa + #x8140406 + #x805fd08 + #xe4e10419 + #x14fdef + #x4fb01f8 + #x501f900 + #x90b1d1b + #x41002fb + #xf07fe03 + #x1030407 + #xe1ed110f + #x411f5ea + #x3fe01f3 + #x7fff707 + #x70f1f14 + #xf12fcfe + #x6fafe06 + #x606fa + #xeb001004 + #x906ebe8 + #x200fcf4 + #x9fafb0e + #x4131c10 + #x180ffb00 + #xf5f7050c + #x205fcee + #xfc040602 + #x5f8e8f0 + #x100fafa + #x8f8030f + #x217170f + #x180b0100 + #xee000c10 + #xfcf0ef + #x4010406 + #xfaf0ecfa + #x200fcfa + #x4fb090c + #x2161411 + #x160d05fb + #xf6090c12 + #xf6f1eefd + #x5000a06 + #xf1f2f301 + #x20000f5 + #x2010908 + #x3131511 + #x181302f6 + #x4080914 + #xeaedfb06 + #x4060dfb + #xf2f7f602 + #x20100ee + #x5040509 + #x612170e + #x1e14faf6 + #x6000916 + #xe7f40903 + #x80f05eb + #xf8f5f402 + #x2fdee + #x901030b + #x715160a + #x1f0ef4fc + #xfdfe0e18 + #xee000ef8 + #x120ef3e4 + #xfbedf406 + #xff04fbf5 + #xdfb040c + #x7190f09 + #x1d04f702 + #xf0031417 + #xf70308ef + #x1700e4ed + #xf3e6fa0c + #x8fefd + #x8fb0803 + #xa1b0809 + #x17ff0303 + #xef0d1318 + #xfa0302f1 + #x13efe4fb + #xe7e8010f + #x40e05fc + #x1fe09fb + #x1118050c + #x10000c03 + #xf7100d18 + #xf803fdf7 + #x8e6ef01 + #xe0f5050c + #xe130bf2 + #xfe0200f9 + #x190e040d + #x9050d07 + #xc0b19 + #xf705fbfc + #xe9fbfd + #xe4000006 + #x171409e9 + #x2f800 + #x1902070b + #x40c0d0f + #x2090e15 + #xfc06fcfe + #xfcf0fdf8 + #xed03fc04 + #x191103e4 + #x2fdf60e + #x13fe0907 + #x4110e17 + #x30a1008 + #x304fd01 + #xfcf4fafa + #xf700fb05 + #x120cfee7 + #x3f6fc19 + #x6ff0803 + #x7121117 + #x50c0afd + #x3000208 + #xfbf4fb01 + #xfcfbff06 + #xa0afcf0 + #x3f70618 + #x50401 + #x8121611 + #xa0b01f8 + #xff000a0e + #xf8f4ff04 + #xfcfe0103 + #x609fef6 + #x2fb0c10 + #xff070003 + #x8131809 + #xd04f9f8 + #xfd041210 + #xf8f90200 + #xff0400ff + #x40800f9 + #x3010b07 + #x5ff05 + #x9151400 + #x9faf4fa + #x20b180c + #xfafcfffc + #x608fcfc + #x20704fc + #x7030504 + #x3040006 + #xd140afe + #x1f4f4fc + #x80e1a04 + #xfafdfcff + #xd04f8fc + #xff060400 + #xb000104 + #x4030008 + #xd0c02ff + #xf8f2f802 + #x90f18fd + #xfafffc05 + #x1100f8fa + #xfd060709 + #xffd0004 + #x204010b + #x5000302 + #xf4f6fe08 + #x8160af9 + #xfdff0508 + #x9faf8f5 + #x1070613 + #xfe0007f9 + #x5020810 + #xfe050500 + #xf8fb0305 + #x6140901 + #x3030700 + #x4faf0f5 + #x40a12 + #xfa0407f7 + #xc070a0b + #xc0400 + #xfffb00fe + #x9140b01 + #xb0300f6 + #x1f6ecff + #xff040f0d + #xfe0a04f8 + #x15070503 + #x70cff06 + #xfdf90100 + #xe1308fd + #x8fbf6f6 + #xf1f30d + #xfc050f06 + #x60d01fa + #x16020101 + #x907ff10 + #xf8fa0604 + #x110d04fb + #xfdf0f3ff + #xfdf20114 + #xf9070bfe + #xe0900fd + #xeff0104 + #x8050417 + #xf8020b05 + #xa0607fd + #xeeebf402 + #xfffc0e0d + #xfa0a00f8 + #x120503fe + #x5030308 + #xa040812 + #xfb070b05 + #x3090dfd + #xe8ebf301 + #x3061200 + #xfd08f5f8 + #x110306fa + #x40b040e + #xb000a08 + #xfc0b0a0b + #x5150df7 + #xeae5edff + #x70d0bf5 + #x101eefd + #x100407f6 + #x90f0717 + #x4fa0901 + #xfa0f0b12 + #x101cfef5 + #xebe0ec04 + #x71103f4 + #x3f9f200 + #x80704f7 + #xe09101e + #xf9fb0800 + #x1130d10 + #x1513f100 + #xe6e0f60d + #x61200f6 + #x2f5fbff + #x306fefb + #xf07171b + #xf7040301 + #xf120906 + #x1106f30e + #xe1e40712 + #x912fdf3 + #xfff900f9 + #x402f801 + #xa0b1e17 + #xdfe02 + #x180800ff + #x701000f + #xe0f2130b + #xf0df8ec + #xfefffdf7 + #x7fdfa08 + #x8141f11 + #xe0df902 + #xefefe00 + #x2050701 + #xe2011202 + #x1202f0e7 + #x2f6fb + #x7f7ff0a + #x71c1c0e + #x1507fa02 + #xfcf90109 + #x509fff1 + #xf20808ff + #xdf6eaea + #x201f301 + #x3f7070b + #x91e160e + #x14040000 + #xf1fe0812 + #x602eff0 + #xff040503 + #xedecf7 + #x200f702 + #xfefd0d07 + #xc1a1310 + #x110703fd + #xf7060b15 + #xfef5eafb + #x904 + #xf6ecf400 + #x200fcfb + #xfd020c06 + #xb15150e + #x140dfff9 + #x3080b15 + #xf1edf505 + #xfd070dfb + #xf4f1fa03 + #x102fbf1 + #x1060907 + #xb15170b + #x1b0ff7fb + #x8040b17 + #xe9f30402 + #x31006ed + #xf9f3fc02 + #x204f4f0 + #x7020908 + #xa181409 + #x1e07f4fe + #xff010e1a + #xeb0009f7 + #xe0ef6e5 + #xfbeffb05 + #x204f1f6 + #x7ff0a05 + #xc1b0e0b + #x1afef800 + #xf506121e + #xf50901ef + #x17ffe7e9 + #xf4eafe0d + #x404f5ff + #x3ff0e00 + #x101c0b0e + #x11fa0000 + #xf50e131f + #xfc0af6f4 + #x11ece7f4 + #xe7ed0313 + #x80800fb + #xfb050bfb + #x17130a0e + #x9fe0403 + #xf101f + #xfe07f0fc + #x2e4f2f9 + #xe1f70714 + #xe0d07f0 + #xfa0801fc + #x1d0a0a0b + #x505030a + #x80b0f1c + #xfe04f101 + #xf4e9fef6 + #xe700080f + #x141105e4 + #x5f804 + #x18020c07 + #x50b0315 + #xa071415 + #x3f402 + #xeff3fff1 + #xf2000208 + #x1712fbe0 + #x4fbf711 + #xe000d04 + #x60d0a1a + #x70b160a + #x400f803 + #xf1f8fbf4 + #xfcfb0105 + #x160ff1e5 + #x3f30019 + #x4040a04 + #x90e1117 + #x8110f00 + #x2fefd07 + #xf4f7fafd + #xfef70405 + #x110beef0 + #xfef40c18 + #x80504 + #xc101610 + #xc1001fb + #xfe00060d + #xf4f6ff01 + #xfcfa0603 + #xc08f3f7 + #xfafd120f + #x2080105 + #xc131706 + #xe07f9fd + #xfd050f0d + #xf4f902ff + #xfe0004ff + #xa07f8f8 + #xfc040f07 + #x5030206 + #xd171001 + #x9fef6fe + #xc1607 + #xf5fe00fb + #x40200fe + #x807fbfb + #x60904 + #x6000306 + #x11160801 + #xf6f4ff + #x61217ff + #xf7fefcfe + #xb00fefc + #x508fd00 + #x5020503 + #x5000409 + #x120f0201 + #xf7f5f602 + #x91413f8 + #xf8fcfc06 + #xdfcfcfa + #x308fe0a + #x5fe0400 + #x400050d + #xc070102 + #xf2f5fa08 + #x9160cf7 + #xfbfe010a + #xcfafaf6 + #x2080212 + #x1fe06fb + #x3010811 + #x20501 + #xf5fa0108 + #xf1501fb + #x40a01 + #x1fbf3f6 + #x5031011 + #xf90700fb + #x6021107 + #x208ff03 + #xfaff05fd + #xf1407fe + #x50804f9 + #xf4eeff + #x104130e + #xfd0cfefa + #xc050c00 + #xa0bfc08 + #xfafd00fa + #x131208fa + #x603f9fa + #xfeebf60b + #xff091108 + #x70afcfb + #xf0305fe + #xe04fd12 + #xf5fd0101 + #x140d02f6 + #xfef9f301 + #xfaea0411 + #xff0e0a03 + #xe07fefb + #xb000102 + #xa000619 + #xf5010506 + #xe0700f9 + #xf1f1f609 + #xf9f5130b + #x10d00ff + #xf0401f8 + #x3020108 + #x8000f14 + #xfb080708 + #x50703fd + #xeaf0f906 + #xfd0514fd + #x509f6fe + #xb0504f6 + #x406040f + #x6010f0a + #xb070b + #x40f02fd + #xebedf800 + #x4110cf2 + #x7fff200 + #x70904f6 + #xa060915 + #xb03 + #x30b0911 + #x1118f8ff + #xe8e4f4fd + #x91300f2 + #x5f4f503 + #x50c00f9 + #x11031319 + #xf8000705 + #x90d0f11 + #x1d10ec08 + #xe2e2f806 + #xc10fef4 + #xfff2fd01 + #x609fa00 + #x10041c17 + #xf505000b + #x140f0e02 + #x1901f114 + #xe0e9030d + #x100dfff2 + #xfbf7ffff + #x802f803 + #x90d1f12 + #xfe09fc0b + #x1b0a06f8 + #xdf90116 + #xe0f70f0d + #x1508feeb + #xfbfff900 + #x9fafd05 + #x6181e0c + #xb08fc08 + #x13fffdfa + #x5000a08 + #xe1050f05 + #x1600f5e3 + #x1f105 + #x4f70204 + #xa1f180d + #x1202ff04 + #xf9fe06 + #x60704f7 + #xed0c0700 + #x10f7ece1 + #x3fef00c + #xfefa0903 + #xf1f150e + #xfff0101 + #xf4fb0413 + #xa05f3f2 + #xfd080201 + #x3eeebec + #x4faf70c + #xf8000d04 + #x141c150e + #xa020200 + #xf7020b16 + #x5f6e9fb + #xfe030504 + #xf7ebf4fa + #x3fbfd03 + #xf9060c04 + #x1416170a + #xd08fd00 + #x2060e14 + #xf8ecf104 + #xfc070900 + #xf2eefd00 + #x200fbf9 + #x90a05 + #x10161605 + #x1508f700 + #x7050c15 + #xebef0004 + #x1006f3 + #xf5f301ff + #x402f2f4 + #x4070a04 + #xf1a1206 + #x1a01f501 + #x2030e1c + #xecfd04fb + #xd0ff7e8 + #xf7f30000 + #x7ffedf9 + #x3040c03 + #x111b0e0a + #x14faf800 + #xfb05121f + #xf608fcf6 + #x1501eae6 + #xf2f20009 + #x8fbf2fe + #xfe070d00 + #x16160d0d + #xaf8fd01 + #xfd0b161f + #x10aeef9 + #xfeee6ec + #xe9f30515 + #x7fcfffb + #xf90d09fd + #x1c10100c + #x2fdff06 + #x50c161f + #x603ea03 + #xfce7f0f3 + #xe4f90e18 + #x90406ee + #xfd0d0001 + #x1d091205 + #x102fc10 + #xd0a1719 + #x6fdee08 + #xebecfaf4 + #xeaff1011 + #xf0e00e3 + #x506f808 + #x16061000 + #x305fe19 + #xc091b11 + #x5faf506 + #xe6f8fbf2 + #xf5000f06 + #x1512f3e1 + #x9faf912 + #xa070b00 + #x706081c + #x60d1a09 + #x5f9f805 + #xecfdf5f6 + #xfcfc0cff + #x190de6e9 + #x3f20418 + #x20b0804 + #xa081516 + #x7131203 + #x2f8fb09 + #xf2faf4fd + #xfcf909fc + #x1705e3f3 + #xfaf61017 + #xd0707 + #xb0d1a0b + #xf120502 + #xfefa0010 + #xf4f8fb00 + #xf8fb09fd + #x1300ebfa + #xf3011611 + #x50a0605 + #xc121603 + #x1309fb03 + #xfd020b0f + #xf3fa00fd + #xf90108fb + #xffff3fa + #xf70b110a + #x8020502 + #xe150e03 + #xdfef704 + #xc1108 + #xf4fffff9 + #x304f9 + #xc01f7fb + #xfe0c0a07 + #x6000601 + #x12140604 + #x2f8f704 + #x81211ff + #xf6fffafc + #x60001f9 + #xa03f701 + #x3070505 + #x3000705 + #x15100206 + #xfaf5f607 + #xc170bf8 + #xf8fcfb03 + #x7fd00f8 + #xa03fa0a + #x2020402 + #x1000909 + #x10080205 + #xf6f4f80b + #xe1803f7 + #xfafa0107 + #x5fcfcf5 + #x9020112 + #xfd0203fe + #x2000c0c + #x7050203 + #xf6f5ff0b + #x101700fa + #xfe000905 + #x2fcf5f4 + #x6030b13 + #xf80601fa + #x400110b + #x1070003 + #xf9fb0502 + #x160e02fa + #x10c0502 + #xfff5f1fc + #x1071709 + #x204f902 + #x20c0ffb + #xa03fe06 + #xf80200fd + #x160f05f8 + #x709f902 + #xfceaf705 + #xd1409 + #xa05f9ff + #x70b04f9 + #xdff000f + #xf7fffb02 + #x170e00f5 + #x4fef209 + #xf4e9040b + #x3100d06 + #xf02fbfc + #x607ff00 + #x9fb0a14 + #xf700000b + #x1107faf7 + #xfbf4f610 + #xeff51207 + #x80f0501 + #xc01fef9 + #x303000a + #x3fe1412 + #xfc04040d + #x804fafd + #xf1f1fe0e + #xf30814fb + #xd09fdfd + #x704fef8 + #x302040e + #x31609 + #x207060c + #x608fb01 + #xeff3ff03 + #xfe1409f0 + #xbfdf9fe + #x509fcfb + #x8010c10 + #xff060c05 + #x7070b0e + #xf0bf805 + #xebeffafd + #x814ffef + #x4f3fc01 + #x70bf900 + #xb011510 + #xf9050409 + #xa091109 + #x1b06f20b + #xe2e9f703 + #xf0ffdf1 + #xfbf10003 + #xb07f805 + #xa031a0f + #xf8060010 + #x100e13fc + #x1af8f815 + #xe0ecfe11 + #x130800ee + #xf5f7ff05 + #xe00fa05 + #x5131c0d + #xff07020f + #x160f0af0 + #xdf10817 + #xe0f70714 + #x1507ffe6 + #xf7fef909 + #xbfaff01 + #x41d1a0c + #x8040408 + #x1106fdf4 + #xf9140c + #xe3050b0f + #x1305f6e0 + #xf40f + #x3f904ff + #xd1f140c + #xbfe0402 + #x2fbf903 + #x2060bfc + #xf20b0506 + #xdfeebe0 + #x5f8f614 + #xfafe07ff + #x161f140d + #x7fd0302 + #xf6f90111 + #x805fbf4 + #x70004 + #x3f4e6e4 + #x4f3fe13 + #xf5040903 + #x1b1b1509 + #x4010105 + #xf5fe0b13 + #x9f8edf9 + #x1030108 + #xf7ededf2 + #xf6060a + #xf90a0805 + #x19171602 + #x706fe07 + #xfe041011 + #xfcebf202 + #xfe050507 + #xf0f0fafa + #xfc02fe + #xc0806 + #x14181400 + #xf05f908 + #x4060f11 + #xeeebfe04 + #x20d04fd + #xf1f600fa + #x3fff8f8 + #x60a0905 + #x121b0e01 + #x13fff906 + #x3040f18 + #xeaf803ff + #xd0efaed + #xf3fcfffb + #x8faf1f8 + #x4090a04 + #x16190a06 + #xdf9fa05 + #xfe05151f + #xf503fafb + #x1602ece6 + #xf2fafe05 + #x7f3f5fc + #xff0c0904 + #x1a150e09 + #x3f8fb05 + #xff081a1f + #x304efff + #xff2e6ea + #xecf90312 + #x2f300f8 + #xff100606 + #x1b0f1206 + #xfefbf90c + #x50c1d1a + #xbfbec06 + #xfbe9eaf3 + #xe9fb1019 + #xfe06ed + #x4100006 + #x1a0c11ff + #xf815 + #xb0c1f11 + #x8f2f509 + #xe9eef1f9 + #xed01190f + #x70afee3 + #xd05fa0a + #x120f0cfc + #x400fe1b + #x8101f0a + #x3effd05 + #xe6f8f3fd + #xf5031800 + #x110fede3 + #xffafd0f + #x90f0700 + #x5fe0a1a + #x3141d07 + #xf2ff02 + #xeffcf000 + #xfb0410f4 + #x1a08e1ec + #x4f40615 + #x4100406 + #x4021812 + #x4191304 + #xfdf3fe09 + #xf8f8f003 + #xf90409f2 + #x1afce1f5 + #xf6fa1218 + #x50e0709 + #x50c1b07 + #xf160805 + #xfaf50012 + #xf9f5f603 + #xf60506f4 + #x14f4eaf9 + #xef051617 + #x90a0903 + #xa151402 + #x160a0007 + #xfafc0813 + #xf6f8fdff + #xf60705f7 + #xcf4f5f9 + #xf50f1213 + #xa0509fc + #xf170b03 + #x11fffd08 + #xff06100b + #xf5fdfcfa + #xfc0802f6 + #x9f9f8f8 + #x100b0f + #x60207fb + #x13130507 + #x5f8fc08 + #x7100d01 + #xfafff8fb + #x10600f4 + #x8fcf8fd + #x70b060d + #x10305ff + #x130d0408 + #xfdf5fb0a + #xf1406fc + #xfcfaf803 + #x202fef4 + #xafdfb06 + #x5050409 + #xff040704 + #x11090604 + #xf9f2fb0f + #x131400fa + #xfbf80007 + #x1fbf4 + #x8fc030c + #xff040206 + #x40d07 + #xb060403 + #xf8f2000f + #x1512fdf9 + #xfaff0606 + #xff00f5f4 + #x5fe0e0d + #xfd06ff04 + #x61204 + #x6050203 + #xf6f70507 + #x160f00fa + #xff080901 + #xfaf2f9 + #x103160c + #xff07fa02 + #x10810ff + #x805fe05 + #xf80004fd + #x150b01f9 + #xa09fb0e + #xfcedf600 + #x1121306 + #xbfcfc01 + #x41500fc + #x8fc0402 + #xfbfffa08 + #x150dfef8 + #xdfef612 + #xf0eb0107 + #x7150f05 + #xdfcfcfd + #x80efb02 + #x3f80b0a + #xfcfbfe11 + #x1308f6f9 + #x4f2fa18 + #xe8f90d06 + #xd110bfe + #xafefbfb + #x604fd0b + #xfdff150b + #xfdfe0611 + #xc01f5fd + #xf9f00315 + #xec0b0efe + #xf0905f7 + #x501fafd + #x400050f + #xfc081607 + #x1010a0c + #x500f802 + #xf2f60709 + #xfb1804f3 + #xd0001f5 + #x604f704 + #x4000e0d + #xfd0c0d05 + #x5050d07 + #xb02fa05 + #xf0f7ff00 + #xa16faf0 + #x3f700fb + #xb04f70a + #x503120a + #xff0a040a + #x7081204 + #x1300fb09 + #xeaf2f805 + #x120bf9f0 + #xf8f50103 + #x1100f90a + #x30b1509 + #xff050410 + #x91013f9 + #x12f3010f + #xe0edf915 + #x1306feea + #xf2fa0009 + #x13fcfe06 + #x117130b + #x3070f + #xe1609ee + #x3ee1013 + #xe1f2031e + #x1208fce2 + #xf7fefd0f + #xbf902fd + #x51f110d + #x6020d04 + #xf0df9f2 + #xf8f91a0d + #xe7fe0a17 + #x100af3e0 + #xfefcfb14 + #x1fc04fa + #x111f120f + #x7010b00 + #x6fff300 + #xfa0815ff + #xf6060a0b + #xd05e8e0 + #x2f40017 + #xf80103fe + #x1c1d130d + #x2000404 + #xf9f6fc0d + #x50b01f4 + #x2050305 + #x5f9e2e4 + #xfff00a14 + #xf8060305 + #x1f191605 + #x2000c + #xf3fb0a0e + #x8fef3f5 + #x500010a + #xfbefe2ef + #xf9f4100b + #xfc090509 + #x1e1814fd + #x304fe12 + #xf8041009 + #xffedf3fd + #x50e + #xf2eff0f8 + #xf8fc0c00 + #x30a0708 + #x181b0efa + #xa04fd10 + #x80f09 + #xeeebfe02 + #x2060704 + #xf0f8faf8 + #xff0000f7 + #x90a0804 + #x171d08ff + #xefefd0c + #x1080f13 + #xe9f50200 + #xd0afff4 + #xf3fffaf9 + #x3faf8f5 + #x80b0805 + #x19190704 + #x8f9fd08 + #x6151c + #xf200fefd + #x1502f1e8 + #xf500f704 + #x1f1faf7 + #x40d070a + #x1c120b06 + #xf9fa0c + #xfe0a1e1b + #x1fff4ff + #xff4e7eb + #xf3fc0012 + #xfbf101f5 + #x60e050c + #x1a100f02 + #xfdfaf810 + #x10f1f13 + #x8f5f403 + #xfeeae6f7 + #xf0fc0f16 + #xf7fb04ee + #xd0b030a + #x16130dfd + #xfffbfa18 + #x4151f08 + #x3ebfd05 + #xedebeb02 + #xf1011b0c + #x8fbe6 + #x13040009 + #x101605fd + #x2f8021c + #x4181d04 + #xfbec0401 + #xebf1f007 + #xf60d1afa + #xe0ceae6 + #x10fb020a + #xc15ff04 + #x1f81116 + #x11b1905 + #xf6f10300 + #xf4f4f107 + #xfb1310ee + #x1802e0ed + #x3f80910 + #xa10000b + #xffff1c0d + #x51d1306 + #xf5f5ff07 + #xfdf1f306 + #xfb1102ed + #x19f3e3f4 + #xf4fd1119 + #xc0b070c + #xff0c1b05 + #x101b0a05 + #xf4f40212 + #xfceff904 + #xfa0ffdf2 + #xfeaeef6 + #xf008161e + #xd080d01 + #x6170e02 + #x18100305 + #xf4f80a16 + #xf8f3feff + #xfa0dfdf6 + #x4ecf7f3 + #xf811151c + #xd090af7 + #xf170406 + #x13020106 + #xf900110d + #xf7fafdfb + #xfe0cfef5 + #xf4f9f3 + #x5111018 + #x80802f4 + #x14120209 + #x5fb0208 + #x20c1002 + #xfbfcf7fc + #x20afcf4 + #x2f8f8f8 + #xc0b0c12 + #x20800fc + #x130b0608 + #xfcf8010c + #xc1106fd + #xfef8f701 + #x308faf4 + #x3f8fb00 + #xa06090f + #x80103 + #xf080904 + #xf9f4000f + #x140f00fa + #xfcf5fd09 + #x205f6f6 + #x3f90404 + #x303060d + #x80805 + #xa080700 + #xf6f2040f + #x150b00f7 + #xf8fb040a + #x102f4f6 + #xfc0e05 + #x103020c + #x10b0d01 + #x8070300 + #xf1f7090a + #x160900f5 + #xfb06060b + #x1fbf1f7 + #xfc041304 + #x4010009 + #x1110bfc + #x9040201 + #xf1ff0705 + #x140a02f8 + #x40d000a + #xfff0f4fd + #xe1507 + #xafefd05 + #x21504fa + #x8ff0203 + #xf902fd03 + ) + ) + + + + diff --git a/test/decompiler/reference/engine/gfx/ocean/ocean-tables_REF.gc b/test/decompiler/reference/engine/gfx/ocean/ocean-tables_REF.gc new file mode 100644 index 0000000000..83d0052755 --- /dev/null +++ b/test/decompiler/reference/engine/gfx/ocean/ocean-tables_REF.gc @@ -0,0 +1,11589 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *ocean-spheres-village1*, type ocean-spheres +(define + *ocean-spheres-village1* + (new 'static 'ocean-spheres :spheres (new 'static 'inline-array sphere 36 + (new 'static 'sphere :x -7864320.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z -7864320.0 :w 2224365.5) + (new 'static 'sphere :x -7864320.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z -4718592.0 :w 2224365.5) + (new 'static 'sphere :x -7864320.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z -1572864.0 :w 2224365.5) + (new 'static 'sphere :x -7864320.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z 1572864.0 :w 2224365.5) + (new 'static 'sphere :x -7864320.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z 4718592.0 :w 2224365.5) + (new 'static 'sphere :x -7864320.0 :z 7864320.0 :w 2224365.5) + (new 'static 'sphere :x -4718592.0 :z 7864320.0 :w 2224365.5) + (new 'static 'sphere :x -1572864.0 :z 7864320.0 :w 2224365.5) + (new 'static 'sphere :x 1572864.0 :z 7864320.0 :w 2224365.5) + (new 'static 'sphere :x 4718592.0 :z 7864320.0 :w 2224365.5) + (new 'static 'sphere :x 7864320.0 :z 7864320.0 :w 2224365.5) + ) + ) + ) + +;; definition for symbol *ocean-colors-village1*, type ocean-colors +(define + *ocean-colors-village1* + (new 'static 'ocean-colors :colors (new 'static 'array rgba 2548 + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x3 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x35 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x35 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x47 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x48 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #xc :g #x37 :b #x48 :a #x80) + (new 'static 'rgba :r #xc :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2d :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4c :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x4a :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x4a :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4b :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x4d :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4f :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x50 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4f :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x4d :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4c :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4e :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x4c :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x4a :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x4e :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4c :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x48 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4e :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x54 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x57 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x58 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x55 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x55 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x56 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x59 :a #x80) + (new 'static 'rgba :r #x21 :g #x50 :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x4c :b #x5a :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x59 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x57 :a #x80) + (new 'static 'rgba :r #x1b :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x51 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4f :a #x80) + (new 'static 'rgba :r #xd :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #xc :g #x38 :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4c :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x50 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x51 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x51 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x52 :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x50 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4e :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x8 :g #x33 :b #x44 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x5a :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x5c :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x5a :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x55 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x3e :b #x50 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x50 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x3c :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x53 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x53 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x53 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x52 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x50 :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4c :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x2d :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x53 :a #x80) + (new 'static 'rgba :r #x22 :g #x4e :b #x5a :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5b :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5c :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x55 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5d :a #x80) + (new 'static 'rgba :r #x22 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x5b :a #x80) + (new 'static 'rgba :r #x1e :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x57 :a #x80) + (new 'static 'rgba :r #x1b :g #x4c :b #x57 :a #x80) + (new 'static 'rgba :r #x19 :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x54 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x55 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x55 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #x9 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x9 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #x1b :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x51 :b #x5a :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x25 :g #x55 :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x51 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x56 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x56 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x55 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x55 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5d :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x5b :a #x80) + (new 'static 'rgba :r #x1c :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x18 :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x54 :a #x80) + (new 'static 'rgba :r #x13 :g #x44 :b #x55 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x56 :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x4e :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x20 :g #x50 :b #x59 :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x56 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x56 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5f :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x50 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5d :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x21 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x59 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x55 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x55 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x55 :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x56 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x56 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x4f :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x10 :g #x3b :b #x4a :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x4f :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x57 :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x27 :g #x53 :b #x5f :a #x80) + (new 'static 'rgba :r #x28 :g #x57 :b #x60 :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x23 :g #x53 :b #x5b :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x54 :b #x5c :a #x80) + (new 'static 'rgba :r #x23 :g #x52 :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x5c :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x18 :g #x48 :b #x57 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x55 :a #x80) + (new 'static 'rgba :r #x16 :g #x47 :b #x56 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x57 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x4f :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x40 :a #x80) + (new 'static 'rgba :r #x12 :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x4b :b #x57 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x5a :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x5a :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x5b :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x56 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x56 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5a :a #x80) + (new 'static 'rgba :r #x22 :g #x4e :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x5a :a #x80) + (new 'static 'rgba :r #x1f :g #x4d :b #x5a :a #x80) + (new 'static 'rgba :r #x17 :g #x47 :b #x55 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x53 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x53 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x55 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x55 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x12 :g #x3e :b #x4b :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x57 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x59 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x5a :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x5a :a #x80) + (new 'static 'rgba :r #x1f :g #x4b :b #x5a :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x5b :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x5d :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x5c :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x5c :a #x80) + (new 'static 'rgba :r #x20 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5e :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x54 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x5b :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x50 :b #x59 :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x58 :a #x80) + (new 'static 'rgba :r #x1d :g #x4d :b #x57 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x51 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x50 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x51 :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x52 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x53 :a #x80) + (new 'static 'rgba :r #x13 :g #x44 :b #x53 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x4a :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x53 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x57 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x58 :a #x80) + (new 'static 'rgba :r #x1f :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x1f :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x5b :a #x80) + (new 'static 'rgba :r #x1c :g #x4d :b #x5a :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x58 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x57 :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x56 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x57 :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x5a :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x58 :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x58 :a #x80) + (new 'static 'rgba :r #x1f :g #x4d :b #x57 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x1d :g #x4c :b #x56 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x1a :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x51 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x50 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x50 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x50 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3d :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2f :b #x38 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x55 :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x57 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x59 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x58 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x56 :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x55 :a #x80) + (new 'static 'rgba :r #x13 :g #x3e :b #x54 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x58 :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x1f :g #x4d :b #x59 :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x5b :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x58 :a #x80) + (new 'static 'rgba :r #x1f :g #x4e :b #x57 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x53 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x53 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x52 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x51 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x4f :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x4f :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x50 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4c :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x4f :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x51 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x50 :a #x80) + (new 'static 'rgba :r #xf :g #x3a :b #x50 :a #x80) + (new 'static 'rgba :r #xf :g #x3a :b #x4f :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x55 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x55 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x57 :a #x80) + (new 'static 'rgba :r #x1d :g #x4c :b #x59 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x56 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x56 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x57 :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x58 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x57 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x52 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x51 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x51 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x51 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x50 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x50 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x4f :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x4d :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4d :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #xa :g #x36 :b #x47 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x48 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x4c :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x55 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x57 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x57 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x52 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x52 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x50 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x4f :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x4d :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x4d :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x4d :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x4d :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4c :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4f :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x53 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x55 :a #x80) + (new 'static 'rgba :r #x17 :g #x48 :b #x57 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x57 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x51 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x51 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x51 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x52 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x51 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x4f :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x4d :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4b :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x4b :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4a :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x47 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x50 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x3e :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x56 :a #x80) + (new 'static 'rgba :r #x18 :g #x47 :b #x58 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x58 :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x56 :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x51 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x51 :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x4f :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4d :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4b :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4a :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x49 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x46 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x3e :b #x55 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x57 :a #x80) + (new 'static 'rgba :r #x18 :g #x48 :b #x58 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x59 :a #x80) + (new 'static 'rgba :r #x1c :g #x4c :b #x59 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x57 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x51 :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x53 :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x55 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x56 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x53 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x50 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x4d :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4a :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x56 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x59 :a #x80) + (new 'static 'rgba :r #x1c :g #x4c :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x5c :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x5c :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5a :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x56 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x53 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x53 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x55 :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x52 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4a :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x4 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x3f :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #x16 :g #x47 :b #x56 :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x5a :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x5c :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5e :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x5b :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x57 :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x52 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x52 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x53 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x53 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x4f :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x4d :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x4 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x3 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x57 :a #x80) + (new 'static 'rgba :r #x21 :g #x51 :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x53 :b #x5f :a #x80) + (new 'static 'rgba :r #x28 :g #x55 :b #x5f :a #x80) + (new 'static 'rgba :r #x27 :g #x53 :b #x5f :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x5d :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x5b :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x57 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x55 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x53 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x4f :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x4d :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x4b :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x49 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x4 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x2 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x7 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x50 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x57 :a #x80) + (new 'static 'rgba :r #x22 :g #x52 :b #x5d :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x5f :a #x80) + (new 'static 'rgba :r #x26 :g #x56 :b #x5f :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x5d :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x5c :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x5a :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x59 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x57 :a #x80) + (new 'static 'rgba :r #x18 :g #x47 :b #x56 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x56 :a #x80) + (new 'static 'rgba :r #x1b :g #x4a :b #x55 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x54 :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x51 :a #x80) + (new 'static 'rgba :r #x1d :g #x46 :b #x4d :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x4b :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x40 :a #x80) + (new 'static 'rgba :r #x4 :g #x35 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x34 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x4c :b #x59 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x5b :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x5b :a #x80) + (new 'static 'rgba :r #x1c :g #x4a :b #x59 :a #x80) + (new 'static 'rgba :r #x1a :g #x49 :b #x58 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x57 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x57 :a #x80) + (new 'static 'rgba :r #x19 :g #x4a :b #x56 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x57 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x56 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x54 :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x55 :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x53 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x50 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x4e :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x4c :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x4a :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x49 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x40 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4d :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x50 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x54 :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x53 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x53 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x52 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x53 :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x52 :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x51 :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x50 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4f :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x4e :b #x53 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x52 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x4e :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x39 :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x4e :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4e :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4f :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4f :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x4e :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x56 :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x57 :a #x80) + (new 'static 'rgba :r #x22 :g #x4e :b #x54 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x52 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x4f :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x39 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3d :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x43 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x49 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x4c :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4e :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x51 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x51 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x48 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x49 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x4d :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x56 :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x57 :a #x80) + (new 'static 'rgba :r #x25 :g #x50 :b #x57 :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x55 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x51 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3d :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2f :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x41 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x7 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4d :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x40 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x4b :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x53 :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x56 :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x57 :a #x80) + (new 'static 'rgba :r #x22 :g #x4e :b #x56 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x52 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x48 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x40 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4c :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x50 :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x54 :a #x80) + (new 'static 'rgba :r #x16 :g #x46 :b #x57 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x56 :a #x80) + (new 'static 'rgba :r #x15 :g #x46 :b #x54 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x51 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4a :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x26 :g #x51 :b #x53 :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x51 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x9 :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x47 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x4c :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x4c :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x4a :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x42 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x4f :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x59 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x59 :a #x80) + (new 'static 'rgba :r #x1a :g #x49 :b #x56 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x4e :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #xf :g #x42 :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x42 :b #x45 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x44 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x1a :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x21 :g #x47 :b #x42 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x49 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #xc :g #x3d :b #x46 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x4a :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x4a :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x4c :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x4e :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x4f :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x50 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x4f :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4c :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x40 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x45 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x4f :a #x80) + (new 'static 'rgba :r #x17 :g #x47 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x56 :a #x80) + (new 'static 'rgba :r #x21 :g #x52 :b #x5a :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x58 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x55 :a #x80) + (new 'static 'rgba :r #x18 :g #x49 :b #x4f :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x44 :b #x46 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x42 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x3e :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x3d :a #x80) + (new 'static 'rgba :r #x14 :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #x19 :g #x40 :b #x39 :a #x80) + (new 'static 'rgba :r #x1c :g #x41 :b #x38 :a #x80) + (new 'static 'rgba :r #x1f :g #x43 :b #x3b :a #x80) + (new 'static 'rgba :r #x20 :g #x45 :b #x3e :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x3e :a #x80) + (new 'static 'rgba :r #x1c :g #x44 :b #x40 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x46 :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x4a :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4b :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4c :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x50 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x52 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x50 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x4e :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x49 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x4e :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x55 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x55 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x4f :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x51 :a #x80) + (new 'static 'rgba :r #x1f :g #x50 :b #x53 :a #x80) + (new 'static 'rgba :r #x1a :g #x4b :b #x4e :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x45 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x3b :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x39 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x37 :a #x80) + (new 'static 'rgba :r #x14 :g #x3f :b #x35 :a #x80) + (new 'static 'rgba :r #x17 :g #x40 :b #x34 :a #x80) + (new 'static 'rgba :r #x1a :g #x41 :b #x35 :a #x80) + (new 'static 'rgba :r #x1e :g #x42 :b #x36 :a #x80) + (new 'static 'rgba :r #x1f :g #x43 :b #x35 :a #x80) + (new 'static 'rgba :r #x1d :g #x42 :b #x38 :a #x80) + (new 'static 'rgba :r #x1b :g #x41 :b #x39 :a #x80) + (new 'static 'rgba :r #x17 :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x47 :a #x80) + (new 'static 'rgba :r #x10 :g #x42 :b #x48 :a #x80) + (new 'static 'rgba :r #x10 :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x49 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x4e :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x51 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x53 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x54 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x53 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x4f :a #x80) + (new 'static 'rgba :r #xf :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #x9 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x4b :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x4f :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x52 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x54 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x4c :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x46 :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x3c :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x39 :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x36 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x36 :a #x80) + (new 'static 'rgba :r #x12 :g #x3e :b #x31 :a #x80) + (new 'static 'rgba :r #x15 :g #x40 :b #x2e :a #x80) + (new 'static 'rgba :r #x18 :g #x40 :b #x2e :a #x80) + (new 'static 'rgba :r #x1b :g #x41 :b #x2f :a #x80) + (new 'static 'rgba :r #x1c :g #x42 :b #x31 :a #x80) + (new 'static 'rgba :r #x1b :g #x42 :b #x32 :a #x80) + (new 'static 'rgba :r #x19 :g #x42 :b #x34 :a #x80) + (new 'static 'rgba :r #x16 :g #x40 :b #x3b :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x3e :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x44 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x46 :a #x80) + (new 'static 'rgba :r #x10 :g #x42 :b #x47 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x48 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x49 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x4d :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x53 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x55 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x55 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x54 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x52 :a #x80) + (new 'static 'rgba :r #x13 :g #x3f :b #x50 :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #xc :g #x38 :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x52 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x54 :a #x80) + (new 'static 'rgba :r #x1d :g #x4c :b #x54 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x4c :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x46 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x45 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x37 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x34 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x35 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x30 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x2c :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x2a :a #x80) + (new 'static 'rgba :r #x14 :g #x3e :b #x29 :a #x80) + (new 'static 'rgba :r #x16 :g #x3f :b #x27 :a #x80) + (new 'static 'rgba :r #x17 :g #x3f :b #x29 :a #x80) + (new 'static 'rgba :r #x16 :g #x3f :b #x2c :a #x80) + (new 'static 'rgba :r #x15 :g #x3f :b #x30 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x36 :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x40 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x43 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x45 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x46 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x47 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x47 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x48 :a #x80) + (new 'static 'rgba :r #x10 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x4e :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x51 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x53 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x54 :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x52 :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x4f :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x4a :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #xe :g #x3a :b #x4b :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x50 :a #x80) + (new 'static 'rgba :r #x1a :g #x48 :b #x55 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x54 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x4f :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x48 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x44 :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x40 :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x36 :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x33 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x31 :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x30 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x2b :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x26 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x22 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x1c :a #x80) + (new 'static 'rgba :r #xf :g #x3a :b #x1d :a #x80) + (new 'static 'rgba :r #x10 :g #x3b :b #x21 :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x24 :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x2b :a #x80) + (new 'static 'rgba :r #x11 :g #x3e :b #x30 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x38 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x42 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x43 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x44 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x44 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x46 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x48 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x4f :a #x80) + (new 'static 'rgba :r #x16 :g #x46 :b #x53 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x54 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x53 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x50 :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x4d :a #x80) + (new 'static 'rgba :r #xa :g #x36 :b #x48 :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x3f :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x31 :b #x3c :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x4a :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x51 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x56 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x53 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x4e :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x48 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x47 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x44 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x13 :g #x3e :b #x39 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x33 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x2d :a #x80) + (new 'static 'rgba :r #xf :g #x3d :b #x2a :a #x80) + (new 'static 'rgba :r #xe :g #x3d :b #x2a :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x24 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x21 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x19 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x17 :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x15 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x16 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x1c :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x23 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x2d :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x35 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x3e :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x41 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x42 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x42 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x44 :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x46 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x4d :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x51 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x52 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x52 :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x4f :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x4a :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x3d :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3f :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x49 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x50 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x55 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x55 :a #x80) + (new 'static 'rgba :r #x1d :g #x4c :b #x51 :a #x80) + (new 'static 'rgba :r #x18 :g #x48 :b #x4b :a #x80) + (new 'static 'rgba :r #x19 :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x18 :g #x47 :b #x49 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x3f :b #x3b :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x34 :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x2e :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x29 :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x29 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x22 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x1f :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x18 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x12 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #xe :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #xd :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x10 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x15 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x1f :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x26 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x2e :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x33 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x39 :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x3e :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x3f :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x3e :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x3f :a #x80) + (new 'static 'rgba :r #xe :g #x3e :b #x44 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x47 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x4b :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x4f :a #x80) + (new 'static 'rgba :r #x11 :g #x3d :b #x51 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x50 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x46 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x4c :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x52 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x50 :a #x80) + (new 'static 'rgba :r #x19 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #x10 :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x37 :a #x80) + (new 'static 'rgba :r #xd :g #x3b :b #x30 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x2d :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x25 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x23 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x1e :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x19 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x14 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x12 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xa :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xa :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #xb :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #xe :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x17 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x1f :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x24 :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x2e :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x32 :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x37 :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x3b :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x3c :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x3d :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x3e :b #x41 :a #x80) + (new 'static 'rgba :r #xe :g #x42 :b #x47 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x4e :a #x80) + (new 'static 'rgba :r #xf :g #x3b :b #x50 :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4e :a #x80) + (new 'static 'rgba :r #xa :g #x36 :b #x49 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x4 :g #x2e :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2f :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x4c :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x13 :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x45 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x3a :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x36 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x30 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x2c :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x26 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x20 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x1d :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x15 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x11 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #xf :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xc :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xa :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xc :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #xb :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x10 :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x19 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x1f :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x26 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x2b :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x2f :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x36 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x37 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x3b :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x3b :a #x80) + (new 'static 'rgba :r #xe :g #x3c :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x46 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4e :a #x80) + (new 'static 'rgba :r #xf :g #x3c :b #x4e :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x4b :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x45 :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x41 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x3d :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x37 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x37 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x33 :a #x80) + (new 'static 'rgba :r #xb :g #x3c :b #x31 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x29 :a #x80) + (new 'static 'rgba :r #x9 :g #x39 :b #x26 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x20 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x1b :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x16 :a #x80) + (new 'static 'rgba :r #x4 :g #x34 :b #x11 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #xf :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xb :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x8 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x9 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xa :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #xc :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x10 :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x16 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x1c :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x23 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x2a :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x2e :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x33 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x36 :a #x80) + (new 'static 'rgba :r #xc :g #x3b :b #x3b :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x47 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4d :a #x80) + (new 'static 'rgba :r #xd :g #x39 :b #x4c :a #x80) + (new 'static 'rgba :r #xa :g #x36 :b #x48 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x40 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x8 :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x9 :g #x3c :b #x42 :a #x80) + (new 'static 'rgba :r #xa :g #x3c :b #x3d :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x3a :a #x80) + (new 'static 'rgba :r #xc :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x36 :a #x80) + (new 'static 'rgba :r #xc :g #x3a :b #x33 :a #x80) + (new 'static 'rgba :r #xb :g #x3b :b #x2f :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x2b :a #x80) + (new 'static 'rgba :r #x9 :g #x38 :b #x27 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x24 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x20 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x18 :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x16 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x11 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xd :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xa :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x9 :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xc :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xd :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #xe :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x12 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x15 :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x1b :a #x80) + (new 'static 'rgba :r #x8 :g #x36 :b #x23 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x28 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x2f :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #xc :g #x3c :b #x3a :a #x80) + (new 'static 'rgba :r #xd :g #x40 :b #x43 :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #xf :g #x3e :b #x4b :a #x80) + (new 'static 'rgba :r #xe :g #x3b :b #x4c :a #x80) + (new 'static 'rgba :r #xb :g #x37 :b #x49 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x4 :g #x34 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x3 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x31 :b #x3f :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x41 :a #x80) + (new 'static 'rgba :r #x7 :g #x38 :b #x40 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x3f :a #x80) + (new 'static 'rgba :r #x9 :g #x3a :b #x3d :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x39 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x38 :a #x80) + (new 'static 'rgba :r #xb :g #x38 :b #x35 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x31 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x30 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x2d :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x2c :a #x80) + (new 'static 'rgba :r #x9 :g #x35 :b #x28 :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x24 :a #x80) + (new 'static 'rgba :r #x7 :g #x32 :b #x22 :a #x80) + (new 'static 'rgba :r #x6 :g #x31 :b #x1a :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x16 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x15 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x11 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x10 :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x12 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x11 :a #x80) + (new 'static 'rgba :r #x4 :g #x2f :b #x11 :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x15 :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x18 :a #x80) + (new 'static 'rgba :r #x6 :g #x30 :b #x1b :a #x80) + (new 'static 'rgba :r #x8 :g #x31 :b #x20 :a #x80) + (new 'static 'rgba :r #x9 :g #x33 :b #x26 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x2e :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #xc :g #x3d :b #x3d :a #x80) + (new 'static 'rgba :r #xc :g #x40 :b #x45 :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x48 :a #x80) + (new 'static 'rgba :r #xd :g #x3a :b #x4a :a #x80) + (new 'static 'rgba :r #xb :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x41 :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x30 :b #x3e :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x37 :b #x3d :a #x80) + (new 'static 'rgba :r #x7 :g #x38 :b #x3d :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x3d :a #x80) + (new 'static 'rgba :r #x9 :g #x3a :b #x38 :a #x80) + (new 'static 'rgba :r #xa :g #x39 :b #x39 :a #x80) + (new 'static 'rgba :r #xa :g #x38 :b #x34 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x34 :a #x80) + (new 'static 'rgba :r #x9 :g #x37 :b #x30 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x32 :a #x80) + (new 'static 'rgba :r #x9 :g #x36 :b #x2f :a #x80) + (new 'static 'rgba :r #x8 :g #x35 :b #x2e :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x29 :a #x80) + (new 'static 'rgba :r #x7 :g #x32 :b #x27 :a #x80) + (new 'static 'rgba :r #x6 :g #x31 :b #x23 :a #x80) + (new 'static 'rgba :r #x6 :g #x30 :b #x23 :a #x80) + (new 'static 'rgba :r #x6 :g #x30 :b #x21 :a #x80) + (new 'static 'rgba :r #x7 :g #x2f :b #x20 :a #x80) + (new 'static 'rgba :r #x6 :g #x2f :b #x1e :a #x80) + (new 'static 'rgba :r #x5 :g #x2e :b #x1b :a #x80) + (new 'static 'rgba :r #x5 :g #x2e :b #x1c :a #x80) + (new 'static 'rgba :r #x6 :g #x2e :b #x1d :a #x80) + (new 'static 'rgba :r #x6 :g #x2f :b #x1f :a #x80) + (new 'static 'rgba :r #x6 :g #x31 :b #x23 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x29 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x2c :a #x80) + (new 'static 'rgba :r #x8 :g #x37 :b #x31 :a #x80) + (new 'static 'rgba :r #x8 :g #x3a :b #x39 :a #x80) + (new 'static 'rgba :r #xa :g #x3a :b #x41 :a #x80) + (new 'static 'rgba :r #xa :g #x3c :b #x44 :a #x80) + (new 'static 'rgba :r #xb :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #xa :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x8 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x5 :g #x31 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3c :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x3d :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3d :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x3e :a #x80) + (new 'static 'rgba :r #x7 :g #x39 :b #x3e :a #x80) + (new 'static 'rgba :r #x8 :g #x3c :b #x3e :a #x80) + (new 'static 'rgba :r #x8 :g #x39 :b #x3c :a #x80) + (new 'static 'rgba :r #x8 :g #x39 :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x39 :a #x80) + (new 'static 'rgba :r #x8 :g #x38 :b #x39 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x38 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x37 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x34 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x35 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x34 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x33 :a #x80) + (new 'static 'rgba :r #x7 :g #x38 :b #x33 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x33 :a #x80) + (new 'static 'rgba :r #x7 :g #x36 :b #x2f :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x2d :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x2a :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x28 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x29 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x2a :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x30 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x34 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x38 :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x3c :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3f :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3f :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3d :a #x80) + (new 'static 'rgba :r #x2 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3c :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3d :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3d :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x33 :b #x3c :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x3b :a #x80) + (new 'static 'rgba :r #x4 :g #x36 :b #x3b :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x3d :a #x80) + (new 'static 'rgba :r #x7 :g #x35 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x3d :a #x80) + (new 'static 'rgba :r #x5 :g #x36 :b #x3b :a #x80) + (new 'static 'rgba :r #x4 :g #x36 :b #x38 :a #x80) + (new 'static 'rgba :r #x4 :g #x35 :b #x36 :a #x80) + (new 'static 'rgba :r #x4 :g #x35 :b #x35 :a #x80) + (new 'static 'rgba :r #x4 :g #x35 :b #x36 :a #x80) + (new 'static 'rgba :r #x4 :g #x35 :b #x37 :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x39 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x3a :a #x80) + (new 'static 'rgba :r #x4 :g #x33 :b #x3b :a #x80) + (new 'static 'rgba :r #x4 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x32 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3c :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x31 :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x3b :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2f :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x2e :b #x3a :a #x80) + (new 'static 'rgba :r #x3 :g #x30 :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x3a :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2f :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2b :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x39 :a #x80) + (new 'static 'rgba :r #x1 :g #x2e :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2c :b #x38 :a #x80) + (new 'static 'rgba :r #x2 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba :r #x1 :g #x2d :b #x38 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + ) + ) + ) + +;; definition for symbol *ocean-near-indices-village1*, type ocean-near-indices +(define + *ocean-near-indices-village1* + (new 'static 'ocean-near-indices + :data + (new 'static 'inline-array ocean-near-index 68 + (new 'static 'ocean-near-index) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x1 + #xffff + #xffff + #x0 + #x2 + #xffff + #xffff + #x0 + #x0 + #x3 + #xffff + #x0 + #x0 + #x3 + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x4 + #x0 + #x5 + #xffff + #x6 + #x0 + #x7 + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x8 + #x9 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #xa #xb #x0 #x0 #x0 #x14 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #x15 + #xffff + #xffff + #xffff + #x0 + #x1a + #xffff + #xffff + #x0 + #x20 + #x21 + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xc #xd #xe #xf #xffff #xffff #x16 #x17 #xffff #x1b #x1c #x0 #x22 #x23 #x24 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x10 #x11 #x12 #x13 #x0 #x0 #x18 #x19 #x1d #x1e #x0 #x1f #x0 #x0 #x0 #x25) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x26 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x27 #x0 #x17 #x0 #x0 #x0 #x0 #x2b #x0 #x0 #x0 #x2e #x0 #x0 #x0 #x32) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x28 + #x29 + #x2a + #x2c + #x2d + #xffff + #xffff + #x2f + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x30 + #x31 + #xffff + #x33 + #x34 + #x35 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xb + #xffff + #xffff + #xffff + #x36 + #x37 + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x38 #x0 #x0 #x0 #x38 #x0 #x0 #x0 #x48 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x19 + #xffff + #xffff + #xffff + #x4f + #x50 + #x51 + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #x3e + #x3f + #x40 + #x41 + #x49 + #x4a + #x4b + #x4c + #xffff + #xffff + #xffff + #x52 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x39 + #x3a + #x2d + #xffff + #x42 + #x43 + #xffff + #xffff + #x4d + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x3b + #x3c + #xffff + #xffff + #xffff + #x44 + #x45 + #x46 + #xffff + #xffff + #x4e + #x0 + #xffff + #xffff + #x53 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x3d #x0 #x0 #x0 #x47 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x54 #xffff #x0 #x0 #x59 #xffff #x0 #x0 #x5c #x56 #x0 #x62 #x63 #x64) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x65 + #x66 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #x55 + #x56 + #xffff + #xffff + #x5a + #x5b + #xffff + #xffff + #x5d + #x5e + #x5f + #x67 + #x68 + #x69 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x60 + #x60 + #x60 + #x61 + #x0 + #x0 + #x0 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #x57 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x6a + #x6b + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x58 #x0 #x0 #x0 #x3d #x0 #x0 #x0 #x3d #x0 #x0 #x0 #x3d #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x6c + #xffff + #xffff + #x0 + #x70 + #xffff + #xffff + #x0 + #x70 + #xffff + #xffff + #x0 + #x7e + #x7f + #x80 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x81 + #x82 + #x83 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #x6d + #xffff + #x71 + #x72 + #x17 + #x77 + #x78 + #x79 + #x7a + #x0 + #x0 + #x84 + #x85 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x6e #x41 #x6f #x0 #x73 #x74 #x75 #x76 #x7b #x7c #x7d #x17 #x86 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x87 #x88 #x0 #x0 #x8e #xffff #x0 #x0 #x91 #xffff #x0 #x0 #x95 #x96) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #x89 + #x20 + #x8a + #xffff + #x8f + #x0 + #x0 + #xffff + #x92 + #x0 + #x0 + #xffff + #x97 + #x0 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x8b #x0 #x0 #x8c #x0 #x0 #x0 #x90 #x0 #x0 #x0 #x93 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #x8d #x0 #x0 #x66 #x0 #x0 #x0 #x94 #x0 #x0 #x0 #x98 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x20 #x0 #x0 #x0 #x9b #x0 #x0 #x0 #x0 #x0 #x9d #x9e #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x99 #x9a #x0 #x0 #x9c #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x9f #xa0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xa1 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x79 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xb2 #xb3 #xb4 #xb5) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xb6 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xab #xac #x0 #xb7 #xb8 #xb9) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x0 + #xa2 + #xa3 + #x0 + #xa6 + #xa7 + #xffff + #xad + #xae + #xaf + #xffff + #xba + #xbb + #xbc + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xa4 + #xa5 + #x0 + #x0 + #xffff + #xffff + #xa8 + #x0 + #xffff + #xffff + #xb0 + #xb1 + #xffff + #xffff + #xbd + #xbe + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #xa9 #xaa #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #xbf + #xc0 + #xc1 + #x0 + #xcc + #xffff + #xffff + #x0 + #xd3 + #xffff + #xffff + #xd8 + #xd9 + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xc2 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xc3 + #x0 + #x0 + #xffff + #xcd + #x0 + #x0 + #xffff + #xd4 + #xc3 + #x0 + #xffff + #xda + #x12 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #xc4 #x0 #x0 #x70 #x3b #x0 #x0 #xffff #xffff #x0 #x0 #xffff #xffff) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #xc5 + #xc6 + #xc7 + #xce + #xcf + #xd0 + #xd1 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xdb + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xc8 + #xc9 + #xca + #xffff + #xc2 + #xffff + #xffff + #xffff + #xd5 + #xd6 + #xd7 + #xffff + #x0 + #x0 + #x0 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xd2 + #xffff + #xffff + #xffff + #x0 + #x3 + #xffff + #xffff + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xcb #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #xdc + #xdd + #xde + #xe3 + #xe4 + #xffff + #xffff + #x5c + #x56 + #xffff + #xffff + #xf0 + #x2d + #x40 + #xf1 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x64 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xf2 + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xf3 + #xf4 + #xf5 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #xdf #x0 #x0 #xffff #xe5 #xe6 #x0 #xea #xeb #xec #x0 #xf6 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x0 + #xffff + #xffff + #x0 + #x0 + #xffff + #xffff + #x0 + #x0 + #xffff + #xffff + #x0 + #x0 + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xe0 + #xe1 + #xffff + #xffff + #xe7 + #x0 + #xffff + #xffff + #xed + #x0 + #xffff + #xffff + #xf7 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xe2 + #xffff + #xffff + #x0 + #x0 + #xe8 + #xffff + #xe9 + #x0 + #x0 + #xee + #xef + #x0 + #xf8 + #xf9 + #x12 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xfa #xfb #xfc #xfd #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xfe + #xffff + #xffff + #xffff + #x105 + #xb + #xffff + #xffff + #x0 + #x0 + #x4f + #x0 + #x0 + #x0 + #x0 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xff #x100 #x0 #x0 #x106 #x107 #x0 #x0 #x10d #x10e #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x101 #xffff #x0 #x0 #x0 #xfa #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #x102 + #x108 + #xffff + #xffff + #x109 + #xfa + #x10f + #xffff + #xffff + #x0 + #x0 + #x114 + #x115 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x0 + #x0 + #x0 + #x10a + #x0 + #x0 + #x10b + #xffff + #xffff + #x110 + #x111 + #xffff + #x116 + #xfd + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x103 #x104 #xc3 #x0 #xffff #x10c #x17 #x0 #x112 #x113 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x0 #x117 #x0 #x118 #x0 #x11a #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x0 #x119 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + ) + ) + ) + +;; definition for symbol *ocean-trans-indices-village1*, type ocean-trans-indices +(define + *ocean-trans-indices-village1* + (new 'static 'ocean-trans-indices :data (new 'static 'inline-array ocean-trans-index 2304 + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x11b :child 1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent #x11c :child 2) + (new 'static 'ocean-trans-index :parent #x11d :child 3) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 4) + (new 'static 'ocean-trans-index :parent #x11e :child 5) + (new 'static 'ocean-trans-index :parent #x11f :child 6) + (new 'static 'ocean-trans-index :child 7) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 8) + (new 'static 'ocean-trans-index :child 9) + (new 'static 'ocean-trans-index :parent #x120 :child 10) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent #x121 :child 11) + (new 'static 'ocean-trans-index :parent 33 :child 12) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 13) + (new 'static 'ocean-trans-index :parent #x122 :child 14) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent #x123 :child 15) + (new 'static 'ocean-trans-index :parent #x124 :child 16) + (new 'static 'ocean-trans-index :parent #x125 :child 17) + (new 'static 'ocean-trans-index :child 18) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x126 :child 19) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent #x11d :child 20) + (new 'static 'ocean-trans-index :parent #x127 :child 21) + (new 'static 'ocean-trans-index :parent 71 :child 22) + (new 'static 'ocean-trans-index :parent #x128 :child 23) + (new 'static 'ocean-trans-index :child 24) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x129 :child 25) + (new 'static 'ocean-trans-index :parent #x12a :child 26) + (new 'static 'ocean-trans-index :parent #x12b :child 27) + (new 'static 'ocean-trans-index :child 28) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #xc5 :child 29) + (new 'static 'ocean-trans-index :parent 6 :child 30) + (new 'static 'ocean-trans-index :child 31) + (new 'static 'ocean-trans-index :parent 23 :child 32) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 33) + (new 'static 'ocean-trans-index :child 34) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 35) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 36) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 37) + (new 'static 'ocean-trans-index :child 38) + (new 'static 'ocean-trans-index :child 39) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 40) + (new 'static 'ocean-trans-index :parent #x12c :child 41) + (new 'static 'ocean-trans-index :parent #x12d :child 42) + (new 'static 'ocean-trans-index :child 43) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x12e :child 44) + (new 'static 'ocean-trans-index :parent 45 :child 45) + (new 'static 'ocean-trans-index :parent 6 :child 46) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x8b :child 47) + (new 'static 'ocean-trans-index :parent #x12f :child 48) + (new 'static 'ocean-trans-index :parent #x130 :child 49) + (new 'static 'ocean-trans-index :parent #x131 :child 50) + (new 'static 'ocean-trans-index :child 51) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x132 :child 52) + (new 'static 'ocean-trans-index :parent #x133 :child 53) + (new 'static 'ocean-trans-index :parent #x12a :child 54) + (new 'static 'ocean-trans-index :parent 18 :child 55) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent 3 :child 56) + (new 'static 'ocean-trans-index :parent #x7c :child 57) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent #x134 :child 58) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 59) + (new 'static 'ocean-trans-index :parent #x69 :child 60) + (new 'static 'ocean-trans-index :child 61) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent 20 :child 62) + (new 'static 'ocean-trans-index :parent #x135 :child 63) + (new 'static 'ocean-trans-index :parent #x136 :child 64) + (new 'static 'ocean-trans-index :parent #x137 :child 65) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :child 66) + (new 'static 'ocean-trans-index :child 67) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + ) + ) + ) + +;; definition for symbol *ocean-mid-indices-village1*, type ocean-mid-indices +(define *ocean-mid-indices-village1* (new 'static 'ocean-mid-indices :data (new 'static 'array uint16 36 + #x138 + #xffff + #x139 + #x13a + #x0 + #x0 + #x13b + #x13c + #x13d + #x13e + #x0 + #x0 + #x0 + #x0 + #x13f + #x140 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + ) + ) + ) + +;; definition for symbol *ocean-mid-masks-village1*, type ocean-mid-masks +(define + *ocean-mid-masks-village1* + (new 'static 'ocean-mid-masks + :data + (new 'static 'inline-array ocean-mid-mask 322 + (new 'static 'ocean-mid-mask) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #xf8 #xfc #xfe #xfe #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xc0 #xc0 #xc0 #x80 #x80 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfc #xfc #xfc #xfc #xfc #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x3f #x1f #xf #x7 #x3 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xfe #xfe #xfc #xf8 #xf8 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x1 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xf0 #xf8 #xf8 #xf8 #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x1f #x7 #x3 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfe #xfc #xf8 #xf8 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xf8 #xf0 #xe0 #xc0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #xf #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xfe #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x3f #xf #x3 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfe #x7c #x38 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xf0 #xf8 #xfc #xfc #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xe0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfe #xf0 #xe0 #xc0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7f #x3f #x3f #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x80 #x80 #x80 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfe #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfc #xf8 #xf0 #xe0 #xc0 #xc0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x3f #x3f #x3f #x3c)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x80 #xc0 #xe0 #xc0 #xc0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #xf #x1f #x1f #x1f #x1f #x1f #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #x80 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfe #xfc #xfe #xfc #xf8 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7f #x3f #x3f #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x0 #x0 #x0 #x0 #x0 #x0 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x38 #x0 #x0 #x0 #x0 #x0 #x1 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x80 #x80 #xc0 #xc0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xfc #xf0 #xe0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xf #x7 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x80 #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xf0 #xf8 #xfc #xfe #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x6 #x6 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #xc0 #xc0 #xe0 #xf0 #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x80 #x80 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfe #xfe #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x1f #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xe0 #xe0 #xe0 #xe0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x7f #x3f #x1f #x1f #x1f #x7 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x0 #x0 #x0 #x0 #xe0 #xf8 #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #xf #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #x0 #x0 #x0 #x0 #x0 #x3f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfe #xfc #xf0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #x7f #x7f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x1 #x80 #xc0 #xc0 #xe0 #xe0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xe0 #xe0 #xc0 #x80 #x80 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xf #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x1f #x1f #x1f #x1f #x1f #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xf8 #xf0 #xf0 #xf0 #xf0 #xf0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x1f #xf #xf #x7 #x80 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf8 #xfc #xfc #xfe #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #x1 #x3 #x7 #xf #x1f #x3f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xf0 #xe0 #xe0 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x7f #x3f #x1f #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xe0 #xc0 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #x7 #x7 #x7 #x7 #x7 #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #xf0 #xfc #xfe #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3e #x0 #x0 #x0 #x0 #x3 #x7 #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xf0 #xfc #xfe #xfe #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x7 #x1f #x3f #x7f #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfc #xc0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xfe #xfc #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #xc7 #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x3f #x3f #x3f #x3f #x3f #x3f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xf8 #xf0 #xe0 #xe0 #xe0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xfe #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #xf #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xe0 #xe0 #xe0 #xe0 #xf8 #xf8 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x7 #x87 #x87 #x87 #x87)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfe #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #xc0 #x80 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x87 #x7 #x7 #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfe #xfe #xfe #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x3 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x80 #x80 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x8c)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #xc0 #xf0 #xfc #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfe #xfe #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x7f #x1f #x7 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #x7 #x7 #x1 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfc #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xf0 #xe0 #xc0 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfe #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xf0 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xf #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfe #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xf #x7 #x1 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xe0 #xe0 #xe0 #xe0 #xe0 #xe0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x7f #x3f #x3f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7f #x18 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xc0 #xc0 #xc0 #xc0 #xc0 #xc0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x3f #x3f #x3f #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #xc0 #xe0 #xe0 #xe0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x1 #x3 #x3 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x1f #xf #xf #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #x7 #x3 #x1 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x18 #x3c #x18 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf8 #xfc #xfc #xfc #xfc #xfc #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x3 #x3 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xe0 #xe0 #xe0 #x70 #x38 #x18 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xfc #xf8 #xf0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x3c)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x7f #x3f #x3f #x3f #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x38 #x30 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #xf8 #xf0 #xf0 #xe0 #xc0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x3f #x3f #x3f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x80 #xe0 #xf8 #xfc #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x1 #x3 #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #xf #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #xc #xc #xe #xe #xc #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #xc0 #xc0 #xe0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x3 #x3 #x1 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #x7f #x7f #x7f #x7f #x7f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfe #xfe #xfe #xfc #xfc #xfc #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xe0 #xc0 #xc0 #xc0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x3f #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xc0 #xc0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1f #x1f #x1f #x3f #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #xc0 #xc0 #xc0 #x80 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xf0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x3f #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #xf #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xfe #xfe #x7e #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #xf #x7 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x80 #xc0 #xc0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x7 #xf #xf #x7 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xfc #xfc #xf8 #xf0 #xf0 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x3f #x3f #x3f #x7f #x3f #xf #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x4 #xe #x4 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #xc0 #xf0 #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #x80 #x80 #x87 #x8f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x3f #x3f #x7f #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x7 #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xe0 #xe0 #xc0 #xc0 #x80 #xc #x1e)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x7 #x7 #x7 #x7 #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #x80 #x80 #x80 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x7 #xf #x1f #x1f #xf #x7 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x80 #xc0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x38 #x3c #x7e #x7f #x7f #x7f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x10 #x38 #x10 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1e #x7e #x7c #x78 #x70 #x30 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xf8 #xf0 #xf0 #xf8 #xfc #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x7f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1 #x1 #x1 #x1 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #xe0 #xf0 #xf8 #xfc #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x38 #x7c #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x80 #xc0 #xe3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x7 #x7 #x8f #xcf #xcf #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x1f #x1f #x1f #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x20)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xf0 #xe0 #xe0 #xc0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #xff #xff #xff #x1 #x1 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #xe0 #xf0 #xf0 #xf0 #xf8 #xfc #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1 #x1 #x3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #xf8 #xf8 #xf1 #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x7f #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x7f #x7f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x80 #xc0 #xe0 #xf0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #xf #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x18 #x3c #x7f #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfc #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x3e)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x70 #xf8 #xf8 #xf0 #xc0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #xc0 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #x80 #x0 #x3 #x7 #x7 #xe #xe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xf0 #xf0 #xf0 #xf8 #xfc)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xf #x7 #x3 #x7 #xf #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xe0 #xc0 #xc0 #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x1 #x1 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xe0 #xe0 #xe0 #xe0 #xe0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x1 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x7 #x1f #x3f #x7f #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x8 #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x80 #x80 #xc3 #xe3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #x3f #x3f #x3f #x3f #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xf0 #xf0 #xe0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x3 #x1f #x3f #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xc1 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x3f #x3c)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfc #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x78 #xfc #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x80 #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x3f #x3f #x3f #x3f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x3f #x7 #x7 #x3 #x3 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x80 #xc0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x80 #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x1f #x1f #x1f #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x1 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xe0 #xe0 #xc0 #xc0 #x80 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x80 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xe0 #xf0 #xf0 #xf0 #xf8 #xfc #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x3f #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #xf #xf #xf #xf #x7 #x7 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfc #xf8 #xf0 #xe0 #xc0 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x7 #x7 #x7 #x7 #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x7f #x1f #xf #x7 #x3 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x7 #x7 #x3 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfc #xfc #xfc #xfe #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x3 #x3 #x3 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #xc0 #xc0 #xe0 #xe0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #x3f #x1f #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xc0 #x80 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x7f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xc0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #x7f #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x3 #x1 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x7 #xf #x3f #x7f #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7e #x30 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #x80 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #x3f #x3f #x1e #xc #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #x80 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x3 #x1 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #x80 #x80 #x80 #xc0 #xc0 #xc0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x7 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x1f #x1f #x1f #x1f #x1f #x1e)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xf0 #xe0 #xc0 #xc0 #xc0 #xc0 #x80)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x3 #x7 #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #xc0 #xf0 #xfc #xfe #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x6 #x7 #xf #x1f #x3f #x7f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfc #xfc #xf8 #xf0 #xe0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x3 #x7 #xf #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfe #xfc #xf8 #xf0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #x1f #x3f #x7f #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #xe1 #xf3 #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x80 #xc0 #xc0 #xe0 #xe0 #xe0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7f #x3f #x3f #x1f #xf #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #xfe #xfe #xfc #xc0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x1 #x1 #x1 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfe #xfc #xf8 #xf0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1 #x1 #x1 #x7 #x7 #x7 #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf0 #xe0 #xe0 #x80 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x7f #x3f #x7 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x1 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xe0 #x80 #x80 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xf8 #xe0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x3f #xf #x3 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x1c #x7e)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xe0 #xe0 #xe0 #xe0 #x40 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x7 #x7 #x7 #x3 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7e #xff #xff #xff #xff #x7e #x1c #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xf8 #xf8 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xf8 #xf8 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xf3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xfe #xfc #xf8 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf3 #xf1 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xfc #xfe #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xf3 #xf1 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfe #xf8 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xf0 #xf0 #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xfc #xfe #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xf1 #xf3 #xf3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf9 #xf9 #xf1 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf7 #xff #xff #xfc #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfc #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xf1 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf7 #xf1 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf8 #xf8 #xf8 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf3 #xf3 #xf3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xfc #xfc #xfc #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xff #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xfe #xf8 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xf7 #xf7 #xf6 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xfc #xfc #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xff #xff #xfe #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf6 #xf4 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf7 #xf6 #xfc #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf3 #xf1 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf1 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #xff #xff #x8f #x7 #x7 #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x4 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #xc0 #xc0 #x80 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #x1f #x3 #x1 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x79 #x78 #xf8 #xf8 #xf8)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x18 #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #x90 #x80 #x80 #x80 #x80 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x1f #x1f #x7 #x3 #x1 #x0)) + (new 'static 'ocean-mid-mask) + ) + ) + ) + +;; definition for symbol *ocean-spheres-village2*, type ocean-spheres +(define + *ocean-spheres-village2* + (new 'static 'ocean-spheres :spheres (new 'static 'inline-array sphere 36 + (new 'static 'sphere :x -6320128.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z -14385152.0 :w 2224365.5) + (new 'static 'sphere :x -6320128.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z -11239424.0 :w 2224365.5) + (new 'static 'sphere :x -6320128.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z -8093696.0 :w 2224365.5) + (new 'static 'sphere :x -6320128.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z -4947968.0 :w 2224365.5) + (new 'static 'sphere :x -6320128.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z -1802240.0 :w 2224365.5) + (new 'static 'sphere :x -6320128.0 :z 1343488.0 :w 2224365.5) + (new 'static 'sphere :x -3174400.0 :z 1343488.0 :w 2224365.5) + (new 'static 'sphere :x -28672.0 :z 1343488.0 :w 2224365.5) + (new 'static 'sphere :x 3117056.0 :z 1343488.0 :w 2224365.5) + (new 'static 'sphere :x 6262784.0 :z 1343488.0 :w 2224365.5) + (new 'static 'sphere :x 9408512.0 :z 1343488.0 :w 2224365.5) + ) + ) + ) + +;; definition for symbol *ocean-colors-village2*, type ocean-colors +(define + *ocean-colors-village2* + (new 'static 'ocean-colors :colors (new 'static 'array rgba 2548 + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x50 :a #x80) + (new 'static 'rgba :r #x23 :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x23 :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x3e :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x23 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x45 :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x43 :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x22 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x42 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x43 :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x43 :b #x4b :a #x80) + (new 'static 'rgba :r #x1e :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x1d :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x44 :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x4e :b #x4f :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x51 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x22 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x53 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x50 :b #x52 :a #x80) + (new 'static 'rgba :r #x1f :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x1f :g #x4f :b #x51 :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x1f :g #x50 :b #x52 :a #x80) + (new 'static 'rgba :r #x1f :g #x4e :b #x50 :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x44 :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x23 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x31 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x48 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x1d :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x50 :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x1f :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x25 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x26 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x53 :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x23 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x50 :a #x80) + (new 'static 'rgba :r #x1c :g #x4f :b #x4f :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x44 :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x40 :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x3b :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1d :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x3d :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x1e :g #x41 :b #x48 :a #x80) + (new 'static 'rgba :r #x1b :g #x43 :b #x48 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x48 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x47 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x47 :a #x80) + (new 'static 'rgba :r #x16 :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x15 :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x17 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x1b :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x1f :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x52 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x53 :a #x80) + (new 'static 'rgba :r #x28 :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x28 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x29 :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x29 :g #x55 :b #x53 :a #x80) + (new 'static 'rgba :r #x28 :g #x55 :b #x50 :a #x80) + (new 'static 'rgba :r #x28 :g #x55 :b #x50 :a #x80) + (new 'static 'rgba :r #x28 :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x25 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x23 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x22 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x4f :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x4e :a #x80) + (new 'static 'rgba :r #x22 :g #x44 :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x3f :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x53 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x3b :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #x1d :g #x41 :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x43 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x47 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x47 :a #x80) + (new 'static 'rgba :r #x14 :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x45 :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x14 :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x15 :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1a :g #x4c :b #x47 :a #x80) + (new 'static 'rgba :r #x1c :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x1e :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x54 :b #x53 :a #x80) + (new 'static 'rgba :r #x2b :g #x56 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x27 :g #x53 :b #x4e :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x52 :a #x80) + (new 'static 'rgba :r #x26 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x53 :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x52 :b #x4d :a #x80) + (new 'static 'rgba :r #x1c :g #x4f :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x23 :g #x46 :b #x4e :a #x80) + (new 'static 'rgba :r #x23 :g #x3e :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x37 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x3e :b #x46 :a #x80) + (new 'static 'rgba :r #x1d :g #x44 :b #x49 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x13 :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x11 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x10 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #xe :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x43 :b #x40 :a #x80) + (new 'static 'rgba :r #x1a :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x14 :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x16 :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x17 :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x19 :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x29 :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x31 :g #x59 :b #x54 :a #x80) + (new 'static 'rgba :r #x2f :g #x58 :b #x55 :a #x80) + (new 'static 'rgba :r #x29 :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x53 :b #x52 :a #x80) + (new 'static 'rgba :r #x27 :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x51 :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4d :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x43 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x46 :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x18 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x16 :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x15 :g #x49 :b #x45 :a #x80) + (new 'static 'rgba :r #x14 :g #x49 :b #x45 :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x10 :g #x43 :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x45 :b #x41 :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x14 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x16 :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x2e :g #x56 :b #x54 :a #x80) + (new 'static 'rgba :r #x2e :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x53 :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x48 :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x1c :g #x4f :b #x4a :a #x80) + (new 'static 'rgba :r #x1a :g #x4f :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x4c :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x3c :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x4c :a #x80) + (new 'static 'rgba :r #x1c :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x19 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x18 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x4c :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x15 :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x12 :g #x45 :b #x41 :a #x80) + (new 'static 'rgba :r #x11 :g #x44 :b #x3f :a #x80) + (new 'static 'rgba :r #x12 :g #x44 :b #x41 :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x41 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x42 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x15 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x52 :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x1e :g #x4e :b #x49 :a #x80) + (new 'static 'rgba :r #x1a :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x1a :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x19 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x1a :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x41 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x46 :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x1b :g #x4e :b #x49 :a #x80) + (new 'static 'rgba :r #x18 :g #x4e :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x4a :b #x4c :a #x80) + (new 'static 'rgba :r #x1f :g #x41 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x39 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x40 :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x4c :a #x80) + (new 'static 'rgba :r #x1d :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x47 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x1a :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x19 :g #x42 :b #x43 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x1b :g #x43 :b #x46 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x48 :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1c :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x1d :g #x45 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x31 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x3a :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x3e :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x18 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x17 :g #x42 :b #x3f :a #x80) + (new 'static 'rgba :r #x16 :g #x41 :b #x42 :a #x80) + (new 'static 'rgba :r #x14 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x42 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x42 :a #x80) + (new 'static 'rgba :r #x14 :g #x43 :b #x41 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x41 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x1c :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x19 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1c :g #x48 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x41 :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x50 :a #x80) + (new 'static 'rgba :r #x25 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x40 :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x41 :a #x80) + (new 'static 'rgba :r #x14 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x3f :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x3c :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3a :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3d :a #x80) + (new 'static 'rgba :r #xb :g #x3f :b #x3c :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x40 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1d :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x4d :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x1a :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x43 :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x4e :a #x80) + (new 'static 'rgba :r #x25 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x52 :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x27 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x14 :g #x42 :b #x3f :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xa :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x3c :b #x3a :a #x80) + (new 'static 'rgba :r #x7 :g #x3c :b #x38 :a #x80) + (new 'static 'rgba :r #x8 :g #x3d :b #x3b :a #x80) + (new 'static 'rgba :r #x9 :g #x3c :b #x3b :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3d :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x3c :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x1b :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x1e :g #x4b :b #x47 :a #x80) + (new 'static 'rgba :r #x1c :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x1a :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x3d :b #x47 :a #x80) + (new 'static 'rgba :r #x23 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4b :b #x50 :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x52 :a #x80) + (new 'static 'rgba :r #x2a :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x2a :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x3e :b #x3b :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x7 :g #x3b :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x39 :b #x39 :a #x80) + (new 'static 'rgba :r #x5 :g #x38 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x39 :a #x80) + (new 'static 'rgba :r #x6 :g #x37 :b #x38 :a #x80) + (new 'static 'rgba :r #x5 :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x3b :b #x36 :a #x80) + (new 'static 'rgba :r #x9 :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #x1a :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1d :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x1a :g #x4e :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x24 :g #x4a :b #x4e :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x2c :g #x56 :b #x54 :a #x80) + (new 'static 'rgba :r #x2f :g #x57 :b #x57 :a #x80) + (new 'static 'rgba :r #x2e :g #x56 :b #x52 :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x4f :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x4d :a #x80) + (new 'static 'rgba :r #x2c :g #x53 :b #x4e :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x4d :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x4f :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x41 :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x16 :g #x43 :b #x40 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x3b :a #x80) + (new 'static 'rgba :r #xb :g #x3f :b #x3d :a #x80) + (new 'static 'rgba :r #x9 :g #x3d :b #x3a :a #x80) + (new 'static 'rgba :r #x7 :g #x3b :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x39 :b #x38 :a #x80) + (new 'static 'rgba :r #x6 :g #x34 :b #x36 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x36 :a #x80) + (new 'static 'rgba :r #x5 :g #x32 :b #x36 :a #x80) + (new 'static 'rgba :r #x5 :g #x37 :b #x38 :a #x80) + (new 'static 'rgba :r #x6 :g #x3a :b #x3a :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x4f :b #x4e :a #x80) + (new 'static 'rgba :r #x1d :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x21 :g #x41 :b #x49 :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x50 :a #x80) + (new 'static 'rgba :r #x2c :g #x55 :b #x55 :a #x80) + (new 'static 'rgba :r #x31 :g #x5a :b #x58 :a #x80) + (new 'static 'rgba :r #x31 :g #x5a :b #x57 :a #x80) + (new 'static 'rgba :r #x30 :g #x58 :b #x51 :a #x80) + (new 'static 'rgba :r #x2d :g #x54 :b #x4a :a #x80) + (new 'static 'rgba :r #x29 :g #x4f :b #x47 :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x47 :a #x80) + (new 'static 'rgba :r #x2a :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x2c :g #x52 :b #x4d :a #x80) + (new 'static 'rgba :r #x2a :g #x52 :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4b :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4b :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x16 :g #x44 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3b :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x3b :a #x80) + (new 'static 'rgba :r #x7 :g #x3c :b #x39 :a #x80) + (new 'static 'rgba :r #x6 :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x31 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x2e :b #x34 :a #x80) + (new 'static 'rgba :r #x6 :g #x2e :b #x34 :a #x80) + (new 'static 'rgba :r #x6 :g #x30 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x36 :a #x80) + (new 'static 'rgba :r #x6 :g #x39 :b #x36 :a #x80) + (new 'static 'rgba :r #x9 :g #x3d :b #x3b :a #x80) + (new 'static 'rgba :r #x11 :g #x40 :b #x3d :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4a :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x25 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x1f :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x50 :a #x80) + (new 'static 'rgba :r #x1e :g #x4c :b #x4e :a #x80) + (new 'static 'rgba :r #x22 :g #x43 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x41 :b #x49 :a #x80) + (new 'static 'rgba :r #x28 :g #x4b :b #x51 :a #x80) + (new 'static 'rgba :r #x2e :g #x56 :b #x58 :a #x80) + (new 'static 'rgba :r #x33 :g #x5a :b #x59 :a #x80) + (new 'static 'rgba :r #x33 :g #x59 :b #x53 :a #x80) + (new 'static 'rgba :r #x2f :g #x56 :b #x4a :a #x80) + (new 'static 'rgba :r #x29 :g #x4d :b #x3e :a #x80) + (new 'static 'rgba :r #x25 :g #x49 :b #x3a :a #x80) + (new 'static 'rgba :r #x24 :g #x49 :b #x3c :a #x80) + (new 'static 'rgba :r #x26 :g #x4b :b #x3f :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x3e :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x3e :a #x80) + (new 'static 'rgba :r #x24 :g #x4a :b #x42 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x46 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x16 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x17 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x3d :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x3b :a #x80) + (new 'static 'rgba :r #x7 :g #x3a :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x39 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x36 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x2f :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x2b :b #x32 :a #x80) + (new 'static 'rgba :r #x7 :g #x2c :b #x34 :a #x80) + (new 'static 'rgba :r #x6 :g #x2f :b #x34 :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x37 :a #x80) + (new 'static 'rgba :r #x8 :g #x3b :b #x3a :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3f :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x2a :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x52 :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x50 :a #x80) + (new 'static 'rgba :r #x1e :g #x50 :b #x50 :a #x80) + (new 'static 'rgba :r #x1f :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x22 :g #x3d :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x48 :a #x80) + (new 'static 'rgba :r #x27 :g #x4b :b #x52 :a #x80) + (new 'static 'rgba :r #x2f :g #x57 :b #x57 :a #x80) + (new 'static 'rgba :r #x32 :g #x5a :b #x55 :a #x80) + (new 'static 'rgba :r #x30 :g #x53 :b #x4a :a #x80) + (new 'static 'rgba :r #x2a :g #x4f :b #x3d :a #x80) + (new 'static 'rgba :r #x24 :g #x49 :b #x38 :a #x80) + (new 'static 'rgba :r #x21 :g #x45 :b #x31 :a #x80) + (new 'static 'rgba :r #x21 :g #x44 :b #x31 :a #x80) + (new 'static 'rgba :r #x1e :g #x43 :b #x31 :a #x80) + (new 'static 'rgba :r #x1d :g #x41 :b #x30 :a #x80) + (new 'static 'rgba :r #x1c :g #x42 :b #x30 :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x36 :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x45 :b #x47 :a #x80) + (new 'static 'rgba :r #x27 :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x11 :g #x42 :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3d :a #x80) + (new 'static 'rgba :r #xa :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #x7 :g #x3b :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x38 :b #x39 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x36 :a #x80) + (new 'static 'rgba :r #x7 :g #x31 :b #x36 :a #x80) + (new 'static 'rgba :r #x6 :g #x2e :b #x33 :a #x80) + (new 'static 'rgba :r #x1 :g #x16 :b #x23 :a #x80) + (new 'static 'rgba :r #x7 :g #x2e :b #x33 :a #x80) + (new 'static 'rgba :r #x7 :g #x34 :b #x37 :a #x80) + (new 'static 'rgba :r #x4 :g #x32 :b #x36 :a #x80) + (new 'static 'rgba :r #x9 :g #x3b :b #x38 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x3f :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x2c :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x2a :g #x52 :b #x53 :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x29 :g #x53 :b #x52 :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x4f :b #x50 :a #x80) + (new 'static 'rgba :r #x20 :g #x46 :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x25 :g #x4b :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x52 :a #x80) + (new 'static 'rgba :r #x30 :g #x57 :b #x57 :a #x80) + (new 'static 'rgba :r #x30 :g #x55 :b #x48 :a #x80) + (new 'static 'rgba :r #x2b :g #x4e :b #x3b :a #x80) + (new 'static 'rgba :r #x25 :g #x47 :b #x35 :a #x80) + (new 'static 'rgba :r #x21 :g #x44 :b #x2c :a #x80) + (new 'static 'rgba :r #x1e :g #x3f :b #x2b :a #x80) + (new 'static 'rgba :r #x1d :g #x40 :b #x29 :a #x80) + (new 'static 'rgba :r #x1b :g #x3f :b #x2b :a #x80) + (new 'static 'rgba :r #x1c :g #x3e :b #x29 :a #x80) + (new 'static 'rgba :r #x1b :g #x3e :b #x2b :a #x80) + (new 'static 'rgba :r #x1e :g #x41 :b #x30 :a #x80) + (new 'static 'rgba :r #x27 :g #x4c :b #x45 :a #x80) + (new 'static 'rgba :r #x2b :g #x54 :b #x4f :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x45 :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #xa :g #x3d :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x3b :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x3a :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x35 :b #x38 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x35 :a #x80) + (new 'static 'rgba :r #x5 :g #x28 :b #x31 :a #x80) + (new 'static 'rgba :r #x6 :g #x2c :b #x33 :a #x80) + (new 'static 'rgba :r #x6 :g #x30 :b #x34 :a #x80) + (new 'static 'rgba :r #x5 :g #x35 :b #x38 :a #x80) + (new 'static 'rgba :r #x9 :g #x3d :b #x3b :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x41 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x31 :g #x57 :b #x57 :a #x80) + (new 'static 'rgba :r #x2b :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x2e :g #x57 :b #x55 :a #x80) + (new 'static 'rgba :r #x2b :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x21 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x1f :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x53 :a #x80) + (new 'static 'rgba :r #x30 :g #x57 :b #x53 :a #x80) + (new 'static 'rgba :r #x2e :g #x52 :b #x43 :a #x80) + (new 'static 'rgba :r #x27 :g #x49 :b #x37 :a #x80) + (new 'static 'rgba :r #x23 :g #x43 :b #x2d :a #x80) + (new 'static 'rgba :r #x1e :g #x40 :b #x2a :a #x80) + (new 'static 'rgba :r #x1d :g #x3e :b #x27 :a #x80) + (new 'static 'rgba :r #x1b :g #x3d :b #x24 :a #x80) + (new 'static 'rgba :r #x1a :g #x3d :b #x27 :a #x80) + (new 'static 'rgba :r #x18 :g #x3b :b #x23 :a #x80) + (new 'static 'rgba :r #x19 :g #x3d :b #x23 :a #x80) + (new 'static 'rgba :r #x1d :g #x40 :b #x2c :a #x80) + (new 'static 'rgba :r #x22 :g #x49 :b #x3f :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x4b :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x9 :g #x3d :b #x3b :a #x80) + (new 'static 'rgba :r #x6 :g #x3a :b #x38 :a #x80) + (new 'static 'rgba :r #x6 :g #x38 :b #x38 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x32 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x2f :b #x34 :a #x80) + (new 'static 'rgba :r #x7 :g #x30 :b #x36 :a #x80) + (new 'static 'rgba :r #x7 :g #x33 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x38 :b #x37 :a #x80) + (new 'static 'rgba :r #x9 :g #x3d :b #x39 :a #x80) + (new 'static 'rgba :r #x16 :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x2c :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x35 :g #x5a :b #x59 :a #x80) + (new 'static 'rgba :r #x2f :g #x57 :b #x55 :a #x80) + (new 'static 'rgba :r #x31 :g #x59 :b #x57 :a #x80) + (new 'static 'rgba :r #x2d :g #x56 :b #x56 :a #x80) + (new 'static 'rgba :r #x27 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x21 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x55 :a #x80) + (new 'static 'rgba :r #x2f :g #x55 :b #x4e :a #x80) + (new 'static 'rgba :r #x29 :g #x4c :b #x3c :a #x80) + (new 'static 'rgba :r #x24 :g #x45 :b #x30 :a #x80) + (new 'static 'rgba :r #x21 :g #x41 :b #x29 :a #x80) + (new 'static 'rgba :r #x1d :g #x3e :b #x26 :a #x80) + (new 'static 'rgba :r #x1b :g #x3d :b #x24 :a #x80) + (new 'static 'rgba :r #x19 :g #x3c :b #x21 :a #x80) + (new 'static 'rgba :r #x1a :g #x3c :b #x25 :a #x80) + (new 'static 'rgba :r #x1b :g #x3e :b #x26 :a #x80) + (new 'static 'rgba :r #x1c :g #x3f :b #x2a :a #x80) + (new 'static 'rgba :r #x1f :g #x42 :b #x30 :a #x80) + (new 'static 'rgba :r #x21 :g #x46 :b #x39 :a #x80) + (new 'static 'rgba :r #x27 :g #x4c :b #x45 :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4b :a #x80) + (new 'static 'rgba :r #x26 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x3e :a #x80) + (new 'static 'rgba :r #xd :g #x3e :b #x3e :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x42 :a #x80) + (new 'static 'rgba :r #x8 :g #x3d :b #x38 :a #x80) + (new 'static 'rgba :r #x7 :g #x3a :b #x38 :a #x80) + (new 'static 'rgba :r #x6 :g #x38 :b #x36 :a #x80) + (new 'static 'rgba :r #x6 :g #x36 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x35 :a #x80) + (new 'static 'rgba :r #x6 :g #x33 :b #x35 :a #x80) + (new 'static 'rgba :r #x7 :g #x37 :b #x37 :a #x80) + (new 'static 'rgba :r #x5 :g #x39 :b #x36 :a #x80) + (new 'static 'rgba :r #xa :g #x3d :b #x3c :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x41 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x34 :g #x58 :b #x57 :a #x80) + (new 'static 'rgba :r #x34 :g #x59 :b #x56 :a #x80) + (new 'static 'rgba :r #x2e :g #x56 :b #x54 :a #x80) + (new 'static 'rgba :r #x2c :g #x56 :b #x54 :a #x80) + (new 'static 'rgba :r #x28 :g #x55 :b #x55 :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x1f :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x29 :g #x4c :b #x52 :a #x80) + (new 'static 'rgba :r #x30 :g #x57 :b #x50 :a #x80) + (new 'static 'rgba :r #x27 :g #x4a :b #x39 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x2f :a #x80) + (new 'static 'rgba :r #x1f :g #x41 :b #x28 :a #x80) + (new 'static 'rgba :r #x1c :g #x3f :b #x29 :a #x80) + (new 'static 'rgba :r #x1d :g #x3f :b #x26 :a #x80) + (new 'static 'rgba :r #x1d :g #x40 :b #x27 :a #x80) + (new 'static 'rgba :r #x1d :g #x40 :b #x29 :a #x80) + (new 'static 'rgba :r #x1f :g #x43 :b #x31 :a #x80) + (new 'static 'rgba :r #x23 :g #x48 :b #x36 :a #x80) + (new 'static 'rgba :r #x23 :g #x48 :b #x3c :a #x80) + (new 'static 'rgba :r #x23 :g #x49 :b #x3d :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x40 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x48 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x19 :g #x42 :b #x44 :a #x80) + (new 'static 'rgba :r #x14 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #xf :g #x3f :b #x3e :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xa :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x3c :b #x3a :a #x80) + (new 'static 'rgba :r #x6 :g #x3a :b #x39 :a #x80) + (new 'static 'rgba :r #x6 :g #x38 :b #x38 :a #x80) + (new 'static 'rgba :r #x5 :g #x34 :b #x37 :a #x80) + (new 'static 'rgba :r #x5 :g #x37 :b #x37 :a #x80) + (new 'static 'rgba :r #x6 :g #x39 :b #x37 :a #x80) + (new 'static 'rgba :r #x7 :g #x3c :b #x3a :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3c :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x2a :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x2e :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x2e :g #x55 :b #x54 :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x2a :g #x55 :b #x55 :a #x80) + (new 'static 'rgba :r #x25 :g #x53 :b #x53 :a #x80) + (new 'static 'rgba :r #x21 :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x1f :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x47 :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x27 :g #x49 :b #x4e :a #x80) + (new 'static 'rgba :r #x2e :g #x55 :b #x50 :a #x80) + (new 'static 'rgba :r #x26 :g #x4a :b #x3b :a #x80) + (new 'static 'rgba :r #x22 :g #x47 :b #x32 :a #x80) + (new 'static 'rgba :r #x20 :g #x43 :b #x2c :a #x80) + (new 'static 'rgba :r #x1f :g #x42 :b #x2c :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x2d :a #x80) + (new 'static 'rgba :r #x20 :g #x44 :b #x30 :a #x80) + (new 'static 'rgba :r #x22 :g #x46 :b #x34 :a #x80) + (new 'static 'rgba :r #x26 :g #x49 :b #x3d :a #x80) + (new 'static 'rgba :r #x29 :g #x4f :b #x45 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x45 :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x46 :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x45 :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x49 :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x17 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x41 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3c :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x3f :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x3d :b #x38 :a #x80) + (new 'static 'rgba :r #x7 :g #x3b :b #x39 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #x6 :g #x3a :b #x3a :a #x80) + (new 'static 'rgba :r #x8 :g #x3c :b #x39 :a #x80) + (new 'static 'rgba :r #xb :g #x3d :b #x3d :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x3c :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x43 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x29 :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x29 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x27 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x53 :a #x80) + (new 'static 'rgba :r #x1f :g #x53 :b #x4e :a #x80) + (new 'static 'rgba :r #x1f :g #x4e :b #x51 :a #x80) + (new 'static 'rgba :r #x22 :g #x46 :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #x25 :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x2d :g #x53 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x4d :b #x40 :a #x80) + (new 'static 'rgba :r #x26 :g #x4a :b #x39 :a #x80) + (new 'static 'rgba :r #x25 :g #x48 :b #x37 :a #x80) + (new 'static 'rgba :r #x24 :g #x47 :b #x35 :a #x80) + (new 'static 'rgba :r #x24 :g #x47 :b #x35 :a #x80) + (new 'static 'rgba :r #x26 :g #x49 :b #x3b :a #x80) + (new 'static 'rgba :r #x27 :g #x4c :b #x3d :a #x80) + (new 'static 'rgba :r #x29 :g #x4e :b #x46 :a #x80) + (new 'static 'rgba :r #x2c :g #x52 :b #x4b :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x4c :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x4b :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x2a :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x48 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #x12 :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #xf :g #x40 :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3a :a #x80) + (new 'static 'rgba :r #xc :g #x3f :b #x3a :a #x80) + (new 'static 'rgba :r #xb :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xc :g #x3e :b #x3c :a #x80) + (new 'static 'rgba :r #xd :g #x3f :b #x3c :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x26 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x1f :g #x4f :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x44 :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x42 :a #x80) + (new 'static 'rgba :r #x24 :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x2d :g #x56 :b #x50 :a #x80) + (new 'static 'rgba :r #x2d :g #x53 :b #x47 :a #x80) + (new 'static 'rgba :r #x2a :g #x50 :b #x42 :a #x80) + (new 'static 'rgba :r #x28 :g #x4d :b #x40 :a #x80) + (new 'static 'rgba :r #x27 :g #x4c :b #x3d :a #x80) + (new 'static 'rgba :r #x28 :g #x4e :b #x3e :a #x80) + (new 'static 'rgba :r #x29 :g #x4e :b #x42 :a #x80) + (new 'static 'rgba :r #x2b :g #x50 :b #x47 :a #x80) + (new 'static 'rgba :r #x2a :g #x4f :b #x49 :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x4c :a #x80) + (new 'static 'rgba :r #x29 :g #x4f :b #x47 :a #x80) + (new 'static 'rgba :r #x2a :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4b :a #x80) + (new 'static 'rgba :r #x2c :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x2a :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4b :a #x80) + (new 'static 'rgba :r #x27 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x13 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x13 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x14 :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #x17 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4d :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x1f :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x1c :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x1c :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x23 :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x2f :g #x59 :b #x53 :a #x80) + (new 'static 'rgba :r #x32 :g #x5a :b #x52 :a #x80) + (new 'static 'rgba :r #x2f :g #x56 :b #x4e :a #x80) + (new 'static 'rgba :r #x2d :g #x52 :b #x4c :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x46 :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x48 :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x4c :a #x80) + (new 'static 'rgba :r #x27 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x28 :g #x4d :b #x44 :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x29 :g #x52 :b #x4e :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x2c :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x4d :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x2b :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x1b :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x45 :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x4e :a #x80) + (new 'static 'rgba :r #x1c :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x1a :g #x4e :b #x49 :a #x80) + (new 'static 'rgba :r #x1b :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x3d :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x24 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #x2e :g #x59 :b #x58 :a #x80) + (new 'static 'rgba :r #x33 :g #x5c :b #x59 :a #x80) + (new 'static 'rgba :r #x31 :g #x5a :b #x56 :a #x80) + (new 'static 'rgba :r #x30 :g #x58 :b #x53 :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x4e :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x48 :a #x80) + (new 'static 'rgba :r #x27 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x28 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x27 :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x46 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x45 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x1a :g #x4b :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x18 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1b :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x23 :g #x44 :b #x4a :a #x80) + (new 'static 'rgba :r #x2d :g #x55 :b #x57 :a #x80) + (new 'static 'rgba :r #x32 :g #x5b :b #x5a :a #x80) + (new 'static 'rgba :r #x32 :g #x5b :b #x55 :a #x80) + (new 'static 'rgba :r #x30 :g #x57 :b #x55 :a #x80) + (new 'static 'rgba :r #x2d :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x50 :a #x80) + (new 'static 'rgba :r #x29 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x4c :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x4c :b #x47 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x27 :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x1c :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x26 :g #x4f :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x19 :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x16 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x17 :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x1c :g #x45 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x40 :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x54 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x22 :g #x45 :b #x4b :a #x80) + (new 'static 'rgba :r #x2e :g #x56 :b #x54 :a #x80) + (new 'static 'rgba :r #x34 :g #x5d :b #x5a :a #x80) + (new 'static 'rgba :r #x32 :g #x5a :b #x55 :a #x80) + (new 'static 'rgba :r #x2f :g #x56 :b #x52 :a #x80) + (new 'static 'rgba :r #x2b :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x49 :a #x80) + (new 'static 'rgba :r #x1b :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x1b :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x24 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4e :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x44 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x14 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x49 :b #x4b :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x3f :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x22 :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x26 :g #x4a :b #x4f :a #x80) + (new 'static 'rgba :r #x30 :g #x59 :b #x58 :a #x80) + (new 'static 'rgba :r #x35 :g #x5c :b #x58 :a #x80) + (new 'static 'rgba :r #x31 :g #x59 :b #x56 :a #x80) + (new 'static 'rgba :r #x2f :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x32 :g #x56 :b #x52 :a #x80) + (new 'static 'rgba :r #x2b :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x40 :a #x80) + (new 'static 'rgba :r #x15 :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #x15 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x16 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x1a :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x1d :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x29 :g #x51 :b #x4e :a #x80) + (new 'static 'rgba :r #x27 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x26 :g #x4d :b #x4e :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x19 :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x14 :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x46 :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x43 :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x23 :g #x46 :b #x4a :a #x80) + (new 'static 'rgba :r #x2f :g #x56 :b #x58 :a #x80) + (new 'static 'rgba :r #x34 :g #x5d :b #x5b :a #x80) + (new 'static 'rgba :r #x33 :g #x5b :b #x56 :a #x80) + (new 'static 'rgba :r #x31 :g #x58 :b #x57 :a #x80) + (new 'static 'rgba :r #x31 :g #x57 :b #x53 :a #x80) + (new 'static 'rgba :r #x33 :g #x58 :b #x55 :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x45 :b #x44 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x41 :a #x80) + (new 'static 'rgba :r #x12 :g #x43 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #x12 :g #x42 :b #x3f :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x43 :a #x80) + (new 'static 'rgba :r #x19 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x13 :g #x42 :b #x3e :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x19 :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x1b :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x28 :g #x4e :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x48 :a #x80) + (new 'static 'rgba :r #x1e :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x47 :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x43 :a #x80) + (new 'static 'rgba :r #x15 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x43 :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x27 :g #x48 :b #x4e :a #x80) + (new 'static 'rgba :r #x38 :g #x60 :b #x5e :a #x80) + (new 'static 'rgba :r #x38 :g #x60 :b #x5c :a #x80) + (new 'static 'rgba :r #x36 :g #x5d :b #x5a :a #x80) + (new 'static 'rgba :r #x30 :g #x57 :b #x55 :a #x80) + (new 'static 'rgba :r #x32 :g #x58 :b #x54 :a #x80) + (new 'static 'rgba :r #x24 :g #x4e :b #x4b :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x3d :a #x80) + (new 'static 'rgba :r #xd :g #x40 :b #x3f :a #x80) + (new 'static 'rgba :r #xc :g #x41 :b #x3f :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x3f :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x3d :a #x80) + (new 'static 'rgba :r #x10 :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #x13 :g #x43 :b #x3f :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #x1a :g #x43 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x1b :g #x47 :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x49 :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x4a :b #x46 :a #x80) + (new 'static 'rgba :r #x18 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x49 :b #x4b :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x29 :g #x4a :b #x4f :a #x80) + (new 'static 'rgba :r #x38 :g #x61 :b #x5c :a #x80) + (new 'static 'rgba :r #x38 :g #x5f :b #x5a :a #x80) + (new 'static 'rgba :r #x35 :g #x5d :b #x5a :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x4e :a #x80) + (new 'static 'rgba :r #x2d :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x28 :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x12 :g #x44 :b #x42 :a #x80) + (new 'static 'rgba :r #xf :g #x42 :b #x42 :a #x80) + (new 'static 'rgba :r #xc :g #x41 :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x40 :b #x3e :a #x80) + (new 'static 'rgba :r #xe :g #x3f :b #x3f :a #x80) + (new 'static 'rgba :r #xd :g #x3c :b #x3e :a #x80) + (new 'static 'rgba :r #xc :g #x3e :b #x3d :a #x80) + (new 'static 'rgba :r #x1e :g #x4a :b #x45 :a #x80) + (new 'static 'rgba :r #xc :g #x3f :b #x40 :a #x80) + (new 'static 'rgba :r #xd :g #x41 :b #x3e :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #xe :g #x41 :b #x40 :a #x80) + (new 'static 'rgba :r #x11 :g #x41 :b #x42 :a #x80) + (new 'static 'rgba :r #x15 :g #x43 :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x43 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x1d :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x25 :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x4b :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x49 :a #x80) + (new 'static 'rgba :r #x1f :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x1e :g #x4f :b #x4b :a #x80) + (new 'static 'rgba :r #x1d :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x1c :g #x4c :b #x4e :a #x80) + (new 'static 'rgba :r #x1e :g #x46 :b #x4b :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x25 :g #x49 :b #x4e :a #x80) + (new 'static 'rgba :r #x2f :g #x5c :b #x5a :a #x80) + (new 'static 'rgba :r #x32 :g #x5b :b #x5a :a #x80) + (new 'static 'rgba :r #x33 :g #x5b :b #x5a :a #x80) + (new 'static 'rgba :r #x30 :g #x58 :b #x56 :a #x80) + (new 'static 'rgba :r #x29 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4c :a #x80) + (new 'static 'rgba :r #x1d :g #x49 :b #x49 :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x11 :g #x46 :b #x41 :a #x80) + (new 'static 'rgba :r #xe :g #x42 :b #x41 :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x40 :a #x80) + (new 'static 'rgba :r #x10 :g #x3d :b #x41 :a #x80) + (new 'static 'rgba :r #x11 :g #x38 :b #x3f :a #x80) + (new 'static 'rgba :r #x11 :g #x39 :b #x3e :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x3e :a #x80) + (new 'static 'rgba :r #x10 :g #x3c :b #x40 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x3f :a #x80) + (new 'static 'rgba :r #xe :g #x40 :b #x41 :a #x80) + (new 'static 'rgba :r #xe :g #x42 :b #x3f :a #x80) + (new 'static 'rgba :r #xf :g #x43 :b #x3f :a #x80) + (new 'static 'rgba :r #x11 :g #x44 :b #x3f :a #x80) + (new 'static 'rgba :r #x14 :g #x45 :b #x42 :a #x80) + (new 'static 'rgba :r #x16 :g #x45 :b #x43 :a #x80) + (new 'static 'rgba :r #x1b :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4a :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x48 :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x24 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x1f :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x23 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x24 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x25 :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x24 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x4d :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x22 :g #x46 :b #x4c :a #x80) + (new 'static 'rgba :r #x28 :g #x59 :b #x57 :a #x80) + (new 'static 'rgba :r #x29 :g #x58 :b #x54 :a #x80) + (new 'static 'rgba :r #x29 :g #x56 :b #x53 :a #x80) + (new 'static 'rgba :r #x27 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x1a :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x18 :g #x49 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x48 :b #x47 :a #x80) + (new 'static 'rgba :r #x12 :g #x46 :b #x42 :a #x80) + (new 'static 'rgba :r #x11 :g #x44 :b #x44 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x13 :g #x38 :b #x40 :a #x80) + (new 'static 'rgba :r #x16 :g #x37 :b #x40 :a #x80) + (new 'static 'rgba :r #x16 :g #x36 :b #x3f :a #x80) + (new 'static 'rgba :r #x16 :g #x34 :b #x3e :a #x80) + (new 'static 'rgba :r #x16 :g #x39 :b #x3f :a #x80) + (new 'static 'rgba :r #x14 :g #x3a :b #x40 :a #x80) + (new 'static 'rgba :r #x13 :g #x3d :b #x41 :a #x80) + (new 'static 'rgba :r #x11 :g #x3f :b #x42 :a #x80) + (new 'static 'rgba :r #xf :g #x41 :b #x41 :a #x80) + (new 'static 'rgba :r #x10 :g #x42 :b #x43 :a #x80) + (new 'static 'rgba :r #x10 :g #x45 :b #x40 :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x48 :a #x80) + (new 'static 'rgba :r #x15 :g #x47 :b #x43 :a #x80) + (new 'static 'rgba :r #x19 :g #x48 :b #x45 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4d :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x22 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x4e :b #x4e :a #x80) + (new 'static 'rgba :r #x27 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x2a :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x2a :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x29 :g #x54 :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x54 :b #x53 :a #x80) + (new 'static 'rgba :r #x1f :g #x4c :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x21 :g #x47 :b #x4b :a #x80) + (new 'static 'rgba :r #x25 :g #x55 :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x4b :a #x80) + (new 'static 'rgba :r #x19 :g #x4b :b #x49 :a #x80) + (new 'static 'rgba :r #x17 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x14 :g #x46 :b #x46 :a #x80) + (new 'static 'rgba :r #x14 :g #x46 :b #x43 :a #x80) + (new 'static 'rgba :r #x13 :g #x45 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x3f :b #x43 :a #x80) + (new 'static 'rgba :r #x17 :g #x3c :b #x41 :a #x80) + (new 'static 'rgba :r #x19 :g #x36 :b #x41 :a #x80) + (new 'static 'rgba :r #x19 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x18 :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x19 :g #x33 :b #x40 :a #x80) + (new 'static 'rgba :r #x19 :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1a :g #x3a :b #x43 :a #x80) + (new 'static 'rgba :r #x19 :g #x3a :b #x42 :a #x80) + (new 'static 'rgba :r #x16 :g #x3f :b #x43 :a #x80) + (new 'static 'rgba :r #x14 :g #x41 :b #x44 :a #x80) + (new 'static 'rgba :r #x12 :g #x41 :b #x45 :a #x80) + (new 'static 'rgba :r #x12 :g #x46 :b #x45 :a #x80) + (new 'static 'rgba :r #x14 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x47 :b #x47 :a #x80) + (new 'static 'rgba :r #x19 :g #x4a :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x4a :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x4c :b #x4d :a #x80) + (new 'static 'rgba :r #x24 :g #x4c :b #x4e :a #x80) + (new 'static 'rgba :r #x25 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x4e :b #x4c :a #x80) + (new 'static 'rgba :r #x1e :g #x49 :b #x4a :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x28 :g #x4f :b #x50 :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x26 :g #x4e :b #x4f :a #x80) + (new 'static 'rgba :r #x2c :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x2d :g #x57 :b #x55 :a #x80) + (new 'static 'rgba :r #x2d :g #x59 :b #x57 :a #x80) + (new 'static 'rgba :r #x2b :g #x57 :b #x54 :a #x80) + (new 'static 'rgba :r #x24 :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x4d :b #x50 :a #x80) + (new 'static 'rgba :r #x21 :g #x3e :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x3f :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x50 :a #x80) + (new 'static 'rgba :r #x20 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x1e :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x1b :g #x4f :b #x4a :a #x80) + (new 'static 'rgba :r #x18 :g #x4b :b #x48 :a #x80) + (new 'static 'rgba :r #x16 :g #x47 :b #x48 :a #x80) + (new 'static 'rgba :r #x14 :g #x44 :b #x45 :a #x80) + (new 'static 'rgba :r #x15 :g #x44 :b #x47 :a #x80) + (new 'static 'rgba :r #x17 :g #x41 :b #x45 :a #x80) + (new 'static 'rgba :r #x1a :g #x3b :b #x44 :a #x80) + (new 'static 'rgba :r #x1c :g #x44 :b #x48 :a #x80) + (new 'static 'rgba :r #x1d :g #x46 :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1b :g #x31 :b #x40 :a #x80) + (new 'static 'rgba :r #x1b :g #x36 :b #x41 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x1b :g #x3e :b #x45 :a #x80) + (new 'static 'rgba :r #x19 :g #x3f :b #x45 :a #x80) + (new 'static 'rgba :r #x17 :g #x40 :b #x46 :a #x80) + (new 'static 'rgba :r #x15 :g #x46 :b #x48 :a #x80) + (new 'static 'rgba :r #x14 :g #x48 :b #x46 :a #x80) + (new 'static 'rgba :r #x17 :g #x4a :b #x48 :a #x80) + (new 'static 'rgba :r #x1a :g #x4c :b #x4a :a #x80) + (new 'static 'rgba :r #x1e :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x26 :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x24 :g #x4e :b #x4f :a #x80) + (new 'static 'rgba :r #x27 :g #x51 :b #x50 :a #x80) + (new 'static 'rgba :r #x28 :g #x50 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x29 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x2d :g #x56 :b #x53 :a #x80) + (new 'static 'rgba :r #x2b :g #x55 :b #x55 :a #x80) + (new 'static 'rgba :r #x2c :g #x55 :b #x52 :a #x80) + (new 'static 'rgba :r #x30 :g #x59 :b #x58 :a #x80) + (new 'static 'rgba :r #x2f :g #x58 :b #x59 :a #x80) + (new 'static 'rgba :r #x2a :g #x57 :b #x57 :a #x80) + (new 'static 'rgba :r #x23 :g #x56 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x4e :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x3f :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x39 :b #x41 :a #x80) + (new 'static 'rgba :r #x1e :g #x3e :b #x47 :a #x80) + (new 'static 'rgba :r #x1f :g #x46 :b #x4c :a #x80) + (new 'static 'rgba :r #x1c :g #x4e :b #x4d :a #x80) + (new 'static 'rgba :r #x1b :g #x4e :b #x4a :a #x80) + (new 'static 'rgba :r #x19 :g #x49 :b #x4b :a #x80) + (new 'static 'rgba :r #x17 :g #x46 :b #x47 :a #x80) + (new 'static 'rgba :r #x18 :g #x43 :b #x47 :a #x80) + (new 'static 'rgba :r #x1a :g #x42 :b #x48 :a #x80) + (new 'static 'rgba :r #x1c :g #x3f :b #x46 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1d :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x3e :b #x47 :a #x80) + (new 'static 'rgba :r #x1b :g #x42 :b #x49 :a #x80) + (new 'static 'rgba :r #x18 :g #x46 :b #x4a :a #x80) + (new 'static 'rgba :r #x18 :g #x4b :b #x4b :a #x80) + (new 'static 'rgba :r #x18 :g #x4d :b #x4a :a #x80) + (new 'static 'rgba :r #x1b :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x1e :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x50 :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x50 :b #x4e :a #x80) + (new 'static 'rgba :r #x22 :g #x50 :b #x4c :a #x80) + (new 'static 'rgba :r #x24 :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x27 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x50 :a #x80) + (new 'static 'rgba :r #x26 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x28 :g #x53 :b #x53 :a #x80) + (new 'static 'rgba :r #x29 :g #x55 :b #x50 :a #x80) + (new 'static 'rgba :r #x2b :g #x56 :b #x52 :a #x80) + (new 'static 'rgba :r #x2c :g #x58 :b #x56 :a #x80) + (new 'static 'rgba :r #x2c :g #x58 :b #x55 :a #x80) + (new 'static 'rgba :r #x2e :g #x58 :b #x58 :a #x80) + (new 'static 'rgba :r #x2c :g #x59 :b #x59 :a #x80) + (new 'static 'rgba :r #x26 :g #x58 :b #x52 :a #x80) + (new 'static 'rgba :r #x22 :g #x56 :b #x52 :a #x80) + (new 'static 'rgba :r #x22 :g #x4c :b #x4f :a #x80) + (new 'static 'rgba :r #x22 :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1a :g #x36 :b #x40 :a #x80) + (new 'static 'rgba :r #x1a :g #x36 :b #x40 :a #x80) + (new 'static 'rgba :r #x1c :g #x3a :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x44 :b #x49 :a #x80) + (new 'static 'rgba :r #x1c :g #x47 :b #x4b :a #x80) + (new 'static 'rgba :r #x1c :g #x45 :b #x48 :a #x80) + (new 'static 'rgba :r #x1c :g #x42 :b #x47 :a #x80) + (new 'static 'rgba :r #x1d :g #x40 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x1f :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3f :b #x49 :a #x80) + (new 'static 'rgba :r #x1e :g #x43 :b #x4a :a #x80) + (new 'static 'rgba :r #x1d :g #x48 :b #x4d :a #x80) + (new 'static 'rgba :r #x1c :g #x4c :b #x4c :a #x80) + (new 'static 'rgba :r #x1b :g #x4f :b #x4d :a #x80) + (new 'static 'rgba :r #x1c :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x51 :b #x4f :a #x80) + (new 'static 'rgba :r #x1f :g #x52 :b #x4f :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x52 :b #x51 :a #x80) + (new 'static 'rgba :r #x23 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x23 :g #x53 :b #x4f :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x24 :g #x53 :b #x51 :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x50 :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x51 :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x53 :a #x80) + (new 'static 'rgba :r #x26 :g #x55 :b #x55 :a #x80) + (new 'static 'rgba :r #x28 :g #x56 :b #x56 :a #x80) + (new 'static 'rgba :r #x26 :g #x57 :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x54 :b #x55 :a #x80) + (new 'static 'rgba :r #x23 :g #x4f :b #x53 :a #x80) + (new 'static 'rgba :r #x24 :g #x41 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x22 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x41 :a #x80) + (new 'static 'rgba :r #x1b :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x1b :g #x36 :b #x41 :a #x80) + (new 'static 'rgba :r #x1d :g #x3b :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x3d :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x1e :g #x3c :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x22 :g #x38 :b #x46 :a #x80) + (new 'static 'rgba :r #x22 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3e :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #x20 :g #x48 :b #x4c :a #x80) + (new 'static 'rgba :r #x1f :g #x4a :b #x4f :a #x80) + (new 'static 'rgba :r #x1e :g #x4e :b #x51 :a #x80) + (new 'static 'rgba :r #x1f :g #x50 :b #x4f :a #x80) + (new 'static 'rgba :r #x1f :g #x51 :b #x51 :a #x80) + (new 'static 'rgba :r #x1f :g #x53 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x52 :b #x52 :a #x80) + (new 'static 'rgba :r #x20 :g #x54 :b #x52 :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x53 :a #x80) + (new 'static 'rgba :r #x21 :g #x54 :b #x50 :a #x80) + (new 'static 'rgba :r #x20 :g #x54 :b #x51 :a #x80) + (new 'static 'rgba :r #x21 :g #x52 :b #x53 :a #x80) + (new 'static 'rgba :r #x22 :g #x51 :b #x54 :a #x80) + (new 'static 'rgba :r #x22 :g #x4f :b #x53 :a #x80) + (new 'static 'rgba :r #x23 :g #x4d :b #x51 :a #x80) + (new 'static 'rgba :r #x26 :g #x43 :b #x4d :a #x80) + (new 'static 'rgba :r #x23 :g #x3d :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1c :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x42 :a #x80) + (new 'static 'rgba :r #x1c :g #x37 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x40 :b #x49 :a #x80) + (new 'static 'rgba :r #x21 :g #x42 :b #x4a :a #x80) + (new 'static 'rgba :r #x22 :g #x43 :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x46 :b #x4d :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x4a :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x47 :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x48 :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x48 :b #x4e :a #x80) + (new 'static 'rgba :r #x21 :g #x49 :b #x4f :a #x80) + (new 'static 'rgba :r #x21 :g #x4b :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x47 :b #x4e :a #x80) + (new 'static 'rgba :r #x20 :g #x46 :b #x4d :a #x80) + (new 'static 'rgba :r #x20 :g #x46 :b #x4c :a #x80) + (new 'static 'rgba :r #x21 :g #x45 :b #x4c :a #x80) + (new 'static 'rgba :r #x23 :g #x41 :b #x4b :a #x80) + (new 'static 'rgba :r #x22 :g #x40 :b #x4a :a #x80) + (new 'static 'rgba :r #x21 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x36 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x1d :g #x37 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x38 :b #x42 :a #x80) + (new 'static 'rgba :r #x1d :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x3b :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x21 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x21 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3e :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3e :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x21 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3c :b #x49 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x47 :a #x80) + (new 'static 'rgba :r #x21 :g #x3c :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3d :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x48 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x21 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x39 :b #x44 :a #x80) + (new 'static 'rgba :r #x1d :g #x39 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x43 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x47 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x39 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3b :b #x46 :a #x80) + (new 'static 'rgba :r #x20 :g #x3a :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x38 :b #x45 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x20 :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x38 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1e :g #x37 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x43 :a #x80) + (new 'static 'rgba :r #x20 :g #x36 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x36 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x46 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x45 :a #x80) + (new 'static 'rgba :r #x1f :g #x37 :b #x44 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x43 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x31 :b #x41 :a #x80) + (new 'static 'rgba :r #x1e :g #x32 :b #x40 :a #x80) + (new 'static 'rgba :r #x1e :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x35 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x33 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x34 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x41 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba :r #x1f :g #x32 :b #x42 :a #x80) + (new 'static 'rgba) + (new 'static 'rgba) + (new 'static 'rgba) + ) + ) + ) + +;; definition for symbol *ocean-near-indices-village2*, type ocean-near-indices +(define + *ocean-near-indices-village2* + (new 'static 'ocean-near-indices + :data + (new 'static 'inline-array ocean-near-index 23 + (new 'static 'ocean-near-index) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x1 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x1 #x0 #x0 #x0 #xffff #x0 #x0 #x0 #xffff #x0 #x0 #x0 #xffff #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x2 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #x0 + #x0 + #x0 + #xffff + #xffff + #x0 + #x0 + #xffff + #xffff + #xffff + #x0 + #xffff + #xffff + #xffff + #x3 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #x4 #x5 #x6 #xffff #x7 #x0 #x0 #xffff #x8 #x0 #x0 #xffff #x9 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xa #xb #x0 #x0 #xc #x0 #x0 #x0 #xd #x0 #x0 #x0 #xe #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xf + #xf + #xf + #xffff + #xf + #xf + #xf + #xffff + #xffff + #x2 + #x13 + #xffff + #xffff + #x15 + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xf #xf #x10 #x11 #xf #xf #xf #x12 #x0 #x0 #xf #x14 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #xffff #xffff #xffff #xffff #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x16 #xffff #xffff #x0 #x0 #x1d #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x17 #x18 #x19 #x1a #x0 #x0 #x1e #x1f #x0 #x0 #x0 #x22 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #x1b #x1c #x0 #x20 #x21 #x0 #x0 #x0 #x0 #x0 #x0 #x23 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #xffff + #xffff + #x24 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x25 #x2a #x2b #x2c #x2d #xffff #x33 #x0 #x34 #xffff #x38 #x39 #x3a) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x26 #x27 #x0 #x2e #x2f #x30 #x0 #xffff #x35 #x36 #x0 #x3b #x3c #x6 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x0 #x0 #x0 #x28 #x0 #x0 #x31 #x32 #x0 #x0 #x37 #x0 #x0 #x0 #x3d #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x29 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #xffff + #x3e + #x3f + #x40 + #xffff + #x42 + #x0 + #x0 + #xffff + #x47 + #x48 + #x49 + #xffff + #xffff + #xffff + #xffff + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #x41 #x0 #x0 #x0 #x0 #x0 #x0 #x43 #x4a #x4b #x0 #x4c #x4e #x4f #x50 #x51) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x0 + #x0 + #x0 + #x0 + #x44 + #x45 + #x46 + #x0 + #xffff + #xffff + #x4d + #x46 + #xffff + #xffff + #xffff + #x52 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 + #x53 + #x54 + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #xffff + #x0 + ) + ) + (new 'static 'ocean-near-index + :data + (new 'static 'array uint16 16 #xffff #xffff #x0 #x0 #xffff #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x0) + ) + ) + ) + ) + +;; definition for symbol *ocean-trans-indices-village2*, type ocean-trans-indices +(define + *ocean-trans-indices-village2* + (new 'static 'ocean-trans-indices :data (new 'static 'inline-array ocean-trans-index 2304 + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 85 :child 2) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 86 :child 3) + (new 'static 'ocean-trans-index :parent 87 :child 4) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 86 :child 3) + (new 'static 'ocean-trans-index :parent 7 :child 5) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 1 :child 1) + (new 'static 'ocean-trans-index :parent 86 :child 3) + (new 'static 'ocean-trans-index :child 6) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 88 :child 7) + (new 'static 'ocean-trans-index :child 8) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 89 :child 9) + (new 'static 'ocean-trans-index :parent 29 :child 10) + (new 'static 'ocean-trans-index :child 11) + (new 'static 'ocean-trans-index :parent 6 :child 12) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 81 :child 13) + (new 'static 'ocean-trans-index :parent 90 :child 14) + (new 'static 'ocean-trans-index :parent 91 :child 15) + (new 'static 'ocean-trans-index :child 16) + (new 'static 'ocean-trans-index :child 17) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 92 :child 18) + (new 'static 'ocean-trans-index :child 19) + (new 'static 'ocean-trans-index :parent 93 :child 20) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent 94 :child 21) + (new 'static 'ocean-trans-index :parent 95 :child 22) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index :parent -1 :child -1) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + (new 'static 'ocean-trans-index) + ) + ) + ) + +;; definition for symbol *ocean-mid-indices-village2*, type ocean-mid-indices +(define *ocean-mid-indices-village2* (new 'static 'ocean-mid-indices :data (new 'static 'array uint16 36 + #xffff + #xffff + #xffff + #x60 + #x0 + #x0 + #xffff + #xffff + #xffff + #x60 + #x0 + #x0 + #xffff + #xffff + #x61 + #x62 + #x0 + #x0 + #x63 + #x64 + #x65 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + #x0 + ) + ) + ) + +;; definition for symbol *ocean-mid-masks-village2*, type ocean-mid-masks +(define + *ocean-mid-masks-village2* + (new 'static 'ocean-mid-masks + :data + (new 'static 'inline-array ocean-mid-mask 102 + (new 'static 'ocean-mid-mask) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #x1f #xf #x7 #x7 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x87 #x3 #x3 #x3 #x3 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x62 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x7 #xf #x1f #x1f #x1f #x1f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x3f #x3f #x3f #x1f #x1f #x1f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #x7f #x3f #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xf #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #x7 #x7 #x7 #x7 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x1 #x1 #x1 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xff #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x7f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x3f #xf #x3 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1 #x9 #xf #xf #x1f #x1f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x3f #x1f #xf #x7 #x1 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #xf #xf #x3f #x3f #x1f #x1f #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #x7f #x3f #x3f #x1f #xf #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #x80 #x80 #x80 #x80 #x80 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x1f #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xf9 #xf0 #x10 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x3f #x3c)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #xfe #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x7f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x1 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1c #x0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xfc #xfe #xf8 #xf8 #xf0 #xe0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xfd #xfd #x78 #x30 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x3 #x1 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xc0 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x38)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #x7f #x7f #x7f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #xc #xc #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xc0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xe0 #xf0 #x30 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x7 #x7 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x1 #x1 #x3 #xf #x1f #x3f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x18 #x1c #x3f #x3f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #xc0 #xe0 #xe0 #xc0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x3f #x3f #x3f #xff #xff #xff #xfe)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xc0 #xe0 #xe0 #xe0 #xff #xff #x7f #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x3 #x3 #x3 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #xe0 #xe0 #xe0 #xe0 #xe0 #xe0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x3 #x7 #x7 #x7 #x3 #x1 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x1f #xf #xf #xf #xf #xf #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfe #xfe #xfe #xfe #xfe #xfe #xfe #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x7f #x7f #x7f #x7f #x7f #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x1 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x70)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #x3f #xff #xff #x7f #x7 #x3 #x3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xfe #xfe #xfe #xfe #xfe #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x3f #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #x7f #x7f #x7f #x7f #x7f #x78 #x60)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x70 #x70 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3 #x3 #x7 #x7 #xf #xf #xf #x7)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf8 #xf8 #xf8 #x70 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xf #xe #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #x3 #x0 #x0 #x0 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x7 #x7 #x7 #x7 #xf)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x80 #xc0 #xe0 #xf0 #xf0 #xf0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1f #x7f #x7f #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x1 #x1 #xe3 #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x0 #x0 #x0 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7f #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x7 #xf #x1f #x1f #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #xe0 #xe0 #xe0 #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x8 #x18 #xfc #xff #xff #x7f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #x0 #x0 #x0 #x3f #x3f #x3 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xe0 #xc0 #x80 #x80 #x80 #x83)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf #xf #xf #xf #x1f #x1f #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #x7 #x7 #x3 #x1 #x0 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x80 #xc0 #x80 #x0 #x0 #x0 #xc0 #xe0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x81 #x87 #x83 #x80 #x80 #x80 #xc0 #xe3)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x7 #xf #xf #x9f #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x3 #x7 #xf #xf #xf #x3 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x0 #xff #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xff #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf1 #xf1 #xf1 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf1 #xf3 #xf7 #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf1 #xf1 #xf3 #xf3 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xf1 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf1 #xf1 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf1 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf1 #xf1 #xf1 #xff #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf0 #xf0 #xf3 #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xfc #xff #xff #xf7 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xf3 #xf1 #xf0 #xf0 #xff #xff #xff #xff)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x1 #x1 #x1)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #xff #x3f #x1f)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x1 #x1 #x1 #x1 #x1 #x1 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xfc #xfc #xfc #xfc #xfc #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #xff #xff #xff #xff #xff #x11 #x0 #x0)) + (new 'static 'ocean-mid-mask :mask (new 'static 'array uint8 8 #x3f #x7f #x7f #x3f #x1f #xf #x7 #x0)) + ) + ) + ) + +;; definition for symbol *ocean-near-indices-sunken*, type ocean-near-indices +(define + *ocean-near-indices-sunken* + (new 'static 'ocean-near-indices + :data + (new 'static 'inline-array ocean-near-index 1 (new 'static 'ocean-near-index)) + ) + ) + +;; definition for symbol *ocean-trans-indices-sunken*, type ocean-trans-indices +(define *ocean-trans-indices-sunken* (new 'static 'ocean-trans-indices)) + +;; definition for symbol *ocean-mid-indices-sunken*, type ocean-mid-indices +(define *ocean-mid-indices-sunken* (new 'static 'ocean-mid-indices)) + +;; definition for symbol *ocean-mid-masks-sunken*, type ocean-mid-masks +(define + *ocean-mid-masks-sunken* + (new 'static 'ocean-mid-masks + :data + (new 'static 'inline-array ocean-mid-mask 2 (new 'static 'ocean-mid-mask) (new 'static 'ocean-mid-mask)) + ) + ) + +;; definition for symbol *ocean-map-village1*, type ocean-map +(define *ocean-map-village1* (new 'static 'ocean-map + :start-corner + (new 'static 'vector :x -9437184.0 :z -9437184.0 :w 1.0) + :far-color + (new 'static 'vector :x 1.505882 :y 45.678432 :z 56.72157) + ) + ) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-spheres) *ocean-spheres-village1*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-colors) *ocean-colors-village1*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-mid-masks) *ocean-mid-masks-village1*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-mid-indices) *ocean-mid-indices-village1*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-trans-indices) *ocean-trans-indices-village1*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village1* ocean-near-indices) *ocean-near-indices-village1*) + +;; definition for symbol *ocean-map-village2*, type ocean-map +(define *ocean-map-village2* (new 'static 'ocean-map + :start-corner + (new 'static 'vector :x -7892992.0 :z -15958016.0 :w 1.0) + :far-color + (new 'static 'vector :x 31.62353 :y 50.19608 :z 66.76079) + ) + ) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-spheres) *ocean-spheres-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-colors) *ocean-colors-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-mid-masks) *ocean-mid-masks-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-mid-indices) *ocean-mid-indices-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-trans-indices) *ocean-trans-indices-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-village2* ocean-near-indices) *ocean-near-indices-village2*) + +;; definition for symbol *ocean-map-sunken*, type ocean-map +(define *ocean-map-sunken* (new 'static 'ocean-map + :start-corner + (new 'static 'vector :x -7892992.0 :z -15958016.0 :w 1.0) + :far-color + (new 'static 'vector :x 31.62353 :y 50.19608 :z 66.76079) + ) + ) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-spheres) *ocean-spheres-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-colors) *ocean-colors-village2*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-mid-masks) *ocean-mid-masks-sunken*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-mid-indices) *ocean-mid-indices-sunken*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-trans-indices) *ocean-trans-indices-sunken*) + +;; failed to figure out what this is: +(set! (-> *ocean-map-sunken* ocean-near-indices) *ocean-near-indices-sunken*) + + + + diff --git a/test/decompiler/reference/engine/gfx/sky/sky_REF.gc b/test/decompiler/reference/engine/gfx/sky/sky_REF.gc new file mode 100644 index 0000000000..19775725ae --- /dev/null +++ b/test/decompiler/reference/engine/gfx/sky/sky_REF.gc @@ -0,0 +1,202 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for function sky-make-sun-data +;; INFO: Return type mismatch symbol vs none. +(defun sky-make-sun-data ((arg0 sky-parms) (arg1 int) (arg2 float)) + (let* ((s4-0 (-> arg0 orbit arg1)) + (s3-0 (-> arg0 upload-data sun arg1)) + (f0-1 (- arg2 (-> s4-0 high-noon))) + (f30-0 (* 2730.6667 f0-1)) + (f28-0 (* (sin f30-0) (-> s4-0 dist))) + (f30-1 (cos f30-0)) + ) + (let* ((f24-0 (* f30-1 (-> s4-0 dist))) + (f26-0 (* f24-0 (cos-rad (-> s4-0 tilt)))) + (f24-1 (* f24-0 (sin-rad (-> s4-0 tilt)))) + (f22-0 (sin-rad (-> s4-0 rise))) + (f0-10 (cos-rad (-> s4-0 rise))) + ) + (set! (-> s3-0 pos z) (- (+ (* f28-0 f0-10) (* f24-1 f22-0)))) + (set! (-> s3-0 pos y) f26-0) + (set! (-> s3-0 pos x) (- (* f24-1 f0-10) (* f28-0 f22-0))) + ) + (let ((f0-14 (if (< f30-1 0.0) + 0.0 + f30-1 + ) + ) + ) + (set! (-> arg0 upload-data sun arg1 r-aurora) + (+ (* (-> s4-0 min-halo) (- 1.0 f0-14)) (* (-> s4-0 max-halo) f0-14)) + ) + ) + ) + (none) + ) + +;; definition for function sky-make-moon-data +;; INFO: Return type mismatch symbol vs none. +(defun sky-make-moon-data ((arg0 sky-parms) (arg1 float)) + (let* ((s5-0 (-> arg0 orbit 2)) + (gp-0 (-> arg0 upload-data moon)) + (f0-1 (- arg1 (-> s5-0 high-noon))) + (f28-0 (* 2730.6667 f0-1)) + (f30-0 (* (sin f28-0) (-> s5-0 dist))) + (f26-0 (* (cos f28-0) (-> s5-0 dist))) + (f28-1 (* f26-0 (cos-rad (-> s5-0 tilt)))) + (f26-1 (* f26-0 (sin-rad (-> s5-0 tilt)))) + (f24-0 (sin-rad (-> s5-0 rise))) + (f0-10 (cos-rad (-> s5-0 rise))) + ) + (set! (-> gp-0 pos z) (- (+ (* f30-0 f0-10) (* f26-1 f24-0)))) + (set! (-> gp-0 pos y) f28-1) + (set! (-> gp-0 pos x) (- (* f26-1 f0-10) (* f30-0 f24-0))) + ) + (none) + ) + +;; definition for function sky-make-light +;; INFO: Return type mismatch light vs none. +(defun sky-make-light ((arg0 sky-parms) (arg1 light) (arg2 int) (arg3 rgba)) + (let* ((v1-2 (-> arg0 orbit arg2)) + (a0-1 (if (= arg2 2) + (-> arg0 upload-data moon) + (-> arg0 upload-data sun arg2) + ) + ) + (f0-0 0.003921569) + (f1-1 (/ 1.0 (-> v1-2 dist))) + (v1-3 arg1) + ) + (set! (-> v1-3 direction x) (* (-> (the-as sky-sun-data a0-1) pos x) f1-1)) + (set! (-> v1-3 direction y) (* (-> (the-as sky-sun-data a0-1) pos y) f1-1)) + (set! (-> v1-3 direction z) (* (-> (the-as sky-sun-data a0-1) pos z) f1-1)) + (set! (-> v1-3 color x) (* (the float (-> arg3 r)) f0-0)) + (set! (-> v1-3 color y) (* (the float (-> arg3 g)) f0-0)) + (set! (-> v1-3 color z) (* (the float (-> arg3 b)) f0-0)) + (set! (-> v1-3 color w) 1.0) + (set! (-> v1-3 levels x) 1.0) + ) + (none) + ) + +;; definition of type sky-frame-data +(deftype sky-frame-data (structure) + ((data uint128 18 :offset-assert 0) + (world-homo-matrix matrix :inline :offset 0) + (hmge-scale vector :inline :offset 64) + (hvdf-offset vector :inline :offset 80) + (consts vector :inline :offset 96) + (pfog0 float :offset 96) + (radius float :offset 100) + (nokick float :offset 108) + (strip-giftag qword :inline :offset 112) + (col-adgif qword :inline :offset 128) + (save uint128 5 :offset 144) + (sun-fan-giftag qword :inline :offset 224) + (sun-strip-giftag qword :inline :offset 240) + (sun-alpha qword :inline :offset 256) + (sun-alpha-giftag qword :inline :offset 272) + ) + :method-count-assert 9 + :size-assert #x120 + :flag-assert #x900000120 + ) + +;; definition for method 3 of type sky-frame-data +(defmethod inspect sky-frame-data ((obj sky-frame-data)) + (format #t "[~8x] ~A~%" obj 'sky-frame-data) + (format #t "~Tdata[18] @ #x~X~%" (-> obj data)) + (format #t "~Tworld-homo-matrix: #~%" (-> obj data)) + (format #t "~Thmge-scale: #~%" (-> obj hmge-scale)) + (format #t "~Thvdf-offset: #~%" (-> obj hvdf-offset)) + (format #t "~Tconsts: #~%" (-> obj consts)) + (format #t "~Tpfog0: ~f~%" (-> obj consts x)) + (format #t "~Tradius: ~f~%" (-> obj consts y)) + (format #t "~Tnokick: ~f~%" (-> obj consts w)) + (format #t "~Tstrip-giftag: #~%" (-> obj strip-giftag)) + (format #t "~Tcol-adgif: #~%" (-> obj col-adgif)) + (format #t "~Tsave[5] @ #x~X~%" (-> obj save)) + (format #t "~Tsun-fan-giftag: #~%" (-> obj sun-fan-giftag)) + (format #t "~Tsun-strip-giftag: #~%" (-> obj sun-strip-giftag)) + (format #t "~Tsun-alpha: #~%" (-> obj sun-alpha)) + (format #t "~Tsun-alpha-giftag: #~%" (-> obj sun-alpha-giftag)) + obj + ) + +;; definition for symbol sky-vu1-block, type vu-function +(define sky-vu1-block (new 'static 'vu-function :length #xcd :qlength #x67)) + +;; definition for function sky-init-upload-data +;; ERROR: function has no type analysis. Cannot decompile. + +;; definition for function sky-add-frame-data +;; ERROR: function has no type analysis. Cannot decompile. + +;; definition for function sky-upload +;; ERROR: function has no type analysis. Cannot decompile. + +;; definition for function sky-draw +;; WARN: Type Propagation failed: Failed type prop at op 12 ((set! a0 (+ a0 16))): Cannot get_type_int2: (+ a0 16), args float and +;; WARN: Type Propagation failed: Type analysis failed +(defun sky-draw ((a0-0 sky-parms)) + (local-vars + (v0-0 none) + (v1-0 sky-parms) + (a0-1 float) + (a0-2 none) + (a1-0 int) + (a1-1 int) + (a1-2 int) + (a1-3 int) + (a2-0 int) + (a2-1 int) + (a2-2 int) + ) + (set! v1-0 a0-0) + (set! a0-1 (-> v1-0 orbit 0 tilt)) + (set! a1-0 #x10000000) + (s.d! a0-1 a1-0) + (set! a1-1 #x15000000) + (set! a2-0 191) + (set! a2-1 (sll a2-0 48)) + (set! a2-2 (srl a2-1 48)) + (set! a1-2 (logior a1-1 a2-2)) + (s.w! (+ a0-1 8) a1-2) + (set! a1-3 #x10000000) + (s.w! (+ a0-1 12) a1-3) + (set! a0-2 (the-as none (+ a0-1 16))) + (s.w! (+ v1-0 4) a0-2) + (set! v0-0 (the-as none 0)) + (ret-none) + ) + +;; failed to figure out what this is: +(sky-set-sun-radii *sky-parms* 0 60.0 200.0 300.0) + +;; failed to figure out what this is: +(sky-set-sun-radii *sky-parms* 1 15.0 20.0 300.0) + +;; failed to figure out what this is: +(sky-set-sun-colors + *sky-parms* + 1 + (new 'static 'rgba :r #xc2 :g #xfe :b #x78 :a #x80) + (new 'static 'rgba :r #xc2 :g #xfe :b #x78 :a #x80) + (new 'static 'rgba :r #xc2 :g #xfe :b #x78 :a #x20) + (new 'static 'rgba :r #xc2 :g #xfe :b #x78) + ) + +;; failed to figure out what this is: +(sky-set-orbit *sky-parms* 0 12.5 -15.0 0.0 9950.0 300.0 300.0) + +;; failed to figure out what this is: +(sky-set-orbit *sky-parms* 1 4.0 0.0 60.0 9950.0 120.0 120.0) + +;; failed to figure out what this is: +(sky-set-orbit *sky-parms* 2 0.0 0.0 -10.0 9950.0 0.0 0.0) + + + + diff --git a/test/decompiler/reference/engine/sparticle/sparticle-h_REF.gc b/test/decompiler/reference/engine/sparticle/sparticle-h_REF.gc new file mode 100644 index 0000000000..ba52b20a4a --- /dev/null +++ b/test/decompiler/reference/engine/sparticle/sparticle-h_REF.gc @@ -0,0 +1,153 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *sp-frame-time*, type vector +(define *sp-frame-time* (new 'global 'vector)) + +;; failed to figure out what this is: +(set-vector! *sp-frame-time* 0.00000000000000000000000000000000000001175495 5.0 1.0 1.0) + +;; definition for symbol *sp-60-hz*, type symbol +(define *sp-60-hz* #t) + +;; definition of type sparticle-cpuinfo +(deftype sparticle-cpuinfo (structure) + ((sprite sprite-vec-data-2d :offset-assert 0) + (adgif adgif-shader :offset-assert 4) + (radius float :offset-assert 8) + (omega float :offset-assert 12) + (vel-sxvel vector :inline :offset-assert 16) + (rot-syvel vector :inline :offset-assert 32) + (fade rgbaf :inline :offset-assert 48) + (acc vector :inline :offset-assert 64) + (rotvel3d quaternion :inline :offset-assert 80) + (vel vector3s :inline :offset 16) + (accel vector3s :inline :offset 64) + (scalevelx float :offset 28) + (scalevely float :offset 44) + (friction float :offset-assert 96) + (timer int32 :offset-assert 100) + (flags sp-cpuinfo-flag :offset-assert 104) + (user-int32 int32 :offset-assert 108) + (user-uint32 uint32 :offset 108) + (user-float float :offset 108) + (user-pntr uint32 :offset 108) + (user-sprite sprite-vec-data-2d :offset 108) + (func basic :offset-assert 112) + (next-time uint32 :offset-assert 116) + (next-launcher basic :offset-assert 120) + (cache-alpha float :offset-assert 124) + (valid symbol :offset-assert 128) + (key sparticle-launch-control :offset-assert 132) + (binding sparticle-launch-state :offset-assert 136) + (data uint32 1 :offset 12) + (dataf float 1 :offset 12) + (datac uint8 1 :offset 12) + ) + :method-count-assert 9 + :size-assert #x8c + :flag-assert #x90000008c + ) + +;; definition for method 3 of type sparticle-cpuinfo +(defmethod inspect sparticle-cpuinfo ((obj sparticle-cpuinfo)) + (format #t "[~8x] ~A~%" obj 'sparticle-cpuinfo) + (format #t "~Tsprite: #~%" (-> obj sprite)) + (format #t "~Tadgif: #~%" (-> obj adgif)) + (format #t "~Tradius: ~f~%" (-> obj radius)) + (format #t "~Tomega: ~f~%" (-> obj omega)) + (format #t "~Tvel-sxvel: #~%" (-> obj vel-sxvel)) + (format #t "~Trot-syvel: #~%" (-> obj rot-syvel)) + (format #t "~Tfade: #~%" (-> obj fade)) + (format #t "~Tacc: #~%" (-> obj acc)) + (format #t "~Trotvel3d: #~%" (-> obj rotvel3d)) + (format #t "~Tvel: #~%" (-> obj vel-sxvel)) + (format #t "~Taccel: #~%" (-> obj acc)) + (format #t "~Tscalevelx: ~f~%" (-> obj vel-sxvel w)) + (format #t "~Tscalevely: ~f~%" (-> obj rot-syvel w)) + (format #t "~Tfriction: ~f~%" (-> obj friction)) + (format #t "~Ttimer: ~D~%" (-> obj timer)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Tuser-int32: ~D~%" (-> obj user-float)) + (format #t "~Tuser-uint32: ~D~%" (-> obj user-float)) + (format #t "~Tuser-float: ~f~%" (the-as float (-> obj user-float))) + (format #t "~Tuser-pntr: #x~X~%" (-> obj user-float)) + (format #t "~Tuser-sprite: #~%" (-> obj user-float)) + (format #t "~Tfunc: ~A~%" (-> obj func)) + (format #t "~Tnext-time: ~D~%" (-> obj next-time)) + (format #t "~Tnext-launcher: ~A~%" (-> obj next-launcher)) + (format #t "~Tcache-alpha: ~f~%" (-> obj cache-alpha)) + (format #t "~Tvalid: ~A~%" (-> obj valid)) + (format #t "~Tkey: ~A~%" (-> obj key)) + (format #t "~Tbinding: #~%" (-> obj binding)) + (format #t "~Tdata[1] @ #x~X~%" (&-> obj omega)) + (format #t "~Tdataf[1] @ #x~X~%" (&-> obj omega)) + (format #t "~Tdatac[1] @ #x~X~%" (&-> obj omega)) + obj + ) + +;; definition of type sparticle-launchinfo +(deftype sparticle-launchinfo (structure) + ((launchrot vector :inline :offset-assert 0) + (conerot vector :inline :offset-assert 16) + (coneradius float :offset-assert 32) + (rotate-y float :offset-assert 36) + (data uint8 1 :offset 0) + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + ) + +;; definition for method 3 of type sparticle-launchinfo +(defmethod inspect sparticle-launchinfo ((obj sparticle-launchinfo)) + (format #t "[~8x] ~A~%" obj 'sparticle-launchinfo) + (format #t "~Tlaunchrot: #~%" (-> obj launchrot)) + (format #t "~Tconerot: #~%" (-> obj conerot)) + (format #t "~Tconeradius: ~f~%" (-> obj coneradius)) + (format #t "~Trotate-y: ~f~%" (-> obj rotate-y)) + (format #t "~Tdata[1] @ #x~X~%" (-> obj launchrot)) + obj + ) + +;; definition of type sparticle-system +(deftype sparticle-system (basic) + ((blocks int32 2 :offset-assert 4) + (length int32 2 :offset-assert 12) + (num-alloc int32 2 :offset-assert 20) + (is-3d basic :offset-assert 28) + (flags uint32 :offset-assert 32) + (alloc-table (pointer uint64) :offset-assert 36) + (cpuinfo-table (inline-array sparticle-cpuinfo) :offset-assert 40) + (vecdata-table pointer :offset-assert 44) + (adgifdata-table (inline-array adgif-shader) :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + (:methods + (new (symbol type int int symbol pointer (inline-array adgif-shader)) _type_ 0) + ) + ) + +;; definition for method 3 of type sparticle-system +(defmethod inspect sparticle-system ((obj sparticle-system)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tblocks[2] @ #x~X~%" (-> obj blocks)) + (format #t "~Tlength[2] @ #x~X~%" (-> obj length)) + (format #t "~Tnum-alloc[2] @ #x~X~%" (-> obj num-alloc)) + (format #t "~Tis-3d: ~A~%" (-> obj is-3d)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Talloc-table: #x~X~%" (-> obj alloc-table)) + (format #t "~Tcpuinfo-table: #x~X~%" (-> obj cpuinfo-table)) + (format #t "~Tvecdata-table: #x~X~%" (-> obj vecdata-table)) + (format #t "~Tadgifdata-table: #x~X~%" (-> obj adgifdata-table)) + obj + ) + +;; failed to figure out what this is: +0 + + + + diff --git a/test/decompiler/reference/engine/sparticle/sparticle-launcher-h_REF.gc b/test/decompiler/reference/engine/sparticle/sparticle-launcher-h_REF.gc new file mode 100644 index 0000000000..eb6e74cbf8 --- /dev/null +++ b/test/decompiler/reference/engine/sparticle/sparticle-launcher-h_REF.gc @@ -0,0 +1,218 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition of type sp-field-init-spec +(deftype sp-field-init-spec (structure) + ((field sp-field-id :offset-assert 0) + (flags sp-flag :offset-assert 2) + (initial-valuef float :offset-assert 4) + (random-rangef float :offset-assert 8) + (random-multf float :offset-assert 12) + (initial-value int32 :offset 4) + (random-range int32 :offset 8) + (random-mult int32 :offset 12) + (sym symbol :offset 4) + (func symbol :offset 4) + (tex uint32 :offset 4) + (pntr pointer :offset 4) + (sound sound-spec :offset 4) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; definition for method 3 of type sp-field-init-spec +(defmethod inspect sp-field-init-spec ((obj sp-field-init-spec)) + (format #t "[~8x] ~A~%" obj 'sp-field-init-spec) + (format #t "~Tfield: ~D~%" (-> obj field)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Tinitial-valuef: ~f~%" (-> obj initial-valuef)) + (format #t "~Trandom-rangef: ~f~%" (-> obj random-rangef)) + (format #t "~Trandom-multf: ~f~%" (-> obj random-multf)) + (format #t "~Tinitial-value: ~D~%" (-> obj initial-valuef)) + (format #t "~Trandom-range: ~D~%" (-> obj random-rangef)) + (format #t "~Trandom-mult: ~D~%" (-> obj random-multf)) + (format #t "~Tfunc: ~A~%" (-> obj initial-valuef)) + (format #t "~Ttex: ~D~%" (-> obj initial-valuef)) + (format #t "~Tpntr: #x~X~%" (-> obj initial-valuef)) + (format #t "~Tsym: ~A~%" (-> obj initial-valuef)) + (format #t "~Tsound: ~A~%" (-> obj initial-valuef)) + obj + ) + +;; definition of type sparticle-launcher +(deftype sparticle-launcher (basic) + ((birthaccum float :offset-assert 4) + (soundaccum float :offset-assert 8) + (init-specs (inline-array sp-field-init-spec) :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; definition for method 3 of type sparticle-launcher +(defmethod inspect sparticle-launcher ((obj sparticle-launcher)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tbirthaccum: ~f~%" (-> obj birthaccum)) + (format #t "~Tsoundaccum: ~f~%" (-> obj soundaccum)) + (format #t "~Tinit-specs: #x~X~%" (-> obj init-specs)) + obj + ) + +;; definition of type sparticle-group-item +(deftype sparticle-group-item (structure) + ((launcher uint32 :offset-assert 0) + (fade-after meters :offset-assert 4) + (falloff-to meters :offset-assert 8) + (flags sp-group-item-flag :offset-assert 12) + (period uint16 :offset-assert 14) + (length uint16 :offset-assert 16) + (offset uint16 :offset-assert 18) + (hour-mask uint32 :offset-assert 20) + (binding uint32 :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +;; definition for method 3 of type sparticle-group-item +(defmethod inspect sparticle-group-item ((obj sparticle-group-item)) + (format #t "[~8x] ~A~%" obj 'sparticle-group-item) + (format #t "~Tlauncher: ~D~%" (-> obj launcher)) + (format #t "~Tfade-after: (meters ~m)~%" (-> obj fade-after)) + (format #t "~Tfalloff-to: (meters ~m)~%" (-> obj falloff-to)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Tperiod: ~D~%" (-> obj period)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Toffset: ~D~%" (-> obj offset)) + (format #t "~Thour-mask: ~D~%" (-> obj hour-mask)) + (format #t "~Tbinding: ~D~%" (-> obj binding)) + obj + ) + +;; definition of type sparticle-launch-state +(deftype sparticle-launch-state (structure) + ((group-item sparticle-group-item :offset-assert 0) + (flags sp-launch-state-flags :offset-assert 4) + (randomize uint16 :offset-assert 6) + (origin vector :offset-assert 8) + (sprite3d sprite-vec-data-3d :offset-assert 12) + (sprite sparticle-cpuinfo :offset-assert 16) + (offset uint32 :offset-assert 20) + (accum float :offset-assert 24) + (spawn-time uint32 :offset-assert 28) + (swarm basic :offset 20) + (seed uint32 :offset 24) + (time uint32 :offset 28) + (spec basic :offset 16) + (id uint32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; definition for method 3 of type sparticle-launch-state +(defmethod inspect sparticle-launch-state ((obj sparticle-launch-state)) + (format #t "[~8x] ~A~%" obj 'sparticle-launch-state) + (format #t "~Tgroup-item: #~%" (-> obj group-item)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Trandomize: ~D~%" (-> obj randomize)) + (format #t "~Torigin: #~%" (-> obj origin)) + (format #t "~Tsprite3d: #~%" (-> obj sprite3d)) + (format #t "~Tsprite: ~A~%" (-> obj sprite)) + (format #t "~Toffset: ~D~%" (-> obj offset)) + (format #t "~Taccum: ~f~%" (-> obj accum)) + (format #t "~Tspawn-time: ~D~%" (-> obj spawn-time)) + (format #t "~Tswarm: ~A~%" (-> obj offset)) + (format #t "~Tseed: ~D~%" (-> obj accum)) + (format #t "~Ttime: ~D~%" (-> obj spawn-time)) + (format #t "~Tspec: ~A~%" (-> obj sprite)) + (format #t "~Tid: ~D~%" (-> obj sprite3d)) + obj + ) + +;; definition of type sparticle-launch-group +(deftype sparticle-launch-group (basic) + ((length int16 :offset-assert 4) + (duration uint16 :offset-assert 6) + (linger-duration uint16 :offset-assert 8) + (flags sp-group-flag :offset-assert 10) + (name string :offset-assert 12) + (launcher (inline-array sparticle-group-item) :offset-assert 16) + (bounds sphere :inline :offset-assert 32) + ) + :method-count-assert 10 + :size-assert #x30 + :flag-assert #xa00000030 + (:methods + (create-launch-control (_type_ process) sparticle-launch-control 9) + ) + ) + +;; definition for method 3 of type sparticle-launch-group +(defmethod inspect sparticle-launch-group ((obj sparticle-launch-group)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Tduration: ~D~%" (-> obj duration)) + (format #t "~Tlinger-duration: ~D~%" (-> obj linger-duration)) + (format #t "~Tflags: ~D~%" (-> obj flags)) + (format #t "~Tname: ~A~%" (-> obj name)) + (format #t "~Tlauncher: #x~X~%" (-> obj launcher)) + (format #t "~Tbounds: #~%" (-> obj bounds)) + obj + ) + +;; definition of type sparticle-launch-control +(deftype sparticle-launch-control (inline-array-class) + ((group sparticle-launch-group :offset-assert 16) + (proc process :offset-assert 20) + (local-clock int32 :offset-assert 24) + (fade float :offset-assert 28) + (matrix int32 :offset-assert 32) + (last-spawn-frame int32 :offset-assert 36) + (last-spawn-time int32 :offset-assert 40) + (center vector :inline :offset-assert 48) + (data sparticle-launch-state :inline :dynamic :offset-assert 64) + ) + :method-count-assert 14 + :size-assert #x40 + :flag-assert #xe00000040 + (:methods + (initialize (_type_ sparticle-launch-group process) none 9) + (is-visible? (_type_ vector) symbol 10) + (spawn (_type_ vector) object 11) + (kill-and-free-particles (_type_) none 12) + (kill-particles (_type_) none 13) + ) + ) + +;; definition for method 3 of type sparticle-launch-control +(defmethod inspect sparticle-launch-control ((obj sparticle-launch-control)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tlength: ~D~%" (-> obj length)) + (format #t "~Tallocated-length: ~D~%" (-> obj allocated-length)) + (format #t "~Tgroup: ~A~%" (-> obj group)) + (format #t "~Tproc: ~A~%" (-> obj proc)) + (format #t "~Tlocal-clock: ~D~%" (-> obj local-clock)) + (format #t "~Tfade: ~f~%" (-> obj fade)) + (format #t "~Tmatrix: ~D~%" (-> obj matrix)) + (format #t "~Tlast-spawn-frame: ~D~%" (-> obj last-spawn-frame)) + (format #t "~Tlast-spawn-time: ~D~%" (-> obj last-spawn-time)) + (format #t "~Tcenter: ~`vector`P~%" (-> obj center)) + (format #t "~Tdata[0] @ #x~X~%" (-> obj data)) + obj + ) + +;; failed to figure out what this is: +(set! (-> sparticle-launch-control heap-base) (the-as uint 32)) + +;; failed to figure out what this is: +0 + + + + diff --git a/test/decompiler/reference/engine/sparticle/sparticle-launcher_REF.gc b/test/decompiler/reference/engine/sparticle/sparticle-launcher_REF.gc new file mode 100644 index 0000000000..8e6f630f5c --- /dev/null +++ b/test/decompiler/reference/engine/sparticle/sparticle-launcher_REF.gc @@ -0,0 +1,1362 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *particle-300hz-timer*, type int +(define *particle-300hz-timer* 0) + +;; definition of type sparticle-birthinfo +(deftype sparticle-birthinfo (structure) + ((sprite uint32 :offset-assert 0) + (anim int32 :offset-assert 4) + (anim-speed float :offset-assert 8) + (birth-func basic :offset-assert 12) + (joint-ppoint int32 :offset-assert 16) + (num-to-birth float :offset-assert 20) + (sound basic :offset-assert 24) + (dataf float 1 :offset 0) + (data uint32 1 :offset 0) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +;; definition for method 3 of type sparticle-birthinfo +(defmethod inspect sparticle-birthinfo ((obj sparticle-birthinfo)) + (format #t "[~8x] ~A~%" obj 'sparticle-birthinfo) + (format #t "~Tsprite: ~D~%" (-> obj sprite)) + (format #t "~Tanim: ~D~%" (-> obj anim)) + (format #t "~Tanim-speed: ~f~%" (-> obj anim-speed)) + (format #t "~Tbirth-func: ~A~%" (-> obj birth-func)) + (format #t "~Tjoint-ppoint: ~D~%" (-> obj joint-ppoint)) + (format #t "~Tnum-to-birth: ~f~%" (-> obj num-to-birth)) + (format #t "~Tsound: ~A~%" (-> obj sound)) + (format #t "~Tdataf[1] @ #x~X~%" (&-> obj sprite)) + (format #t "~Tdata[1] @ #x~X~%" (&-> obj sprite)) + obj + ) + +;; definition for method 3 of type sparticle-launcher +;; INFO: Return type mismatch int vs sparticle-launcher. +(defmethod inspect sparticle-launcher ((obj sparticle-launcher)) + (format #t "~X: sparticle-launcher~%" obj) + (let ((s5-0 0)) + (while (!= (-> obj init-specs s5-0 field) (sp-field-id spt-end)) + (let* ((v1-1 (-> obj init-specs s5-0)) + (t9-1 format) + (a0-3 #t) + (a1-1 "~T~S : ~F / #x~X / ~D~%") + (a2-1 (-> v1-1 field)) + ) + (t9-1 + a0-3 + a1-1 + (cond + ((= a2-1 (sp-field-id spt-end)) + "spt-end" + ) + ((= a2-1 (sp-field-id spt-scalevel)) + "spt-scalevel" + ) + ((= a2-1 (sp-field-id spt-scale)) + "spt-scale" + ) + ((= a2-1 (sp-field-id launch-fields-end)) + "launch-fields-end" + ) + ((= a2-1 (sp-field-id spt-rotate-y)) + "spt-rotate-y" + ) + ((= a2-1 (sp-field-id spt-conerot-radius)) + "spt-conerot-radius" + ) + ((= a2-1 (sp-field-id spt-conerot-w)) + "spt-conerot-w" + ) + ((= a2-1 (sp-field-id spt-conerot-z)) + "spt-conerot-z" + ) + ((= a2-1 (sp-field-id spt-conerot-y)) + "spt-conerot-y" + ) + ((= a2-1 (sp-field-id spt-conerot-x)) + "spt-conerot-x" + ) + ((= a2-1 (sp-field-id spt-launchrot-w)) + "spt-launchrot-w" + ) + ((= a2-1 (sp-field-id spt-launchrot-z)) + "spt-launchrot-z" + ) + ((= a2-1 (sp-field-id spt-launchrot-y)) + "spt-launchrot-y" + ) + ((= a2-1 (sp-field-id spt-launchrot-x)) + "spt-launchrot-x" + ) + ((= a2-1 (sp-field-id launch-fields-start)) + "launch-fields-start" + ) + ((= a2-1 (sp-field-id cpu-fields-end)) + "cpu-fields-end" + ) + ((= a2-1 (sp-field-id spt-next-launcher)) + "spt-next-launcher" + ) + ((= a2-1 (sp-field-id spt-next-time)) + "spt-next-time" + ) + ((= a2-1 (sp-field-id spt-func)) + "spt-func" + ) + ((= a2-1 (sp-field-id spt-userdata)) + "spt-userdata" + ) + ((= a2-1 (sp-field-id spt-flags)) + "spt-flags" + ) + ((= a2-1 (sp-field-id spt-timer)) + "spt-timer" + ) + ((= a2-1 (sp-field-id spt-friction)) + "spt-friction" + ) + ((= a2-1 (sp-field-id spt-quad-w)) + "spt-quad-w" + ) + ((= a2-1 (sp-field-id spt-quat-z)) + "spt-quat-z" + ) + ((= a2-1 (sp-field-id spt-quat-y)) + "spt-quat-y" + ) + ((= a2-1 (sp-field-id spt-quat-x)) + "spt-quat-x" + ) + ((= a2-1 (sp-field-id spt-dummy)) + "spt-dummy" + ) + ((= a2-1 (sp-field-id spt-accel-z)) + "spt-accel-z" + ) + ((= a2-1 (sp-field-id spt-accel-y)) + "spt-accel-y" + ) + ((= a2-1 (sp-field-id spt-accel-x)) + "spt-accel-x" + ) + ((= a2-1 (sp-field-id spt-fade-a)) + "spt-fade-a" + ) + ((= a2-1 (sp-field-id spt-fade-b)) + "spt-fade-b" + ) + ((= a2-1 (sp-field-id spt-fade-g)) + "spt-fade-g" + ) + ((= a2-1 (sp-field-id spt-fade-r)) + "spt-fade-r" + ) + ((= a2-1 (sp-field-id spt-scalevel-y)) + "spt-scalevel-y" + ) + ((= a2-1 (sp-field-id spt-rotvel-z)) + "spt-rotvel-z" + ) + ((= a2-1 (sp-field-id spt-rotvel-y)) + "spt-rotvel-y" + ) + ((= a2-1 (sp-field-id spt-rotvel-x)) + "spt-rotvel-x" + ) + ((= a2-1 (sp-field-id spt-scalevel-x)) + "spt-scalevel-x" + ) + ((= a2-1 (sp-field-id spt-vel-z)) + "spt-vel-z" + ) + ((= a2-1 (sp-field-id spt-vel-y)) + "spt-vel-y" + ) + ((= a2-1 (sp-field-id spt-vel-x)) + "spt-vel-x" + ) + ((= a2-1 (sp-field-id spt-omega)) + "spt-omega" + ) + ((= a2-1 (sp-field-id cpu-fields-start)) + "cpu-fields-start" + ) + ((= a2-1 (sp-field-id sprite-fields-end)) + "sprite-fields-end" + ) + ((= a2-1 (sp-field-id spt-a)) + "spt-a" + ) + ((= a2-1 (sp-field-id spt-b)) + "spt-b" + ) + ((= a2-1 (sp-field-id spt-g)) + "spt-g" + ) + ((= a2-1 (sp-field-id spt-r)) + "spt-r" + ) + ((= a2-1 (sp-field-id spt-scale-y)) + "spt-scale-y" + ) + ((= a2-1 (sp-field-id spt-rot-z)) + "spt-rot-z" + ) + ((= a2-1 (sp-field-id spt-rot-y)) + "spt-rot-y" + ) + ((= a2-1 (sp-field-id spt-rot-x)) + "spt-rot-x" + ) + ((= a2-1 (sp-field-id spt-scale-x)) + "spt-scale-x" + ) + ((= a2-1 (sp-field-id spt-z)) + "spt-z" + ) + ((= a2-1 (sp-field-id spt-y)) + "spt-y" + ) + ((= a2-1 (sp-field-id spt-x)) + "spt-x" + ) + ((= a2-1 (sp-field-id sprite-fields-start)) + "sprite-fields-start" + ) + ((= a2-1 (sp-field-id misc-fields-end)) + "misc-fields-end" + ) + ((= a2-1 (sp-field-id spt-sound)) + "spt-sound" + ) + ((= a2-1 (sp-field-id spt-num)) + "spt-num" + ) + ((= a2-1 (sp-field-id spt-joint/refpoint)) + "spt-joint/refpoint" + ) + ((= a2-1 (sp-field-id spt-birth-func)) + "spt-birth-func" + ) + ((= a2-1 (sp-field-id spt-anim-speed)) + "spt-anim-speed" + ) + ((= a2-1 (sp-field-id spt-anim)) + "spt-anim" + ) + ((= a2-1 (sp-field-id spt-texture)) + "spt-texture" + ) + ((= a2-1 (sp-field-id misc-fields-start)) + "misc-fields-start" + ) + (else + "*unknown*" + ) + ) + (-> v1-1 initial-valuef) + (-> v1-1 initial-valuef) + (-> v1-1 initial-valuef) + ) + ) + (+! s5-0 1) + ) + ) + (the-as sparticle-launcher 0) + ) + +;; definition for symbol *part-id-table*, type (array sparticle-launcher) +(define + *part-id-table* + (the-as (array sparticle-launcher) (new 'global 'boxed-array sparticle-launcher 3584)) + ) + +;; definition for symbol *part-group-id-table*, type (array sparticle-launch-group) +(define + *part-group-id-table* + (the-as (array sparticle-launch-group) (new 'global 'boxed-array sparticle-launch-group 1024)) + ) + +;; definition for function lookup-part-group-by-name +;; INFO: Return type mismatch sparticle-launch-group vs basic. +(defun lookup-part-group-by-name ((arg0 string)) + (let* ((s5-0 *part-group-id-table*) + (s4-0 (-> s5-0 length)) + ) + (dotimes (s3-0 s4-0) + (let ((s2-0 (-> s5-0 s3-0))) + (if (and (nonzero? s2-0) (string= arg0 (-> s2-0 name))) + (return (the-as basic s2-0)) + ) + ) + ) + ) + (the-as sparticle-launch-group #f) + ) + +;; definition for function lookup-part-group-pointer-by-name +(defun lookup-part-group-pointer-by-name ((arg0 string)) + (let* ((s4-0 *part-group-id-table*) + (s3-0 (-> s4-0 length)) + ) + (dotimes (gp-0 s3-0) + (let ((v1-2 (-> s4-0 gp-0))) + (if (and (nonzero? v1-2) (string= arg0 (-> v1-2 name))) + (return (&+ (-> s4-0 data) (* gp-0 4))) + ) + ) + ) + ) + (the-as (pointer sparticle-launch-group) #f) + ) + +;; definition for function part-group-pointer? +(defun part-group-pointer? ((arg0 pointer)) + (let ((v1-0 *part-group-id-table*)) + (and (>= (the-as int arg0) (the-as int (-> v1-0 data))) (< (the-as int arg0) (the-as int (&-> v1-0 1024)))) + ) + ) + +;; definition for function unlink-part-group-by-heap +(defun unlink-part-group-by-heap ((arg0 kheap)) + (let* ((v1-0 *part-group-id-table*) + (a2-0 (-> v1-0 length)) + (a1-0 (-> arg0 base)) + (a0-1 (-> arg0 top-base)) + ) + (while (nonzero? a2-0) + (+! a2-0 -1) + (let ((a3-2 (-> v1-0 a2-0))) + (when (and (>= (the-as int a3-2) (the-as int a1-0)) (< (the-as int a3-2) (the-as int a0-1))) + (set! (-> v1-0 a2-0) (the-as sparticle-launch-group 0)) + 0 + ) + ) + ) + ) + 0 + ) + +;; definition for function sp-init-fields! +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition of type sp-queued-launch-particles +(deftype sp-queued-launch-particles (structure) + ((sp-system sparticle-system :offset-assert 0) + (sp-launcher sparticle-launcher :offset-assert 4) + (pos vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +;; definition for method 3 of type sp-queued-launch-particles +(defmethod inspect sp-queued-launch-particles ((obj sp-queued-launch-particles)) + (format #t "[~8x] ~A~%" obj 'sp-queued-launch-particles) + (format #t "~Tsp-system: ~A~%" (-> obj sp-system)) + (format #t "~Tsp-launcher: ~A~%" (-> obj sp-launcher)) + (format #t "~Tpos: #~%" (-> obj pos)) + obj + ) + +;; definition of type sp-launch-queue +(deftype sp-launch-queue (basic) + ((in-use int32 :offset-assert 4) + (queue sp-queued-launch-particles 32 :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x410 + :flag-assert #x900000410 + ) + +;; definition for method 3 of type sp-launch-queue +(defmethod inspect sp-launch-queue ((obj sp-launch-queue)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tin-use: ~D~%" (-> obj in-use)) + (format #t "~Tqueue[32] @ #x~X~%" (-> obj queue)) + obj + ) + +;; definition for symbol *sp-launcher-lock*, type symbol +(define *sp-launcher-lock* #f) + +;; definition for symbol *sp-launch-queue*, type sp-launch-queue +(define *sp-launch-queue* (new 'global 'sp-launch-queue)) + +;; definition for symbol *sp-launcher-enable*, type symbol +(define *sp-launcher-enable* #t) + +;; definition for function particle-setup-adgif +;; INFO: Return type mismatch int vs none. +(defun particle-setup-adgif ((arg0 adgif-shader) (arg1 texture-id)) + (let ((a1-1 (lookup-texture-by-id arg1))) + (set! (-> arg0 tex1) (new 'static 'gs-tex1 :mmag #x1 :mmin #x1)) + (set! (-> arg0 tex0 tfx) 0) + (if a1-1 + (adgif-shader<-texture! arg0 a1-1) + ) + ) + (set! (-> arg0 prims 1) (gs-reg64 tex0-1)) + (set! (-> arg0 prims 3) (gs-reg64 tex1-1)) + (set! (-> arg0 prims 5) (gs-reg64 miptbp1-1)) + (set! (-> arg0 clamp-reg) (gs-reg64 zbuf-1)) + (set! (-> arg0 prims 9) (gs-reg64 alpha-1)) + (set! (-> arg0 alpha) (new 'static 'gs-miptbp :tbp1 #x44)) + (set! (-> arg0 clamp) (new 'static 'gs-clamp :minu #x1c :minv #x101)) + 0 + (none) + ) + +;; definition of type particle-adgif-cache +(deftype particle-adgif-cache (basic) + ((used int32 :offset-assert 4) + (last uint16 :offset-assert 8) + (lastgif adgif-shader :offset-assert 12) + (tidhash uint16 80 :offset-assert 16) + (spadgif adgif-shader 80 :inline :offset-assert 176) + ) + :method-count-assert 9 + :size-assert #x19b0 + :flag-assert #x9000019b0 + ) + +;; definition for method 3 of type particle-adgif-cache +(defmethod inspect particle-adgif-cache ((obj particle-adgif-cache)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Tused: ~D~%" (-> obj used)) + (format #t "~Tlast: ~D~%" (-> obj last)) + (format #t "~Tlastgif: #~%" (-> obj lastgif)) + (format #t "~Ttidhash[80] @ #x~X~%" (-> obj tidhash)) + (format #t "~Tspadgif[80] @ #x~X~%" (-> obj spadgif)) + obj + ) + +;; definition for symbol *particle-adgif-cache*, type particle-adgif-cache +(define *particle-adgif-cache* (new 'global 'particle-adgif-cache)) + +;; failed to figure out what this is: +(set! (-> *particle-adgif-cache* used) 0) + +;; definition for function particle-adgif +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition for function sp-queue-launch +;; Used lq/sq +(defun sp-queue-launch ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector)) + (let ((v1-0 *sp-launch-queue*)) + (when (= (-> v1-0 in-use) 32) + (format 0 "ERROR: sp-launch-particles called during processing, and queue is full~%") + (return 0) + ) + (let ((a3-5 (-> v1-0 queue (-> v1-0 in-use)))) + (set! (-> a3-5 sp-system) arg0) + (set! (-> a3-5 sp-launcher) arg1) + (set! (-> a3-5 pos quad) (-> arg2 quad)) + ) + (let ((v0-1 (+ (-> v1-0 in-use) 1))) + (set! (-> v1-0 in-use) v0-1) + v0-1 + ) + ) + ) + +;; definition for function sp-adjust-launch +;; INFO: Return type mismatch int vs none. +(defun sp-adjust-launch ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 (inline-array sp-field-init-spec))) + (let ((s5-0 (new 'stack-no-clear 'sparticle-launchinfo))) + (let ((s2-0 (new 'stack-no-clear 'matrix)) + (s3-0 (new 'stack-no-clear 'vector)) + ) + (sp-init-fields! + (-> s5-0 launchrot) + arg2 + (sp-field-id launch-fields-start) + (sp-field-id launch-fields-end) + #t + ) + (matrix-rotate-xyz! s2-0 (-> s5-0 launchrot)) + (vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0) + (matrix-rotate-xyz! s2-0 (-> s5-0 conerot)) + (vector3s-matrix*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s2-0) + (if (logtest? (sp-cpuinfo-flag launch-along-z) (-> arg1 flags)) + (set-vector! s3-0 0.0 0.0 (-> s5-0 coneradius) 1.0) + (set-vector! s3-0 0.0 (-> s5-0 coneradius) 0.0 1.0) + ) + (vector-matrix*! s3-0 s3-0 s2-0) + (+! (-> arg0 launchrot x) (-> s3-0 x)) + (+! (-> arg0 launchrot y) (-> s3-0 y)) + (+! (-> arg0 launchrot z) (-> s3-0 z)) + ) + (when (!= (-> s5-0 rotate-y) 0.0) + (let ((s3-1 (new 'stack-no-clear 'matrix))) + (matrix-rotate-y! s3-1 (-> s5-0 rotate-y)) + (vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s3-1) + (vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s3-1) + (if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags))) + (vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s3-1) + ) + ) + (if (logtest? (sp-cpuinfo-flag set-conerot) (-> arg1 flags)) + (set! (-> arg0 conerot y) (+ 16384.0 (-> s5-0 rotate-y))) + ) + ) + ) + 0 + (none) + ) + +;; definition for function sp-euler-convert +;; INFO: Return type mismatch int vs none. +(defun sp-euler-convert ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo)) + (local-vars (v1-1 float) (v1-2 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((a1-1 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'quaternion)) + ) + (set-vector! a1-1 (-> arg0 conerot x) (-> arg0 conerot y) (-> arg0 conerot z) 1.0) + (quaternion-zxy! s5-0 a1-1) + (cond + ((< (-> s5-0 w) 0.0) + (.lvf vf1 (&-> arg0 conerot quad)) + (.lvf vf2 (&-> s5-0 vec quad)) + (.sub.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> arg0 conerot quad) vf1) + (.mov v1-1 vf1) + ) + (else + (.lvf vf1 (&-> arg0 conerot quad)) + (.lvf vf2 (&-> s5-0 vec quad)) + (.add.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> arg0 conerot quad) vf1) + (.mov v1-2 vf1) + ) + ) + ) + (cond + (*sp-60-hz* + (set! (-> arg1 rot-syvel x) (* 5.0 (-> arg1 rot-syvel x))) + (set! (-> arg1 rot-syvel y) (* 5.0 (-> arg1 rot-syvel y))) + (set! (-> arg1 rot-syvel z) (* 5.0 (-> arg1 rot-syvel z))) + ) + (else + (set! (-> arg1 rot-syvel x) (* 6.0 (-> arg1 rot-syvel x))) + (set! (-> arg1 rot-syvel y) (* 6.0 (-> arg1 rot-syvel y))) + (set! (-> arg1 rot-syvel z) (* 6.0 (-> arg1 rot-syvel z))) + ) + ) + (quaternion-zxy! (-> arg1 rotvel3d) (-> arg1 rot-syvel)) + 0 + (none) + ) + ) + +;; definition for function sp-rotate-system +;; INFO: Return type mismatch int vs none. +(defun sp-rotate-system ((arg0 sparticle-launchinfo) (arg1 sparticle-cpuinfo) (arg2 transformq)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (let ((a1-1 (new 'stack-no-clear 'quaternion))) + (let* ((v1-0 a1-1) + (a0-1 arg2) + (f0-0 (-> a0-1 quat x)) + (f1-0 (-> a0-1 quat y)) + (f3-0 (-> a0-1 quat z)) + ) + (set! (-> v1-0 x) f0-0) + (set! (-> v1-0 y) f1-0) + (set! (-> v1-0 z) f3-0) + (set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0)))) + ) + (quaternion->matrix s5-0 a1-1) + ) + (vector3s-rotate*! (the-as vector3s (-> arg0 launchrot)) (the-as vector3s (-> arg0 launchrot)) s5-0) + (vector3s-rotate*! (the-as vector3s (-> arg1 vel-sxvel)) (the-as vector3s (-> arg1 vel-sxvel)) s5-0) + (if (zero? (logand (sp-cpuinfo-flag use-global-acc) (-> arg1 flags))) + (vector3s-rotate*! (the-as vector3s (-> arg1 acc)) (the-as vector3s (-> arg1 acc)) s5-0) + ) + ) + 0 + (none) + ) + +;; definition for function sp-launch-particles-var +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition for symbol *death-adgif*, type adgif-shader +(define *death-adgif* (the-as adgif-shader #f)) + +;; definition for function sp-launch-particles-death +;; INFO: Return type mismatch int vs none. +;; WARN: Expression building failed: Function sp-launch-particles-death has a return type of none, but the expression builder found a return statement. +;; Used lq/sq +(defun sp-launch-particles-death ((arg0 sparticle-system) (arg1 sparticle-launcher) (arg2 vector)) + (local-vars (v1-25 float) (v1-27 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf30 :class vf) + (vf31 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (.lvf vf30 (&-> arg2 quad)) + (let ((v1-0 #x437f0000)) + (.mov vf31 v1-0) + ) + (let ((s5-0 (new 'stack-no-clear 'sprite-vec-data-2d)) + (gp-0 (sp-get-particle arg0 0 (the-as sparticle-launch-state #f))) + ) + (if (not gp-0) + (return 0) + ) + (let* ((a1-2 (-> arg1 init-specs 0)) + (a1-3 + (sp-init-fields! + (&-> s5-0 x) + (the-as (inline-array sp-field-init-spec) a1-2) + (sp-field-id sprite-fields-start) + (sp-field-id sprite-fields-end) + #t + ) + ) + ) + (sp-init-fields! + (&-> gp-0 omega) + (the-as (inline-array sp-field-init-spec) a1-3) + (sp-field-id cpu-fields-start) + (sp-field-id cpu-fields-end) + #t + ) + ) + (set! (-> s5-0 matrix) 0) + (set! (-> s5-0 rot) (the float (sar (shl (the int (-> s5-0 rot)) 48) 48))) + (.lvf vf4 (&-> s5-0 color quad)) + (.lvf vf5 (&-> s5-0 x-y-z-sx quad)) + (.min.x.vf vf4 vf4 vf31 :mask #b111) + (.add.vf vf5 vf5 vf30 :mask #b111) + (.svf (&-> s5-0 color quad) vf4) + (.svf (&-> s5-0 x-y-z-sx quad) vf5) + (when (not *death-adgif*) + (set! *death-adgif* (new 'static 'adgif-shader)) + (particle-adgif *death-adgif* (new 'static 'texture-id :index #x18 :page #x2)) + (set! (-> *death-adgif* alpha) (new 'static 'gs-miptbp :tbp1 #x48)) + ) + (let ((v1-14 (-> *death-adgif* quad 0 quad))) + (set! (-> gp-0 adgif quad 0 quad) v1-14) + ) + (let ((v1-16 (-> *death-adgif* quad 1 quad))) + (set! (-> gp-0 adgif quad 1 quad) v1-16) + ) + (let ((v1-18 (-> *death-adgif* quad 2 quad))) + (set! (-> gp-0 adgif quad 2 quad) v1-18) + ) + (let ((v1-20 (-> *death-adgif* quad 3 quad))) + (set! (-> gp-0 adgif quad 3 quad) v1-20) + ) + (let ((v1-22 (-> *death-adgif* quad 4 quad))) + (set! (-> gp-0 adgif quad 4 quad) v1-22) + ) + (.lvf vf4 (&-> (-> *time-of-day-context* current-prt-color) quad)) + (.lvf vf5 (&-> s5-0 color quad)) + (.lvf vf6 (&-> gp-0 fade quad)) + (.mul.vf vf5 vf5 vf4 :mask #b111) + (.mul.vf vf6 vf6 vf4 :mask #b111) + (.svf (&-> s5-0 color quad) vf5) + (.svf (&-> gp-0 fade quad) vf6) + (.mov v1-25 vf6) + (set! (-> gp-0 key) (the-as sparticle-launch-control 0)) + (set! (-> gp-0 binding) #f) + (let ((v1-26 (-> gp-0 sprite))) + (.lvf vf1 (&-> s5-0 x-y-z-sx quad)) + (.lvf vf2 (&-> s5-0 flag-rot-sy quad)) + (.lvf vf3 (&-> s5-0 color quad)) + (.svf (&-> v1-26 x-y-z-sx quad) vf1) + (.svf (&-> v1-26 flag-rot-sy quad) vf2) + (.sub.w.vf vf3 vf0 vf0 :mask #b1000) + (.svf (&-> v1-26 color quad) vf3) + ) + (.mov v1-27 vf3) + (logior! (-> gp-0 flags) (sp-cpuinfo-flag ready-to-launch)) + (set! (-> gp-0 cache-alpha) (-> s5-0 a)) + ) + 0 + (none) + ) + ) + +;; definition for function sp-clear-queue +;; INFO: Return type mismatch int vs none. +(defun sp-clear-queue () + (let ((gp-0 *sp-launch-queue*)) + (when (> (-> gp-0 in-use) 0) + (dotimes (s5-0 (-> gp-0 in-use)) + (let ((v1-4 (-> gp-0 queue s5-0))) + (sp-launch-particles-var + (-> v1-4 sp-system) + (-> v1-4 sp-launcher) + (-> v1-4 pos) + (the-as sparticle-launch-state #f) + (the-as sparticle-launch-control #f) + 1.0 + ) + ) + ) + (set! (-> gp-0 in-use) 0) + 0 + ) + ) + 0 + (none) + ) + +;; definition for function sp-relaunch-setup-fields +;; INFO: Return type mismatch int vs none. +(defun sp-relaunch-setup-fields ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d)) + (let ((a1-1 (-> arg1 init-specs 0)) + (s4-0 (logand (-> arg2 flags) (sp-cpuinfo-flag level0 level1))) + ) + (set! (-> arg2 next-launcher) (the-as basic 0)) + (cond + ((and (logtest? (-> arg2 flags) (sp-cpuinfo-flag bit12)) + (zero? (logand (-> arg2 flags) (sp-cpuinfo-flag aux-list))) + ) + (let ((f20-0 (-> arg3 r-g-b-a x)) + (f22-0 (-> arg3 r-g-b-a y)) + (f24-0 (-> arg3 r-g-b-a z)) + (f26-0 (-> arg2 fade x)) + (f28-0 (-> arg2 fade y)) + (f30-0 (-> arg2 fade z)) + ) + (set! (-> arg3 r-g-b-a x) 99999.0) + (set! (-> arg3 r-g-b-a y) 99999.0) + (set! (-> arg3 r-g-b-a z) 99999.0) + (set! (-> arg2 fade x) 99999.0) + (set! (-> arg2 fade y) 99999.0) + (set! (-> arg2 fade z) 99999.0) + (let ((a1-2 + (sp-init-fields! + (-> arg3 x-y-z-sx) + (the-as (inline-array sp-field-init-spec) a1-1) + (sp-field-id sprite-fields-start) + (sp-field-id sprite-fields-end) + #f + ) + ) + ) + (sp-init-fields! + (&-> arg2 omega) + (the-as (inline-array sp-field-init-spec) a1-2) + (sp-field-id cpu-fields-start) + (sp-field-id cpu-fields-end) + #f + ) + ) + (logior! (-> arg2 flags) s4-0) + (if (logtest? (-> arg2 flags) (sp-cpuinfo-flag level1)) + (-> *level* level1) + (-> *level* level0) + ) + (let ((v1-16 (-> *time-of-day-context* current-prt-color))) + (if (= (-> arg3 r-g-b-a x) 99999.0) + (set! (-> arg3 r-g-b-a x) f20-0) + (set! (-> arg3 r-g-b-a x) (* (-> arg3 r-g-b-a x) (-> v1-16 x))) + ) + (if (= (-> arg3 r-g-b-a y) 99999.0) + (set! (-> arg3 r-g-b-a y) f22-0) + (set! (-> arg3 r-g-b-a y) (* (-> arg3 r-g-b-a y) (-> v1-16 y))) + ) + (if (= (-> arg3 r-g-b-a z) 99999.0) + (set! (-> arg3 r-g-b-a z) f24-0) + (set! (-> arg3 r-g-b-a z) (* (-> arg3 r-g-b-a z) (-> v1-16 z))) + ) + (if (= (-> arg2 fade x) 99999.0) + (set! (-> arg2 fade x) f26-0) + (set! (-> arg2 fade x) (* (-> arg2 fade x) (-> v1-16 x))) + ) + (if (= (-> arg2 fade y) 99999.0) + (set! (-> arg2 fade y) f28-0) + (set! (-> arg2 fade y) (* (-> arg2 fade y) (-> v1-16 y))) + ) + (if (= (-> arg2 fade z) 99999.0) + (set! (-> arg2 fade z) f30-0) + (set! (-> arg2 fade z) (* (-> arg2 fade z) (-> v1-16 z))) + ) + ) + ) + ) + (else + (let ((a1-3 + (sp-init-fields! + (-> arg3 x-y-z-sx) + (the-as (inline-array sp-field-init-spec) a1-1) + (sp-field-id sprite-fields-start) + (sp-field-id sprite-fields-end) + #f + ) + ) + ) + (sp-init-fields! + (&-> arg2 omega) + (the-as (inline-array sp-field-init-spec) a1-3) + (sp-field-id cpu-fields-start) + (sp-field-id cpu-fields-end) + #f + ) + ) + ) + ) + ) + 0 + 0 + (none) + ) + +;; definition for function sp-relaunch-particle-2d +;; INFO: Return type mismatch int vs none. +(defun sp-relaunch-particle-2d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d)) + (sp-relaunch-setup-fields arg0 arg1 arg2 arg3) + (when (logtest? (-> arg2 flags) (sp-cpuinfo-flag aux-list)) + (set! (-> arg2 func) add-to-sprite-aux-list) + (set! (-> arg3 r-g-b-a w) 0.0) + (set! (-> arg2 fade w) 0.0) + (logclear! (-> arg2 flags) (sp-cpuinfo-flag bit2)) + ) + 0 + (none) + ) + +;; definition for function sp-relaunch-particle-3d +;; INFO: Return type mismatch int vs none. +(defun sp-relaunch-particle-3d ((arg0 object) (arg1 sparticle-launcher) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-3d)) + (local-vars (v1-9 float) (v1-10 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((s4-0 (new 'stack-no-clear 'quaternion))) + (let* ((v1-0 s4-0) + (a2-1 arg3) + (f0-0 (-> a2-1 qx-qy-qz-sy x)) + (f1-0 (-> a2-1 qx-qy-qz-sy y)) + (f3-0 (-> a2-1 qx-qy-qz-sy z)) + ) + (set! (-> v1-0 x) f0-0) + (set! (-> v1-0 y) f1-0) + (set! (-> v1-0 z) f3-0) + (set! (-> v1-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0)))) + ) + (set! (-> arg3 qx-qy-qz-sy x) 0.0) + (set! (-> arg3 qx-qy-qz-sy y) 0.0) + (set! (-> arg3 qx-qy-qz-sy z) 0.0) + (sp-relaunch-setup-fields arg0 arg1 arg2 arg3) + (let ((a1-1 (new 'stack-no-clear 'vector)) + (s3-0 (new 'stack-no-clear 'quaternion)) + ) + (set-vector! a1-1 (-> arg3 qx-qy-qz-sy x) (-> arg3 qx-qy-qz-sy y) (-> arg3 qx-qy-qz-sy z) 1.0) + (quaternion-zxy! s3-0 a1-1) + (cond + ((logtest? (sp-cpuinfo-flag left-multiply-quat) (-> arg2 flags)) + (quaternion*! s3-0 s4-0 s3-0) + ) + (else + (if (logtest? (sp-cpuinfo-flag right-multiply-quat) (-> arg2 flags)) + (quaternion*! s3-0 s3-0 s4-0) + ) + ) + ) + (cond + ((< (-> s3-0 w) 0.0) + (.lvf vf1 (&-> arg3 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s3-0 vec quad)) + (.sub.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> arg3 qx-qy-qz-sy quad) vf1) + (.mov v1-9 vf1) + ) + (else + (.lvf vf1 (&-> arg3 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s3-0 vec quad)) + (.add.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> arg3 qx-qy-qz-sy quad) vf1) + (.mov v1-10 vf1) + ) + ) + ) + ) + (cond + (*sp-60-hz* + (set! (-> arg2 rot-syvel x) (* 5.0 (-> arg2 rot-syvel x))) + (set! (-> arg2 rot-syvel y) (* 5.0 (-> arg2 rot-syvel y))) + (set! (-> arg2 rot-syvel z) (* 5.0 (-> arg2 rot-syvel z))) + ) + (else + (set! (-> arg2 rot-syvel x) (* 6.0 (-> arg2 rot-syvel x))) + (set! (-> arg2 rot-syvel y) (* 6.0 (-> arg2 rot-syvel y))) + (set! (-> arg2 rot-syvel z) (* 6.0 (-> arg2 rot-syvel z))) + ) + ) + (quaternion-zxy! (-> arg2 rotvel3d) (-> arg2 rot-syvel)) + 0 + (none) + ) + ) + +;; definition for method 9 of type sparticle-launch-control +;; INFO: Return type mismatch int vs none. +(defmethod initialize sparticle-launch-control ((obj sparticle-launch-control) (arg0 sparticle-launch-group) (arg1 process)) + (let ((s5-0 0)) + (set! (-> obj group) arg0) + (set! (-> obj proc) arg1) + (set! (-> obj local-clock) 0) + (set! (-> obj fade) 1.0) + (set! (-> obj matrix) 0) + (set! (-> obj last-spawn-frame) (+ (-> *display* real-actual-frame-counter) -2)) + (set! (-> obj last-spawn-time) 0) + (dotimes (s3-0 (-> arg0 length)) + (let* ((a0-2 (-> arg0 launcher s3-0)) + (a1-2 (-> *part-id-table* (-> a0-2 launcher))) + (v1-9 (-> obj data s5-0)) + ) + (when (nonzero? a1-2) + (set! (-> v1-9 group-item) a0-2) + (cond + ((= (-> a1-2 type) sparticle-launcher) + (set! (-> v1-9 accum) 0.0) + (set! (-> v1-9 spawn-time) (the-as uint (+ *particle-300hz-timer* -30000))) + (set! (-> v1-9 offset) (-> a0-2 offset)) + (set! (-> v1-9 randomize) (the-as uint 0)) + (cond + ((logtest? (-> a0-2 flags) (sp-group-item-flag start-dead)) + (logclear! (-> v1-9 flags) (sp-launch-state-flags launcher-active)) + (set! (-> v1-9 origin) #f) + (set! (-> v1-9 sprite3d) #f) + (set! (-> v1-9 sprite) #f) + ) + (else + (logior! (-> v1-9 flags) (sp-launch-state-flags launcher-active)) + (set! (-> v1-9 origin) (-> obj center)) + (set! (-> v1-9 sprite3d) #f) + (set! (-> v1-9 sprite) #f) + ) + ) + (+! s5-0 1) + ) + (else + (format 0 "initialize called with non-particle-launcher~%") + ) + ) + ) + ) + ) + (set! (-> obj length) s5-0) + ) + 0 + (none) + ) + +;; definition for method 9 of type sparticle-launch-group +;; INFO: Return type mismatch object vs sparticle-launch-control. +(defmethod create-launch-control sparticle-launch-group ((obj sparticle-launch-group) (arg0 process)) + (let ((gp-0 (the-as object (new 'process 'sparticle-launch-control (-> obj length))))) + (when (zero? (the-as sparticle-launch-control gp-0)) + (go process-drawable-art-error "memory") + (set! gp-0 0) + (goto cfg-4) + ) + (initialize (the-as sparticle-launch-control gp-0) obj arg0) + (label cfg-4) + (the-as sparticle-launch-control gp-0) + ) + ) + +;; definition for method 12 of type sparticle-launch-control +;; INFO: Return type mismatch int vs none. +(defmethod kill-and-free-particles sparticle-launch-control ((obj sparticle-launch-control)) + (countdown (v1-0 (-> obj length)) + (let ((a0-3 (-> obj data v1-0))) + (logclear! (-> a0-3 flags) (sp-launch-state-flags particles-active)) + ) + ) + (set! (-> obj local-clock) 0) + (set! (-> obj fade) 1.0) + (kill-all-particles-with-key obj) + (if (> (-> obj matrix) 0) + (sprite-release-user-hvdf (-> obj matrix)) + ) + 0 + (none) + ) + +;; definition for method 13 of type sparticle-launch-control +;; INFO: Return type mismatch int vs none. +(defmethod kill-particles sparticle-launch-control ((obj sparticle-launch-control)) + (kill-all-particles-with-key obj) + 0 + (none) + ) + +;; definition for method 10 of type sparticle-launch-control +(defmethod is-visible? sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector)) + (let* ((v1-0 (-> obj group)) + (f0-0 (-> v1-0 bounds w)) + ) + (cond + ((= f0-0 0.0) + #t + ) + ((nonzero? (-> obj matrix)) + #t + ) + (else + (let ((gp-1 (vector+! (new 'stack-no-clear 'vector) arg0 (the-as vector (-> v1-0 bounds))))) + (set! (-> gp-1 w) f0-0) + (if (and *display-actor-vis* (or (not *display-actor-anim*) (name= *display-actor-anim* (-> obj proc name)))) + (add-debug-sphere + *display-actor-vis* + (bucket-id debug-draw0) + gp-1 + (-> gp-1 w) + (new 'static 'rgba :g #xff :a #x80) + ) + ) + (sphere-in-view-frustum? (the-as sphere gp-1)) + ) + ) + ) + ) + ) + +;; definition for method 11 of type sparticle-launch-control +;; INFO: Return type mismatch int vs object. +;; Used lq/sq +(defmethod spawn sparticle-launch-control ((obj sparticle-launch-control) (arg0 vector)) + (set! (-> obj center quad) (-> arg0 quad)) + (if (not (or (is-visible? obj arg0) (logtest? (-> obj group flags) (sp-group-flag always-draw screen-space)))) + (return (the-as object 0)) + ) + (let ((s4-0 *particle-300hz-timer*) + (s5-0 (-> obj last-spawn-time)) + ) + (let ((v1-8 (-> *display* real-actual-frame-counter))) + (if (!= v1-8 (+ (-> obj last-spawn-frame) 1)) + (set! s5-0 (- s4-0 (logand (the-as int (-> *sp-frame-time* x)) 255))) + ) + ) + (set! (-> obj last-spawn-frame) (-> *display* real-actual-frame-counter)) + (set! (-> obj last-spawn-time) s4-0) + (when (logtest? (-> obj group flags) (sp-group-flag use-local-clock)) + (set! s5-0 (-> obj local-clock)) + (+! (-> obj local-clock) (logand (the-as int (-> *sp-frame-time* x)) 255)) + (set! s4-0 (-> obj local-clock)) + ) + (let ((f30-0 (vector-vector-distance arg0 (math-camera-pos))) + (s3-1 (ash 1 (if *time-of-day-proc* + (-> *time-of-day-proc* 0 hour) + 0 + ) + ) + ) + ) + (if (nonzero? (-> obj matrix)) + (set! f30-0 0.0) + ) + (let ((s2-1 (-> obj length))) + (while (begin (label cfg-79) (nonzero? s2-1)) + (+! s2-1 -1) + (let* ((a3-0 (-> obj data s2-1)) + (v1-29 (-> a3-0 group-item)) + (a1-4 (-> *part-id-table* (-> v1-29 launcher))) + ) + (when (and a1-4 (nonzero? a1-4) (logtest? (-> a3-0 flags) (sp-launch-state-flags launcher-active))) + (let ((f0-2 1.0)) + (if (!= (-> v1-29 falloff-to) 0.0) + (set! f0-2 (- 1.0 (/ f30-0 (-> v1-29 falloff-to)))) + ) + (let ((a0-26 sparticle-launcher)) + (b! (!= (-> a1-4 type) a0-26) cfg-78 :delay (nop!)) + ) + (b! (zero? (logand (-> v1-29 flags) (sp-group-item-flag launch-asap))) cfg-36 :delay (nop!)) + (when (zero? (logand (-> a3-0 flags) (sp-launch-state-flags particles-active))) + (set! (-> a3-0 spawn-time) (the-as uint s4-0)) + (logior! (-> a3-0 flags) (sp-launch-state-flags particles-active)) + (if (< 0.0 f0-2) + (sp-launch-particles-var + (if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d)) + *sp-particle-system-3d* + *sp-particle-system-2d* + ) + a1-4 + (-> a3-0 origin) + a3-0 + obj + f0-2 + ) + ) + ) + (b! #t cfg-77 :delay (nop!)) + (label cfg-36) + (when (logtest? s3-1 (-> v1-29 hour-mask)) + 0 + (goto cfg-77) + ) + (when (not (or (= (-> v1-29 fade-after) 0.0) (< f30-0 (-> v1-29 fade-after)))) + 0 + (b! #t cfg-77 :delay (nop!)) + (set! v1-29 (the-as sparticle-group-item 0)) + ) + (b! (nonzero? (-> v1-29 period)) cfg-50 :delay (empty-form)) + (let ((f0-4 (* 0.2 (the float (- s4-0 s5-0)) f0-2))) + (b! #t cfg-72 :delay (nop!)) + (label cfg-50) + (let ((a2-5 (mod (+ s5-0 (-> obj data s2-1 offset)) (the-as int (-> v1-29 period)))) + (a0-56 (mod (the-as uint (+ s4-0 (-> obj data s2-1 offset))) (-> v1-29 period))) + (t0-2 (-> v1-29 length)) + ) + (set! f0-4 (cond + ((and (< a2-5 (the-as int t0-2)) (< a0-56 t0-2)) + (* 0.2 (the float (- s4-0 s5-0)) f0-2) + ) + ((and (< a2-5 (the-as int t0-2)) (>= a0-56 t0-2)) + (* 0.2 (the float (- t0-2 (the-as uint a2-5))) f0-2) + ) + ((and (>= a2-5 (the-as int t0-2)) (< a0-56 t0-2)) + (* 0.2 (the float a0-56) f0-2) + ) + (else + (when (zero? (logand (-> v1-29 flags) (sp-group-item-flag bit1))) + 0 + (goto cfg-77) + ) + (when (< (the-as uint (- s4-0 (the-as int (-> obj data s2-1 spawn-time)))) (-> v1-29 period)) + 0 + (goto cfg-77) + ) + (set! (-> obj data s2-1 offset) (- (-> v1-29 period) a0-56)) + (* 0.2 (the float (- s4-0 s5-0)) f0-2) + ) + ) + ) + ) + (label cfg-72) + (set! (-> a3-0 spawn-time) (the-as uint s4-0)) + (logior! (-> a3-0 flags) (sp-launch-state-flags particles-active)) + (if (< 0.0 f0-4) + (sp-launch-particles-var + (if (logtest? (-> v1-29 flags) (sp-group-item-flag is-3d)) + *sp-particle-system-3d* + *sp-particle-system-2d* + ) + a1-4 + (-> a3-0 origin) + a3-0 + obj + f0-4 + ) + ) + ) + ) + (label cfg-77) + (b! #t cfg-79 :delay (nop!)) + (label cfg-78) + (format 0 "spawn called for non-sparticle-launcher~%") + ) + ) + ) + ) + ) + ) + 0 + ) + +;; definition for function sparticle-track-root +;; INFO: Return type mismatch int vs none. +(defun sparticle-track-root ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector)) + (let ((v1-3 (-> (the-as process-drawable (-> arg1 key proc)) root trans))) + (set! (-> arg2 x) (-> v1-3 x)) + (set! (-> arg2 y) (-> v1-3 y)) + (set! (-> arg2 z) (-> v1-3 z)) + ) + 0 + (none) + ) + +;; definition for function sparticle-track-root-prim +;; INFO: Return type mismatch int vs none. +(defun sparticle-track-root-prim ((arg0 object) (arg1 sparticle-cpuinfo) (arg2 vector)) + (let ((v1-4 (-> (the-as collide-shape (-> (the-as process-drawable (-> arg1 key proc)) root)) root-prim prim-core)) + ) + (set! (-> arg2 x) (-> v1-4 world-sphere x)) + (set! (-> arg2 y) (-> v1-4 world-sphere y)) + (set! (-> arg2 z) (-> v1-4 world-sphere z)) + ) + 0 + (none) + ) + +;; definition for function birth-func-copy-rot-color +;; INFO: Return type mismatch int vs none. +(defun birth-func-copy-rot-color ((arg0 sparticle-system) + (arg1 sparticle-cpuinfo) + (arg2 sprite-vec-data-3d) + (arg3 sparticle-launcher) + (arg4 sparticle-launch-state) + ) + (local-vars (v1-4 float) (v1-5 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((s5-0 (-> arg4 sprite))) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (let* ((v1-0 arg2) + (f0-0 (-> v1-0 qx-qy-qz-sy x)) + (f1-0 (-> v1-0 qx-qy-qz-sy y)) + (f3-0 (-> v1-0 qx-qy-qz-sy z)) + ) + (set! (-> s4-0 x) f0-0) + (set! (-> s4-0 y) f1-0) + (set! (-> s4-0 z) f3-0) + (set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0)))) + ) + (quaternion-rotate-y! (the-as quaternion s4-0) (the-as quaternion s4-0) (-> s5-0 sprite rot)) + (let ((v1-3 arg2)) + (cond + ((< (-> s4-0 w) 0.0) + (.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s4-0 quad)) + (.sub.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> v1-3 qx-qy-qz-sy quad) vf1) + (.mov v1-4 vf1) + ) + (else + (.lvf vf1 (&-> v1-3 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s4-0 quad)) + (.add.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> v1-3 qx-qy-qz-sy quad) vf1) + (.mov v1-5 vf1) + ) + ) + ) + ) + (set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r)) + (set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g)) + (set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b)) + ) + 0 + (none) + ) + ) + +;; definition for symbol *global-toggle*, type int +(define *global-toggle* 0) + +;; definition for function birth-func-copy2-rot-color +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defun birth-func-copy2-rot-color ((arg0 sparticle-system) + (arg1 sparticle-cpuinfo) + (arg2 sprite-vec-data-3d) + (arg3 sparticle-launcher) + (arg4 sparticle-launch-state) + ) + (local-vars (v1-15 float) (v1-16 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((s5-0 (-> arg4 sprite))) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (let* ((v1-0 arg2) + (f0-0 (-> v1-0 qx-qy-qz-sy x)) + (f1-0 (-> v1-0 qx-qy-qz-sy y)) + (f3-0 (-> v1-0 qx-qy-qz-sy z)) + ) + (set! (-> s4-0 x) f0-0) + (set! (-> s4-0 y) f1-0) + (set! (-> s4-0 z) f3-0) + (set! (-> s4-0 w) (sqrtf (- (- (- 1.0 (* f3-0 f3-0)) (* f1-0 f1-0)) (* f0-0 f0-0)))) + ) + (let ((a1-1 (new-stack-vector0))) + (set! (-> a1-1 y) (-> s5-0 sprite rot)) + (set! (-> a1-1 z) (if (logtest? *global-toggle* 1) + (the float (sar (shl (the int (- 16384.0 (-> s5-0 sprite sx))) 48) 48)) + (the float (sar (shl (the int (+ 16384.0 (-> s5-0 sprite sx))) 48) 48)) + ) + ) + (quaternion-zxy! (the-as quaternion s4-0) a1-1) + ) + (let ((v1-14 arg2)) + (cond + ((< (-> s4-0 w) 0.0) + (.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s4-0 quad)) + (.sub.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> v1-14 qx-qy-qz-sy quad) vf1) + (.mov v1-15 vf1) + ) + (else + (.lvf vf1 (&-> v1-14 qx-qy-qz-sy quad)) + (.lvf vf2 (&-> s4-0 quad)) + (.add.vf vf1 vf0 vf2 :mask #b111) + (.svf (&-> v1-14 qx-qy-qz-sy quad) vf1) + (.mov v1-16 vf1) + ) + ) + ) + ) + (set! (-> arg2 r-g-b-a x) (-> s5-0 sprite r)) + (set! (-> arg2 r-g-b-a y) (-> s5-0 sprite g)) + (set! (-> arg2 r-g-b-a z) (-> s5-0 sprite b)) + ) + (set! *global-toggle* (+ *global-toggle* 1)) + 0 + (none) + ) + ) + +;; definition for function birth-func-copy-omega-to-z +;; INFO: Return type mismatch int vs none. +(defun birth-func-copy-omega-to-z ((arg0 sparticle-system) + (arg1 sparticle-cpuinfo) + (arg2 sprite-vec-data-3d) + (arg3 sparticle-launcher) + (arg4 sparticle-launch-state) + ) + (set! (-> arg2 qx-qy-qz-sy z) (+ -16384.0 (-> arg1 omega))) + (set! (-> arg1 next-time) (-> arg4 sprite next-time)) + (set! (-> arg2 x-y-z-sx w) (* 163.85638 (the float (-> arg4 sprite next-time)))) + 0 + (none) + ) + +;; definition for function birth-func-random-next-time +;; INFO: Return type mismatch int vs none. +(defun birth-func-random-next-time ((arg0 sparticle-system) + (arg1 sparticle-cpuinfo) + (arg2 sprite-vec-data-3d) + (arg3 sparticle-launcher) + (arg4 sparticle-launch-state) + ) + (set! (-> arg1 next-time) (the-as uint (the int (rand-vu-float-range 0.0 (-> arg1 user-float))))) + 0 + (none) + ) + + + + diff --git a/test/decompiler/reference/engine/sparticle/sparticle_REF.gc b/test/decompiler/reference/engine/sparticle/sparticle_REF.gc new file mode 100644 index 0000000000..b809aeddf9 --- /dev/null +++ b/test/decompiler/reference/engine/sparticle/sparticle_REF.gc @@ -0,0 +1,741 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for method 2 of type sparticle-cpuinfo +;; INFO: Return type mismatch object vs sparticle-cpuinfo. +(defmethod print sparticle-cpuinfo ((obj sparticle-cpuinfo)) + (format #t "~%") + (dotimes (s5-0 16) + (format #t "~D:~F~%" s5-0 (the-as float (-> obj data s5-0))) + ) + (format #t "TIMER:~D~%" (-> obj timer)) + (the-as sparticle-cpuinfo (format #t "FLAGS:~X~%" (-> obj flags))) + ) + +;; definition for function sp-particle-copy! +;; INFO: Return type mismatch basic vs none. +;; Used lq/sq +(defun sp-particle-copy! ((arg0 sparticle-cpuinfo) (arg1 sparticle-cpuinfo)) + (let ((v1-1 (-> arg1 sprite x-y-z-sx quad))) + (set! (-> arg0 sprite x-y-z-sx quad) v1-1) + ) + (let ((v1-3 (-> arg1 sprite flag-rot-sy quad))) + (set! (-> arg0 sprite flag-rot-sy quad) v1-3) + ) + (let ((v1-5 (-> arg1 sprite color quad))) + (set! (-> arg0 sprite color quad) v1-5) + ) + (dotimes (v1-6 10) + (set! (-> arg0 adgif prims v1-6) (-> arg1 adgif prims v1-6)) + ) + (set! (-> arg0 vel-sxvel quad) (-> arg1 vel-sxvel quad)) + (set! (-> arg0 rot-syvel quad) (-> arg1 rot-syvel quad)) + (set! (-> arg0 fade quad) (-> arg1 fade quad)) + (set! (-> arg0 acc quad) (-> arg1 acc quad)) + (set! (-> arg0 friction) (-> arg1 friction)) + (set! (-> arg0 timer) (-> arg1 timer)) + (set! (-> arg0 flags) (-> arg1 flags)) + (set! (-> arg0 user-float) (-> arg1 user-float)) + (set! (-> arg0 func) (-> arg1 func)) + (none) + ) + +;; definition for method 0 of type sparticle-system +(defmethod new sparticle-system ((allocation symbol) + (type-to-make type) + (arg0 int) + (arg1 int) + (arg2 symbol) + (arg3 pointer) + (arg4 (inline-array adgif-shader)) + ) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (let* ((v1-3 (/ (+ arg0 63) 64)) + (a0-2 (/ (+ arg1 63) 64)) + (a1-2 (* v1-3 64)) + (a2-2 (* a0-2 64)) + (s2-1 (+ v1-3 a0-2)) + (s5-1 (+ a1-2 a2-2)) + ) + (set! (-> gp-0 blocks 0) v1-3) + (set! (-> gp-0 length 0) a1-2) + (set! (-> gp-0 num-alloc 0) 0) + (set! (-> gp-0 blocks 1) a0-2) + (set! (-> gp-0 length 1) a2-2) + (set! (-> gp-0 num-alloc 1) 0) + (set! (-> gp-0 is-3d) arg2) + (set! (-> gp-0 alloc-table) (the-as (pointer uint64) (malloc 'global (* s2-1 8)))) + (set! (-> gp-0 cpuinfo-table) (the-as (inline-array sparticle-cpuinfo) (malloc 'global (* 144 s5-1)))) + (set! (-> gp-0 vecdata-table) arg3) + (set! (-> gp-0 adgifdata-table) arg4) + (dotimes (v1-5 s2-1) + (set! (-> gp-0 alloc-table v1-5) (the-as uint -1)) + ) + (dotimes (s4-1 s5-1) + (set! (-> gp-0 cpuinfo-table s4-1 valid) #f) + (set! (-> gp-0 cpuinfo-table s4-1 sprite) + (the-as sprite-vec-data-2d (&+ (-> gp-0 vecdata-table) (* 48 s4-1))) + ) + (set! (-> gp-0 cpuinfo-table s4-1 adgif) (-> gp-0 adgifdata-table s4-1)) + (adgif-shader<-texture-simple! (-> gp-0 adgifdata-table s4-1) (the-as texture #f)) + (set! (-> gp-0 adgifdata-table s4-1 alpha) (new 'static 'gs-miptbp :tbp1 #x48)) + ) + ) + gp-0 + ) + ) + +;; definition for symbol *sp-particle-system-2d*, type sparticle-system +(define + *sp-particle-system-2d* + (new 'global 'sparticle-system 1920 128 #f (-> *sprite-array-2d* vec-data) (-> *sprite-array-2d* adgif-data)) + ) + +;; definition for symbol *sp-particle-system-3d*, type sparticle-system +(define + *sp-particle-system-3d* + (new 'global 'sparticle-system 256 0 #t (-> *sprite-array-3d* vec-data) (-> *sprite-array-3d* adgif-data)) + ) + +;; definition for function sp-get-block-size +(defun sp-get-block-size ((arg0 sparticle-system) (arg1 int)) + (let ((v0-0 0)) + (let ((v1-0 0) + (a2-0 (-> arg0 blocks 0)) + ) + (when (= arg1 1) + (set! v1-0 a2-0) + (set! a2-0 (-> arg0 blocks 1)) + ) + (dotimes (a1-3 a2-0) + (if (!= (-> arg0 alloc-table (+ v1-0 a1-3)) -1) + (set! v0-0 (+ a1-3 1)) + ) + ) + ) + v0-0 + ) + ) + +;; definition for function sp-get-approx-alloc-size +(defun sp-get-approx-alloc-size ((arg0 sparticle-system) (arg1 int)) + (let ((a3-0 arg1) + (v1-0 0) + ) + (let ((a1-1 0) + (a2-0 (-> arg0 blocks 0)) + ) + (when (= a3-0 1) + (set! a1-1 a2-0) + (set! a2-0 (-> arg0 blocks 1)) + ) + (dotimes (a3-3 a2-0) + (if (!= (-> arg0 alloc-table (+ a1-1 a3-3)) -1) + (set! v1-0 (+ a3-3 1)) + ) + ) + ) + (* v1-0 64) + ) + ) + +;; definition for function sp-free-particle +;; INFO: Return type mismatch int vs none. +(defun sp-free-particle ((arg0 sparticle-system) (arg1 int) (arg2 sparticle-cpuinfo) (arg3 sprite-vec-data-2d)) + (if (and (-> arg2 binding) (nonzero? (-> arg2 binding))) + (logclear! (-> arg2 binding flags) (sp-launch-state-flags launcher-active particles-active)) + ) + (let ((v1-6 (/ arg1 64)) + (t0-4 (logand arg1 63)) + ) + (logior! (-> arg0 alloc-table v1-6) (ash 1 t0-4)) + ) + (if (< arg1 (-> arg0 length 0)) + (+! (-> arg0 num-alloc 0) -1) + (+! (-> arg0 num-alloc 1) -1) + ) + (set! (-> arg2 valid) #f) + (set! (-> arg3 a) 0.0) + 0 + (none) + ) + +;; definition for function sp-get-particle +;; WARN: Unsupported inline assembly instruction kind - [movn t1, t2, t2] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t3, t2] +;; WARN: Unsupported inline assembly instruction kind - [movn t1, t2, t2] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t3, t2] +;; WARN: Unsupported inline assembly instruction kind - [movn t1, t2, t2] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t3, t2] +;; WARN: Unsupported inline assembly instruction kind - [movn t1, t2, t2] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t3, t2] +;; WARN: Unsupported inline assembly instruction kind - [movn t1, t2, t2] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t3, t2] +;; WARN: Unsupported inline assembly instruction kind - [movn t3, t1, t1] +;; WARN: Unsupported inline assembly instruction kind - [movz a2, t2, t1] +(defun sp-get-particle ((arg0 sparticle-system) (arg1 int) (arg2 sparticle-launch-state)) + (local-vars + (a2-3 int) + (a2-4 int) + (a2-5 int) + (a2-6 int) + (a2-7 int) + (a2-8 int) + (t1-16 int) + (t1-17 int) + (t1-18 int) + (t1-19 int) + (t1-20 int) + (t3-5 int) + ) + (let ((v1-0 0) + (t0-0 (-> arg0 blocks 0)) + (a3-0 0) + ) + (when (= arg1 1) + (set! v1-0 t0-0) + (set! t0-0 (-> arg0 blocks 1)) + ) + (when arg2 + (set! a3-0 (the-as int (-> arg2 randomize))) + (+! (-> arg2 randomize) 1) + (when (= (-> arg2 randomize) t0-0) + (set! (-> arg2 randomize) (the-as uint 0)) + 0 + ) + ) + (dotimes (a2-1 t0-0) + (when (nonzero? (-> arg0 alloc-table (+ v1-0 a3-0))) + (let ((a2-2 0) + (t1-15 (-> arg0 alloc-table (+ v1-0 a3-0))) + (t0-4 (* (+ v1-0 a3-0) 64)) + ) + 0 + 0 + (let ((t2-4 (shl t1-15 32)) + (t3-0 (+ a2-2 32)) + ) + (.movn t1-16 t2-4 t2-4 t1-15) + (.movz a2-3 t3-0 t2-4 a2-2) + ) + (let ((t2-5 (shl t1-16 16)) + (t3-1 (+ a2-3 16)) + ) + (.movn t1-17 t2-5 t2-5 t1-16) + (.movz a2-4 t3-1 t2-5 a2-3) + ) + (let ((t2-6 (* t1-17 256)) + (t3-2 (+ a2-4 8)) + ) + (.movn t1-18 t2-6 t2-6 t1-17) + (.movz a2-5 t3-2 t2-6 a2-4) + ) + (let ((t2-7 (* t1-18 16)) + (t3-3 (+ a2-5 4)) + ) + (.movn t1-19 t2-7 t2-7 t1-18) + (.movz a2-6 t3-3 t2-7 a2-5) + ) + (let ((t2-8 (* t1-19 4)) + (t3-4 (+ a2-6 2)) + ) + (.movn t1-20 t2-8 t2-8 t1-19) + (.movz a2-7 t3-4 t2-8 a2-6) + (let ((t1-21 (* t1-20 2)) + (t2-9 (+ a2-7 1)) + ) + (.movn t3-5 t1-21 t1-21 t3-4) + (.movz a2-8 t2-9 t1-21 a2-7) + ) + ) + (let ((t0-5 (+ t0-4 a2-8))) + (set! (-> arg0 alloc-table (+ v1-0 a3-0)) + (logxor (-> arg0 alloc-table (+ v1-0 a3-0)) (the-as uint (ash 1 a2-8))) + ) + (+! (-> arg0 num-alloc arg1) 1) + (let ((v1-9 (-> arg0 cpuinfo-table t0-5))) + (set! (-> v1-9 valid) #t) + (return v1-9) + ) + ) + ) + ) + (+! a3-0 1) + (if (= a3-0 t0-0) + (set! a3-0 0) + ) + ) + ) + (the-as sparticle-cpuinfo #f) + ) + +;; definition for function sp-kill-particle +;; INFO: Return type mismatch symbol vs none. +;; WARN: Expression building failed: Function sp-kill-particle has a return type of none, but the expression builder found a return statement. +(defun sp-kill-particle ((arg0 sparticle-system) (arg1 sparticle-cpuinfo)) + (cond + ((>= (the-as int arg1) #x70000000) + (set! (-> arg1 timer) 0) + 0 + ) + (else + (let ((a2-1 (/ (the-as int (- (the-as uint arg1) (the-as uint (-> arg0 cpuinfo-table 0)))) 144))) + (when (or (< a2-1 0) (>= a2-1 (+ (-> arg0 length 0) (-> arg0 length 1)))) + (format 0 "Tried to release particle ~D~%" a2-1) + (return #f) + ) + (sp-free-particle arg0 a2-1 arg1 (-> arg1 sprite)) + ) + ) + ) + #t + (none) + ) + +;; definition for function sp-orbiter +;; INFO: Return type mismatch int vs none. +(defun sp-orbiter ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector)) + (let* ((f2-0 (-> arg1 omega)) + (f0-0 (-> arg1 radius)) + (f4-0 (-> arg1 vel-sxvel x)) + (f24-0 (-> arg1 vel-sxvel y)) + (f1-0 (-> arg1 vel-sxvel z)) + (f3-0 (-> *sp-frame-time* y)) + (f28-0 (+ f2-0 (* f4-0 f3-0))) + ) + (set! (-> arg1 omega) f28-0) + (let ((f30-0 (+ f0-0 (* f1-0 f3-0)))) + (set! (-> arg1 radius) f30-0) + (let ((f26-0 (sin f28-0)) + (f28-1 (cos f28-0)) + (f22-0 (sin (* 0.5 f24-0))) + (f0-5 (cos (* 0.5 f24-0))) + (a1-1 (new 'stack-no-clear 'vector)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (let ((s3-0 (new 'stack-no-clear 'matrix))) + (set-vector! a1-1 (* f22-0 f28-1) 0.0 (* f22-0 f26-0) f0-5) + (quaternion*! (-> arg1 rotvel3d) (the-as quaternion a1-1) (-> arg1 rotvel3d)) + (quaternion-normalize! (-> arg1 rotvel3d)) + (set-vector! s4-0 (* f26-0 f30-0) 0.0 (* f28-1 f30-0) 1.0) + (quaternion->matrix s3-0 (-> arg1 rotvel3d)) + (vector-matrix*! s4-0 s4-0 s3-0) + ) + (let ((v1-3 (the-as object (-> arg1 user-float)))) + (set! (-> arg2 x) (+ (-> s4-0 x) (-> (the-as sprite-vec-data-2d v1-3) x))) + (set! (-> arg2 y) (+ (-> s4-0 y) (-> (the-as sprite-vec-data-2d v1-3) y))) + (set! (-> arg2 z) (+ (-> s4-0 z) (-> (the-as sprite-vec-data-2d v1-3) z))) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function sp-process-block-2d +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition for function sp-process-block-3d +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition for function sp-copy-to-spr +;; INFO: Return type mismatch int vs none. +(defun sp-copy-to-spr ((arg0 int) (arg1 pointer) (arg2 int)) + (let ((a2-1 (/ (+ arg2 15) 16))) + (dma-send-to-spr-no-flush (the-as uint arg0) (the-as uint arg1) (the-as uint a2-1) #t) + ) + 0 + (none) + ) + +;; definition for function sp-copy-from-spr +;; INFO: Return type mismatch int vs none. +(defun sp-copy-from-spr ((arg0 int) (arg1 pointer) (arg2 int)) + (let ((a2-1 (/ (+ arg2 15) 16))) + (dma-send-from-spr-no-flush (the-as uint arg1) (the-as uint arg0) (the-as uint a2-1) #t) + ) + 0 + (none) + ) + +;; definition for function memcpy +;; ERROR: function was not converted to expressions. Cannot decompile. + +;; definition for function sp-process-block +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defun sp-process-block ((arg0 sparticle-system) (arg1 int) (arg2 sprite-array-2d) (arg3 int)) + (local-vars + (sv-16 int) + (sv-32 int) + (sv-48 (function sparticle-system int int int int symbol none)) + (sv-64 sparticle-system) + (sv-80 int) + (sv-96 int) + (sv-112 int) + (sv-128 (function sparticle-system int int int int symbol none)) + (sv-144 sparticle-system) + (sv-160 int) + (sv-176 int) + (sv-192 int) + ) + (let ((s3-0 16) + (s2-0 (* 144 arg3)) + (s5-0 (* 48 arg3)) + ) + (set! sv-32 (* 80 arg3)) + (let ((s1-0 (+ s3-0 s2-0))) + (set! sv-16 (+ s1-0 s5-0)) + (sp-copy-to-spr s3-0 (the-as pointer (-> arg0 cpuinfo-table arg1)) s2-0) + (sp-copy-to-spr s1-0 (&+ (-> arg0 vecdata-table) (* 48 arg1)) s5-0) + (let ((t9-2 sp-copy-to-spr) + (a1-7 (-> arg0 adgifdata-table arg1)) + ) + (t9-2 sv-16 (the-as pointer a1-7) sv-32) + ) + (set! sv-80 (+ #x70000000 s3-0)) + (set! sv-96 (+ #x70000000 s1-0)) + (cond + ((-> arg0 is-3d) + (set! sv-48 sp-process-block-3d) + (set! sv-64 arg0) + (set! sv-112 arg1) + (let ((t1-0 (paused?))) + (sv-48 sv-64 sv-80 sv-96 sv-112 arg3 t1-0) + ) + ) + (else + (set! sv-128 sp-process-block-2d) + (set! sv-144 arg0) + (set! sv-160 sv-80) + (set! sv-176 sv-96) + (set! sv-192 arg1) + (let ((t1-1 (paused?))) + (sv-128 sv-144 sv-160 sv-176 sv-192 arg3 t1-1) + ) + ) + ) + (sp-copy-from-spr s3-0 (the-as pointer (-> arg0 cpuinfo-table arg1)) s2-0) + (sp-copy-from-spr s1-0 (&+ (-> arg0 vecdata-table) (* 48 arg1)) s5-0) + ) + ) + 0 + (none) + ) + +;; definition for function sp-process-particle-system +;; INFO: Return type mismatch int vs none. +(defun sp-process-particle-system ((arg0 sparticle-system) (arg1 int) (arg2 sprite-array-2d)) + (let* ((v1-0 16) + (s1-0 (/ (- #x4000 v1-0) 272)) + (s3-0 0) + (s4-0 (sp-get-approx-alloc-size arg0 arg1)) + ) + (if (= arg1 1) + (set! s3-0 (* (-> arg0 blocks 0) 64)) + ) + (set! (-> arg2 num-valid arg1) s4-0) + (flush-cache 0) + (while (>= s4-0 s1-0) + (sp-process-block arg0 s3-0 arg2 s1-0) + (set! s4-0 (- s4-0 s1-0)) + (+! s3-0 s1-0) + ) + (if (> s4-0 0) + (sp-process-block arg0 s3-0 arg2 s4-0) + ) + ) + 0 + (none) + ) + +;; definition (perm) for symbol *particles-flag*, type symbol +(define-perm *particles-flag* symbol #t) + +;; definition for function forall-particles-with-key-runner +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defun forall-particles-with-key-runner ((arg0 sparticle-launch-control) + (arg1 (function sparticle-system sparticle-cpuinfo none)) + (arg2 sparticle-system) + ) + (local-vars (sv-16 int)) + (let ((s3-0 (the-as object (-> arg2 cpuinfo-table 0))) + (s2-0 (&+ (-> arg2 vecdata-table) 0)) + (s1-0 (+ (-> arg2 blocks 0) (-> arg2 blocks 1))) + ) + (dotimes (s0-0 s1-0) + (cond + ((!= (-> arg2 alloc-table s0-0) -1) + (set! sv-16 0) + (while (< sv-16 64) + (if (and (-> (the-as sparticle-cpuinfo s3-0) valid) (= (-> (the-as sparticle-cpuinfo s3-0) key) arg0)) + (arg1 arg2 (the-as sparticle-cpuinfo s3-0)) + ) + (set! s3-0 (-> (the-as (inline-array sparticle-cpuinfo) s3-0) 1)) + (&+! s2-0 48) + (set! sv-16 (+ sv-16 1)) + ) + ) + (else + (set! s3-0 (-> (the-as (inline-array sparticle-cpuinfo) s3-0) 64)) + (&+! s2-0 3072) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function forall-particles-with-key +;; INFO: Return type mismatch int vs none. +(defun forall-particles-with-key ((arg0 sparticle-launch-control) + (arg1 (function sparticle-system sparticle-cpuinfo none)) + (arg2 symbol) + (arg3 symbol) + ) + (if arg2 + (forall-particles-with-key-runner arg0 arg1 *sp-particle-system-2d*) + ) + (if arg3 + (forall-particles-with-key-runner arg0 arg1 *sp-particle-system-3d*) + ) + 0 + (none) + ) + +;; definition for function sparticle-kill-it +;; INFO: Return type mismatch int vs none. +(defun sparticle-kill-it ((arg0 sparticle-system) (arg1 sparticle-cpuinfo)) + (set! (-> arg1 timer) 0) + (set! (-> arg1 func) (the-as basic 0)) + (when (and (-> arg1 binding) (nonzero? (-> arg1 binding))) + (logclear! (-> arg1 binding flags) (sp-launch-state-flags launcher-active particles-active)) + (set! (-> arg1 binding) #f) + ) + 0 + (none) + ) + +;; definition for function sparticle-kill-it-level0 +;; INFO: Return type mismatch int vs none. +(defun sparticle-kill-it-level0 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo)) + (if (logtest? (-> arg1 flags) (sp-cpuinfo-flag level0)) + (sparticle-kill-it arg0 arg1) + ) + 0 + (none) + ) + +;; definition for function sparticle-kill-it-level1 +;; INFO: Return type mismatch int vs none. +(defun sparticle-kill-it-level1 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo)) + (if (logtest? (-> arg1 flags) (sp-cpuinfo-flag level1)) + (sparticle-kill-it arg0 arg1) + ) + 0 + (none) + ) + +;; definition for function sparticle-60-to-50 +;; INFO: Return type mismatch int vs none. +(defun sparticle-60-to-50 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer)) + (let ((gp-0 (-> arg1 rotvel3d)) + (s5-0 (new 'stack-no-clear 'quaternion)) + ) + (vector-angle<-quaternion! (the-as vector s5-0) gp-0) + (set! (-> s5-0 w) (* 12516.455 (-> s5-0 w))) + (quaternion-vector-angle! gp-0 (the-as vector s5-0) (-> s5-0 w)) + ) + 0 + (none) + ) + +;; definition for function sparticle-50-to-60 +;; INFO: Return type mismatch int vs none. +(defun sparticle-50-to-60 ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 pointer)) + (let ((gp-0 (-> arg1 rotvel3d)) + (s5-0 (new 'stack-no-clear 'quaternion)) + ) + (vector-angle<-quaternion! (the-as vector s5-0) gp-0) + (set! (-> s5-0 w) (* 8691.982 (-> s5-0 w))) + (quaternion-vector-angle! gp-0 (the-as vector s5-0) (-> s5-0 w)) + ) + 0 + (none) + ) + +;; definition for function kill-all-particles-with-key +;; INFO: Return type mismatch int vs none. +(defun kill-all-particles-with-key ((arg0 sparticle-launch-control)) + (forall-particles-with-key arg0 sparticle-kill-it #t #t) + 0 + (none) + ) + +;; definition for function forall-particles-runner +;; INFO: Return type mismatch int vs none. +(defun forall-particles-runner ((arg0 (function sparticle-system sparticle-cpuinfo pointer none)) (arg1 sparticle-system)) + (let ((s4-0 (the-as object (-> arg1 cpuinfo-table 0))) + (s3-0 (&+ (-> arg1 vecdata-table) 0)) + (s2-0 (+ (-> arg1 blocks 0) (-> arg1 blocks 1))) + ) + (dotimes (s1-0 s2-0) + (cond + ((!= (-> arg1 alloc-table s1-0) -1) + (dotimes (s0-0 64) + (if (-> (the-as sparticle-cpuinfo s4-0) valid) + (arg0 arg1 (the-as sparticle-cpuinfo s4-0) s3-0) + ) + (set! s4-0 (+ (the-as uint s4-0) 144)) + (&+! s3-0 48) + ) + ) + (else + (set! s4-0 (&+ (the-as pointer s4-0) 9216)) + (&+! s3-0 3072) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function forall-particles +;; INFO: Return type mismatch int vs none. +(defun forall-particles ((arg0 function) (arg1 symbol) (arg2 symbol)) + (if arg1 + (forall-particles-runner + (the-as (function sparticle-system sparticle-cpuinfo pointer none) arg0) + *sp-particle-system-2d* + ) + ) + (if arg2 + (forall-particles-runner + (the-as (function sparticle-system sparticle-cpuinfo pointer none) arg0) + *sp-particle-system-3d* + ) + ) + 0 + (none) + ) + +;; definition for function kill-all-particles-in-level +(defun kill-all-particles-in-level ((arg0 level)) + (forall-particles + (if (zero? (-> arg0 index)) + sparticle-kill-it-level0 + sparticle-kill-it-level1 + ) + #t + #t + ) + 0 + ) + +;; definition for function all-particles-50-to-60 +(defun all-particles-50-to-60 () + (forall-particles-runner sparticle-50-to-60 *sp-particle-system-3d*) + (none) + ) + +;; definition for function all-particles-60-to-50 +(defun all-particles-60-to-50 () + (forall-particles-runner sparticle-60-to-50 *sp-particle-system-3d*) + (none) + ) + +;; definition for function set-particle-frame-time +;; INFO: Return type mismatch int vs none. +(defun set-particle-frame-time ((arg0 int)) + (cond + ((= arg0 5) + (set-vector! *sp-frame-time* 0.00000000000000000000000000000000000001175495 5.0 1.0 1.0) + ) + ((= arg0 6) + (set-vector! *sp-frame-time* 0.000000000000000000000000000000000000011754952 6.0 1.2 1.2) + ) + ((= arg0 10) + (set-vector! *sp-frame-time* 0.000000000000000000000000000000000000011754958 10.0 2.0 2.0) + ) + ((= arg0 12) + (set-vector! *sp-frame-time* 0.00000000000000000000000000000000000001175496 12.0 2.4 2.4) + ) + ) + 0 + (none) + ) + +;; definition for function process-particles +;; INFO: Return type mismatch int vs none. +;; WARN: Unsupported inline assembly instruction kind - [mfc0 gp, Count] +;; WARN: Unsupported inline assembly instruction kind - [mfc0 v1, Count] +(defun process-particles () + (local-vars (v1-29 int) (gp-0 int)) + (when *particles-flag* + 0 + 0 + (.mfc0 gp-0 Count) + (set! *sp-launcher-lock* #t) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x40 :b #x40 :a #x80) + ) + ) + (let ((v1-14 (logand (the-as int (-> *sp-frame-time* x)) 255))) + (set! *particle-300hz-timer* (+ *particle-300hz-timer* v1-14)) + (cond + (*sp-60-hz* + (when (or (= v1-14 6) (= v1-14 12)) + (set! *sp-60-hz* #f) + (all-particles-60-to-50) + ) + ) + (else + (when (or (= v1-14 5) (= v1-14 10)) + (set! *sp-60-hz* #t) + (all-particles-50-to-60) + ) + ) + ) + ) + (clear-sprite-aux-list) + (sp-process-particle-system *sp-particle-system-2d* 0 *sprite-array-2d*) + (sp-process-particle-system *sp-particle-system-2d* 1 *sprite-array-2d*) + (sp-process-particle-system *sp-particle-system-3d* 0 (the-as sprite-array-2d *sprite-array-3d*)) + (if *debug-segment* + (add-frame + (-> *display* frames (-> *display* on-screen) frame profile-bar 0) + 'draw + (new 'static 'rgba :r #x80 :g #x80 :b #xff :a #x80) + ) + ) + (set! *sp-launcher-lock* #f) + (sp-clear-queue) + (.mfc0 v1-29 Count) + (let ((a2-5 (- v1-29 gp-0))) + (if *display-sprite-info* + (format + *stdcon* + "Particle time = ~D cycles for ~D 2D [~D warp] and ~D HUD and ~D 3D~%" + a2-5 + (-> *sp-particle-system-2d* num-alloc 0) + (-> *sprite-aux-list* entry) + (-> *sp-particle-system-2d* num-alloc 1) + (-> *sp-particle-system-3d* num-alloc 0) + ) + ) + ) + ) + 0 + (none) + ) + + + + diff --git a/test/decompiler/reference/engine/target/target-handler_REF.gc b/test/decompiler/reference/engine/target/target-handler_REF.gc new file mode 100644 index 0000000000..48d1bf6cda --- /dev/null +++ b/test/decompiler/reference/engine/target/target-handler_REF.gc @@ -0,0 +1,1125 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for function target-generic-event-handler +;; INFO: Return type mismatch none vs object. +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 37] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 39] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 60] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 69] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 73] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 151] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 168] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 185] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 196] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 201] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 222] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 292] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 351] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 366] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 408] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 420] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 427] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 451] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 465] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 472] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 482] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 524] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 552] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 563] +;; Used lq/sq +(defbehavior target-generic-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-0 none)) + (let ((v1-0 arg2)) + (the-as + object + (cond + ((= v1-0 'get-pickup) + (when (zero? (logand (-> self state-flags) #x8000)) + (let ((s4-0 (-> arg3 param 0)) + (f28-0 (the-as float (-> arg3 param 1))) + ) + (if (!= (pickup-collectable! + (-> self fact-info-target) + (the-as pickup-type s4-0) + (-> (new 'static 'array float 1 0.0) 0) + (the-as handle #f) + ) + (pickup-collectable! (-> self fact-info-target) (the-as pickup-type s4-0) f28-0 (process->handle arg0)) + ) + #t + 'full + ) + ) + ) + ) + ((= v1-0 'reset-pickup) + (reset! (-> self fact-info-target) (the-as symbol (-> arg3 param 0))) + ) + ((= v1-0 'reset-collide) + (cond + ((-> self control unknown-symbol00) + (target-collide-set! (-> self control unknown-symbol00) (-> self control unknown-float90)) + ) + ((-> self control unknown-symbol30) + (target-danger-set! (-> self control unknown-symbol30) #f) + ) + ) + ) + ((= v1-0 'level-deactivate) + #f + ) + ((= v1-0 'level-enter) + (let ((v1-21 (level-get *level* (the-as symbol (-> arg3 param 0))))) + (when v1-21 + (let ((s5-1 (-> v1-21 info))) + (let ((v1-22 (-> s5-1 buzzer))) + (if (zero? v1-22) + (set! (-> self fact-info-target buzzer) 0.0) + (set! (-> self fact-info-target buzzer) (pickup-collectable! + (-> self fact-info-target) + (pickup-type buzzer) + (the float (logior -65536 v1-22)) + (the-as handle #f) + ) + ) + ) + ) + (if (and (zero? (-> *game-info* enter-level-time (-> s5-1 index))) + (>= (-> *level-task-data-remap* length) (-> s5-1 index)) + ) + (set! (-> *game-info* enter-level-time (-> *level-task-data-remap* (+ (-> s5-1 index) -1))) + (-> *display* base-frame-counter) + ) + ) + ) + (send-event (ppointer->process (-> *hud-parts* buzzers)) 'sync) + (format #t "GAMEPLAY: enter ~A~%" (-> arg3 param 0)) + ) + ) + ) + ((= v1-0 'get-attack-count) + (set! v0-0 (the-as none (+ (-> self control unknown-dword51) (-> arg3 param 0)))) + (set! (-> self control unknown-dword51) (the-as int v0-0)) + v0-0 + ) + ((= v1-0 'continue) + (go target-continue (the-as continue-point (-> arg3 param 0))) + ) + ((= v1-0 'query) + (case (-> arg3 param 0) + (('powerup) + (and (= (-> self fact-info-target eco-type) (-> arg3 param 1)) (< 0.0 (-> self fact-info-target eco-level))) + ) + (('pickup) + (pickup-collectable! + (-> self fact-info-target) + (the-as pickup-type (-> arg3 param 1)) + (-> (new 'static 'array float 1 0.0) 0) + (the-as handle #f) + ) + ) + (('ground-height) + (target-height-above-ground) + ) + ) + ) + ((= v1-0 'trans) + (case (-> arg3 param 0) + (('save) + (set! (-> self alt-cam-pos quad) (-> self control trans quad)) + (set! (-> self state-flags) (logior #x20000 (-> self state-flags))) + (mem-copy! (the-as pointer (-> arg3 param 1)) (the-as pointer (-> self control trans)) 48) + ) + (('restore) + (set! (-> self state-flags) (logand -131073 (-> self state-flags))) + (let ((gp-1 (-> arg3 param 1))) + (move-to-point! (-> self control) (the-as vector (+ gp-1 0))) + (quaternion-copy! (-> self control quat) (the-as quaternion (+ gp-1 16))) + ) + (rot->dir-targ! (-> self control)) + (logior! (-> self control status) 7) + (set! v0-0 (the-as none (-> *display* base-frame-counter))) + (set! (-> self control unknown-dword11) (the-as int v0-0)) + v0-0 + ) + (('reset) + (set! v0-0 (the-as none (logand -131073 (-> self state-flags)))) + (set! (-> self state-flags) (the-as uint v0-0)) + v0-0 + ) + ) + ) + ((= v1-0 'effect) + (target-powerup-effect (the-as symbol (-> arg3 param 0))) + ) + ((= v1-0 'do-effect) + (dummy-10 (-> self skel effect) (the-as symbol (-> arg3 param 0)) (the-as float (-> arg3 param 1)) -1) + (if (-> self sidekick) + (dummy-10 + (-> self sidekick 0 skel effect) + (the-as symbol (-> arg3 param 0)) + (the-as float (-> arg3 param 1)) + -1 + ) + ) + ) + ((= v1-0 'neck) + (set! (-> self neck flex-blend) (the-as float (-> arg3 param 0))) + (cond + ((-> arg3 param 1) + (set! (-> self state-flags) (logior #x40000 (-> self state-flags))) + (set! (-> self alt-neck-pos quad) (-> (the-as vector (-> arg3 param 1)) quad)) + (look-at-enemy! (-> self neck) (-> self alt-neck-pos) 'force arg0) + ) + (else + (set! v0-0 (the-as none (logand -262145 (-> self state-flags)))) + (set! (-> self state-flags) (the-as uint v0-0)) + v0-0 + ) + ) + ) + ((= v1-0 'sidekick) + (cond + ((and (-> arg3 param 0) (not (-> self sidekick))) + (let ((gp-2 (get-process *default-dead-pool* sidekick #x4000))) + (set! v0-0 (when gp-2 + (let ((t9-21 (method-of-type sidekick activate))) + (t9-21 (the-as sidekick gp-2) self 'sidekick (the-as pointer #x70004000)) + ) + (run-now-in-process gp-2 init-sidekick) + (-> gp-2 ppointer) + ) + ) + ) + (set! (-> self sidekick) (the-as (pointer sidekick) v0-0)) + v0-0 + ) + ((and (not (-> arg3 param 0)) (-> self sidekick)) + (deactivate (-> self sidekick 0)) + (set! (-> self sidekick) (the-as (pointer sidekick) #f)) + #f + ) + ) + ) + ((= v1-0 'blend-shape) + (if (-> arg3 param 0) + (logior! (-> self skel status) 8) + (set! (-> self skel status) (logand -9 (-> self skel status))) + ) + (let ((v1-105 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-105 from) arg0) + (set! (-> v1-105 num-params) arg1) + (set! (-> v1-105 message) arg2) + (set! (-> v1-105 param 0) (-> arg3 param 0)) + (set! (-> v1-105 param 1) (-> arg3 param 1)) + (set! (-> v1-105 param 2) (-> arg3 param 2)) + (set! (-> v1-105 param 3) (-> arg3 param 3)) + (set! (-> v1-105 param 4) (-> arg3 param 4)) + (set! (-> v1-105 param 5) (-> arg3 param 5)) + (set! (-> v1-105 param 6) (-> arg3 param 6)) + (send-event-function (ppointer->process (-> self sidekick)) v1-105) + ) + ) + ((= v1-0 'shadow) + (cond + ((-> arg3 param 0) + (let ((v1-108 (-> self draw shadow-ctrl))) + (set! (-> v1-108 settings flags) (logand -33 (-> v1-108 settings flags))) + ) + 0 + ) + (else + (let ((v1-110 (-> self draw shadow-ctrl))) + (logior! (-> v1-110 settings flags) 32) + ) + 0 + ) + ) + ) + ((= v1-0 'rotate-y-angle) + (quaternion-rotate-y! + (-> self control unknown-quaternion00) + (-> self control unknown-quaternion00) + (the-as float (-> arg3 param 0)) + ) + (if (= (-> *cpad-list* cpads (-> self control unknown-cpad-info00 number) stick0-speed) 0.0) + (rot->dir-targ! (-> self control)) + ) + ) + ((= v1-0 'touched) + (send-event arg0 'touch (-> arg3 param 0)) + ) + ((= v1-0 'dry) + (let ((f0-9 0.0)) + (set! (-> self water drip-wetness) f0-9) + f0-9 + ) + ) + ((= v1-0 'reset-height) + (set! (-> self control unknown-vector52 quad) (-> self control trans quad)) + #f + ) + ((= v1-0 'draw) + (if (-> arg3 param 0) + (logclear! (-> self draw status) (draw-status drwf05)) + (logior! (-> self draw status) (draw-status drwf05)) + ) + (let ((v1-132 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-132 from) arg0) + (set! (-> v1-132 num-params) arg1) + (set! (-> v1-132 message) arg2) + (set! (-> v1-132 param 0) (-> arg3 param 0)) + (set! (-> v1-132 param 1) (-> arg3 param 1)) + (set! (-> v1-132 param 2) (-> arg3 param 2)) + (set! (-> v1-132 param 3) (-> arg3 param 3)) + (set! (-> v1-132 param 4) (-> arg3 param 4)) + (set! (-> v1-132 param 5) (-> arg3 param 5)) + (set! (-> v1-132 param 6) (-> arg3 param 6)) + (send-event-function (ppointer->process (-> self manipy)) v1-132) + ) + ) + ((= v1-0 'no-load-wait) + (set! v0-0 (the-as none (+ (-> *display* base-frame-counter) (-> arg3 param 0)))) + (set! (-> self no-load-wait) (the-as uint v0-0)) + v0-0 + ) + ((= v1-0 'no-look-around) + (set! (-> self no-look-around-wait) (the-as uint (+ (-> *display* base-frame-counter) (-> arg3 param 0)))) + (if (= (-> self next-state name) 'target-look-around) + (send-event self 'end-mode) + ) + ) + ((= v1-0 'change-state) + enter-state + (-> arg3 param 1) + (-> arg3 param 2) + (-> arg3 param 3) + (-> arg3 param 4) + (go (the-as (state target) (-> arg3 param 0))) + ) + ) + ) + ) + ) + +;; definition for function target-shoved +(defbehavior target-shoved target ((arg0 meters) (arg1 meters) (arg2 process) (arg3 (state object object target))) + (let ((s5-0 (new 'static 'attack-info))) + (set! (-> s5-0 attacker) (process->handle arg2)) + (set! (-> s5-0 shove-back) arg0) + (set! (-> s5-0 shove-up) arg1) + (set! (-> s5-0 angle) (if (zero? (logand (logior (-> self control status) (-> self control old-status)) 1)) + 'air + 'shove + ) + ) + (set! (-> s5-0 mask) (the-as uint 2248)) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 255 30) + (go arg3 'shove s5-0) + ) + ) + +;; definition for function get-intersect-point +;; Used lq/sq +(defun get-intersect-point ((arg0 vector) (arg1 touching-prims-entry) (arg2 control-info) (arg3 process)) + (let ((a0-2 (get-touched-tri arg1 arg2 (the-as touching-shapes-entry arg3)))) + (if a0-2 + (set! (-> arg0 quad) (-> a0-2 intersect quad)) + (get-middle-of-bsphere-overlap arg1 arg0) + ) + ) + arg0 + ) + +;; definition for function target-attacked +(defbehavior target-attacked target ((arg0 symbol) (arg1 attack-info) (arg2 process) (arg3 process) (arg4 (state handle attack-info target))) + (when (zero? (logand (-> self state-flags) 8)) + (cond + ((or (logtest? (-> self state-flags) 112) + (and (logtest? (-> arg1 mask) 32) + (= (-> arg1 mode) 'darkeco) + (and (and (= (-> self fact-info-target eco-type) 2) (>= (-> self fact-info-target eco-level) 1.0)) + (logtest? #x100002 (-> self state-flags)) + ) + ) + ) + (case arg0 + (('attack-or-shove) + ) + (('attack-invinc) + (set! arg0 'attack) + ) + (else + (return #f) + ) + ) + ) + (else + (case arg0 + (('attack-or-shove 'attack-invinc) + (set! arg0 'attack) + ) + ) + ) + ) + (mem-copy! (the-as pointer (-> self attack-info-rec)) (the-as pointer arg1) 104) + (when arg3 + (let ((a1-2 ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg3) + (-> self control) + (the-as uint -1) + ) + ) + ) + (when a1-2 + (get-intersect-point (-> self attack-info-rec intersection) a1-2 (-> self control) arg3) + (logior! (-> self attack-info-rec mask) 4) + ) + ) + ) + (set! (-> self attack-info-rec prev-state) (-> self state)) + (logior! (-> self attack-info-rec mask) 8192) + (when (zero? (logand (-> self attack-info-rec mask) 8)) + (set! (-> self attack-info-rec attacker) (process->handle arg2)) + (logior! (-> self attack-info-rec mask) 8) + ) + (cond + ((and (logtest? (-> self attack-info-rec mask) 32) + (and (= (-> self attack-info-rec mode) 'damage) + (not (and (= (-> self game mode) 'play) (>= 1.0 (-> self fact-info-target health)))) + ) + ) + (pickup-collectable! + (-> self fact-info-target) + (pickup-type eco-green) + (- (-> *FACT-bank* health-single-inc)) + (the-as handle #f) + ) + (let ((gp-1 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-1 + (let ((t9-5 (method-of-type part-tracker activate))) + (t9-5 (the-as part-tracker gp-1) self 'part-tracker (the-as pointer #x70004000)) + ) + (run-now-in-process + gp-1 + part-tracker-init + (-> *part-group-id-table* 1) + -1 + #f + #f + #f + (if (logtest? (-> self attack-info-rec mask) 4) + (-> self attack-info-rec intersection) + (-> self control root-prim prim-core) + ) + ) + (-> gp-1 ppointer) + ) + ) + (target-timed-invulnerable + (if (logtest? (-> self attack-info-rec mask) 16) + (-> self attack-info-rec invinc-time) + (-> *TARGET-bank* hit-invulnerable-timeout) + ) + self + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 0 255 150) + (sound-play-by-name (static-sound-name "oof") (new-sound-id) 1024 0 0 1 #t) + #t + ) + (else + (logior! (-> self state-flags) 8) + (if (and (= (-> self game mode) 'play) (and (>= 1.0 (-> self fact-info-target health)) (= arg0 'attack))) + (logior! (-> self state-flags) #x8000) + ) + (go arg4 (the-as handle arg0) (-> self attack-info-rec)) + ) + ) + ) + ) + +;; definition for function target-send-attack +;; INFO: Return type mismatch object vs symbol. +;; Used lq/sq +(defbehavior target-send-attack target ((arg0 process) (arg1 uint) (arg2 uint) (arg3 int) (arg4 int)) + (local-vars + (sv-96 touching-prims-entry) + (sv-128 touching-prims-entry) + (sv-176 touching-prims-entry) + (sv-224 int) + (sv-240 symbol) + (sv-256 symbol) + (sv-272 symbol) + (sv-288 int) + (sv-304 symbol) + (sv-320 symbol) + (sv-336 symbol) + (sv-352 int) + (sv-368 symbol) + (sv-384 symbol) + (sv-400 symbol) + (sv-416 int) + (sv-432 symbol) + (sv-448 symbol) + (sv-464 symbol) + (sv-480 int) + (sv-496 symbol) + (sv-512 symbol) + (sv-528 symbol) + ) + (let ((v1-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-0 from) self) + (set! (-> v1-0 num-params) 4) + (set! (-> v1-0 message) 'attack) + (set! (-> v1-0 param 0) arg2) + (set! (-> v1-0 param 1) arg1) + (set! (-> v1-0 param 2) (the-as uint arg3)) + (set! (-> v1-0 param 3) (the-as uint arg4)) + (let ((gp-0 (send-event-function arg0 v1-0))) + (when (and gp-0 (!= gp-0 'push)) + (let ((v1-5 (-> self control unknown-symbol30))) + (cond + ((or (= v1-5 'spin) (= v1-5 'spin-air)) + (set! sv-96 + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg2) + (-> self control) + (the-as uint 64) + ) + ) + (cond + (sv-96 + (let ((s4-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-0 + (let ((t9-3 (method-of-type part-tracker activate))) + (t9-3 (the-as part-tracker s4-0) self 'part-tracker (the-as pointer #x70004000)) + ) + (let ((s3-0 run-function-in-process) + (s2-0 s4-0) + (s1-0 part-tracker-init) + (s0-0 (-> *part-group-id-table* 4)) + ) + (set! sv-224 -1) + (set! sv-240 (the-as symbol #f)) + (set! sv-256 (the-as symbol #f)) + (set! sv-272 (the-as symbol #f)) + (let ((t3-0 (get-intersect-point (new 'stack-no-clear 'vector) sv-96 (-> self control) (the-as process arg2)))) + ((the-as (function object object object object object object object object none) s3-0) + s2-0 + s1-0 + s0-0 + sv-224 + sv-240 + sv-256 + sv-272 + t3-0 + ) + ) + ) + (-> s4-0 ppointer) + ) + ) + ) + (else + (dummy-10 (-> self skel effect) 'group-spin-hit (the-as float -1.0) 74) + ) + ) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 74 + #f + (static-sound-name "spin-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 127 60) + ) + ((= v1-5 'punch) + (set! sv-128 + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg2) + (-> self control) + (the-as uint 64) + ) + ) + (cond + (sv-128 + (let ((s4-1 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-1 + (let ((t9-11 (method-of-type part-tracker activate))) + (t9-11 (the-as part-tracker s4-1) self 'part-tracker (the-as pointer #x70004000)) + ) + (let ((s3-1 run-function-in-process) + (s2-1 s4-1) + (s1-1 part-tracker-init) + (s0-1 (-> *part-group-id-table* 5)) + ) + (set! sv-288 -1) + (set! sv-304 (the-as symbol #f)) + (set! sv-320 (the-as symbol #f)) + (set! sv-336 (the-as symbol #f)) + (let ((t3-1 (get-intersect-point (new 'stack-no-clear 'vector) sv-128 (-> self control) (the-as process arg2)))) + ((the-as (function object object object object object object object object none) s3-1) + s2-1 + s1-1 + s0-1 + sv-288 + sv-304 + sv-320 + sv-336 + t3-1 + ) + ) + ) + (-> s4-1 ppointer) + ) + ) + ) + ((let ((v0-14 + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg2) + (-> self control) + (the-as uint 32) + ) + ) + ) + (set! sv-128 v0-14) + v0-14 + ) + (let ((s4-2 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-2 + (let ((t9-16 (method-of-type part-tracker activate))) + (t9-16 (the-as part-tracker s4-2) self 'part-tracker (the-as pointer #x70004000)) + ) + (let ((s3-2 run-function-in-process) + (s2-2 s4-2) + (s1-2 part-tracker-init) + (s0-2 (-> *part-group-id-table* 5)) + ) + (set! sv-352 -1) + (set! sv-368 (the-as symbol #f)) + (set! sv-384 (the-as symbol #f)) + (set! sv-400 (the-as symbol #f)) + (let ((t3-2 (get-intersect-point (new 'stack-no-clear 'vector) sv-128 (-> self control) (the-as process arg2)))) + ((the-as (function object object object object object object object object none) s3-2) + s2-2 + s1-2 + s0-2 + sv-352 + sv-368 + sv-384 + sv-400 + t3-2 + ) + ) + ) + (-> s4-2 ppointer) + ) + ) + ) + ) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 23 + #f + (static-sound-name "punch-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 178 30) + ) + ((= v1-5 'flip) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 74 + #f + (static-sound-name "punch-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 127 30) + ) + ((= v1-5 'uppercut) + (set! sv-176 + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg2) + (-> self control) + (the-as uint 64) + ) + ) + (cond + (sv-176 + (let ((s4-3 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-3 + (let ((t9-25 (method-of-type part-tracker activate))) + (t9-25 (the-as part-tracker s4-3) self 'part-tracker (the-as pointer #x70004000)) + ) + (let ((s3-3 run-function-in-process) + (s2-3 s4-3) + (s1-3 part-tracker-init) + (s0-3 (-> *part-group-id-table* 5)) + ) + (set! sv-416 -1) + (set! sv-432 (the-as symbol #f)) + (set! sv-448 (the-as symbol #f)) + (set! sv-464 (the-as symbol #f)) + (let ((t3-3 (get-intersect-point (new 'stack-no-clear 'vector) sv-176 (-> self control) (the-as process arg2)))) + ((the-as (function object object object object object object object object none) s3-3) + s2-3 + s1-3 + s0-3 + sv-416 + sv-432 + sv-448 + sv-464 + t3-3 + ) + ) + ) + (-> s4-3 ppointer) + ) + ) + ) + ((let ((v0-26 + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry arg2) + (-> self control) + (the-as uint 32) + ) + ) + ) + (set! sv-176 v0-26) + v0-26 + ) + (let ((s4-4 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-4 + (let ((t9-30 (method-of-type part-tracker activate))) + (t9-30 (the-as part-tracker s4-4) self 'part-tracker (the-as pointer #x70004000)) + ) + (let ((s3-4 run-function-in-process) + (s2-4 s4-4) + (s1-4 part-tracker-init) + (s0-4 (-> *part-group-id-table* 5)) + ) + (set! sv-480 -1) + (set! sv-496 (the-as symbol #f)) + (set! sv-512 (the-as symbol #f)) + (set! sv-528 (the-as symbol #f)) + (let ((t3-4 (get-intersect-point (new 'stack-no-clear 'vector) sv-176 (-> self control) (the-as process arg2)))) + ((the-as (function object object object object object object object object none) s3-4) + s2-4 + s1-4 + s0-4 + sv-480 + sv-496 + sv-512 + sv-528 + t3-4 + ) + ) + ) + (-> s4-4 ppointer) + ) + ) + ) + ) + (dummy-10 (-> self skel effect) 'group-uppercut-hit (the-as float -1.0) 23) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 23 + #f + (static-sound-name "uppercut-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 178 30) + ) + ((or (= v1-5 'flop) (= v1-5 'flop-down)) + (dummy-10 (-> self skel effect) 'group-flop-hit (the-as float -1.0) 23) + (dummy-10 (-> self skel effect) 'group-flop-hit (the-as float -1.0) 17) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 23 + #f + (static-sound-name "flop-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 178 30) + ) + ((= v1-5 'flut-attack) + (dummy-12 + (-> self skel effect) + (-> self control unknown-symbol30) + (the-as basic -1.0) + 23 + #f + (static-sound-name "punch-hit") + ) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 255 60) + ) + ) + ) + ) + (the-as symbol gp-0) + ) + ) + ) + +;; definition for function target-apply-tongue +(defbehavior target-apply-tongue target ((arg0 vector)) + (when (zero? (logand (-> self state-flags) 8)) + (logior! (-> self state-flags) #x7000) + (let ((gp-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> self control trans)))) + (set! (-> self control unknown-float41) (lerp-scale + (-> *TARGET-bank* tongue-pull-speed-min) + (-> *TARGET-bank* tongue-pull-speed-max) + (vector-length gp-1) + (the-as float 20480.0) + (the-as float 61440.0) + ) + ) + (if (zero? (-> self control unknown-int00)) + (vector-reset! (-> self control unknown-vector40)) + ) + (vector-flatten! gp-1 gp-1 (-> self control local-normal)) + (vector-normalize! gp-1 (the-as float 1.0)) + (vector+! (-> self control unknown-vector40) (-> self control unknown-vector40) gp-1) + ) + (set! (-> self control unknown-float50) 1.0) + (+! (-> self control unknown-int00) 1) + #t + ) + ) + +;; definition for function target-standard-event-handler +(defbehavior target-standard-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('attack 'attack-or-shove 'attack-invinc) + (target-attacked + arg2 + (the-as attack-info (-> arg3 param 1)) + arg0 + (the-as process (-> arg3 param 0)) + (the-as (state handle attack-info target) target-hit) + ) + ) + (('shove) + (when (!= (-> self next-state name) 'target-hit) + (mem-copy! (the-as pointer (-> self attack-info-rec)) (the-as pointer (-> arg3 param 1)) 104) + (when (zero? (logand (-> self attack-info-rec mask) 8)) + (set! (-> self attack-info-rec attacker) (process->handle arg0)) + (logior! (-> self attack-info-rec mask) 8) + ) + (go target-hit 'shove (-> self attack-info-rec)) + ) + ) + (('launch) + (mem-copy! (&-> (-> self control) unknown-pointer00) (the-as pointer arg3) 72) + #t + ) + (('powerup) + (if (or (= (-> self next-state name) 'target-stance) + (= (-> self next-state name) 'target-walk) + (= (-> self next-state name) 'target-stance-look-around) + ) + (go target-eco-powerup (-> arg3 param 0) (the-as float (-> arg3 param 1))) + ) + ) + (('loading) + (if (not + (or (and (logtest? (-> self control unknown-surface00 flags) 2048) (zero? (logand (-> self control status) 1))) + (or (logtest? (-> self water flags) 512) + (logtest? (-> self state-flags) #x830e) + (logtest? (-> self control root-prim prim-core action) (collide-action ca-7 ca-8 ca-9 ca-12 ca-13 ca-14)) + (>= (the-as int (-> self no-load-wait)) (-> *display* base-frame-counter)) + ) + ) + ) + (go target-load-wait) + ) + ) + (('change-mode) + (case (-> arg3 param 0) + (('grab) + (go target-grab) + ) + (('look-around) + (go target-look-around) + ) + (('billy) + (go target-billy-game) + ) + (('falling) + (go target-falling #f) + ) + (('racing) + (go target-racing-start (process->handle (the-as process (-> arg3 param 1)))) + ) + (('flut) + (go target-flut-start (process->handle (the-as process (-> arg3 param 1)))) + ) + (('snowball) + (go target-snowball-start (process->handle (the-as process (-> arg3 param 1)))) + ) + (('tube) + (if (and (logtest? (-> self control status) 1) (zero? (logand (-> self water flags) 512))) + (go target-tube-start (process->handle (the-as process (-> arg3 param 1)))) + ) + ) + (('periscope) + (if (logtest? (-> self control status) 1) + (go target-periscope (process->handle (the-as process (-> arg3 param 1)))) + ) + ) + (('fishing) + (go target-fishing (process->handle (the-as process (-> arg3 param 1)))) + ) + (('final-door) + (go + target-final-door + (the-as basic (process->handle (the-as process (-> arg3 param 1)))) + (process->handle (the-as process (-> arg3 param 2))) + ) + ) + ) + ) + (('play-anim) + (go target-play-anim (the-as string (-> arg3 param 0)) (the-as handle arg1)) + ) + (('clone-anim) + (go target-clone-anim (process->handle (the-as process (-> arg3 param 0)))) + ) + (('edge-grab) + (go target-edge-grab) + ) + (('pole-grab) + (if (zero? (logand (-> self control root-prim prim-core action) (collide-action ca-8))) + (go target-pole-cycle (process->handle (the-as process (-> arg3 param 0)))) + ) + ) + (('swim) + (if (not (or (= (-> self control unknown-surface00 mode) 'swim) + (= (-> self control unknown-surface00 mode) 'dive) + (= (-> self next-state name) 'target-hit) + (logtest? (-> self state-flags) 8) + ) + ) + (go target-swim-stance) + ) + ) + (('wade) + (if (and (!= (-> self control unknown-surface00 mode) 'wade) + (or (= (-> self next-state name) 'target-stance) + (= (-> self next-state name) 'target-walk) + (= (-> self next-state name) 'target-stance-look-around) + ) + ) + (go target-wade-stance) + ) + ) + (('tongue) + (target-apply-tongue (the-as vector (-> arg3 param 0))) + ) + (else + (target-generic-event-handler arg0 arg1 arg2 arg3) + ) + ) + ) + +;; definition for function target-dangerous-event-handler +(defbehavior target-dangerous-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('touched) + (if ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self control) + (the-as uint 224) + ) + (target-send-attack + arg0 + (the-as uint (-> self control unknown-symbol30)) + (-> arg3 param 0) + (-> self control unknown-dword50) + (-> self control unknown-dword51) + ) + (target-standard-event-handler arg0 arg1 arg2 arg3) + ) + ) + (('attack 'attack-or-shove 'attack-invinc) + (target-attacked + arg2 + (the-as attack-info (-> arg3 param 1)) + arg0 + (the-as process (-> arg3 param 0)) + (the-as (state handle attack-info target) target-hit) + ) + ) + (else + (target-standard-event-handler arg0 arg1 arg2 arg3) + ) + ) + ) + +;; definition for function target-bonk-event-handler +;; Used lq/sq +(defbehavior target-bonk-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (cond + ((and (= arg2 'touched) + ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self control) + (the-as uint 6) + ) + (< (* 16384.0 (-> *display* time-adjust-ratio)) + (vector-dot + (-> self control dynam gravity-normal) + (vector-! (new 'stack-no-clear 'vector) (-> self control transv) (-> self control unknown-vector10)) + ) + ) + (begin + (vector-normalize! + (vector-! + s4-0 + (the-as vector (-> self control unknown-sphere-array00 0 prim-core)) + (-> self control unknown-vector72) + ) + (the-as float 1.0) + ) + (< 0.01 (-> s4-0 y)) + ) + ) + (if (< 0.75 (-> s4-0 y)) + (send-event + arg0 + 'bonk + (-> arg3 param 0) + (fmax + (-> self control ground-impact-vel) + (- (vector-dot (-> self control transv) (-> self control dynam gravity-normal))) + ) + ) + ) + (let ((f0-7 (vector-dot + (-> self control dynam gravity-normal) + (vector-! (new 'stack-no-clear 'vector) (-> self control unknown-vector111) (-> self control trans)) + ) + ) + ) + (when (< (-> *TARGET-bank* fall-far) f0-7) + (when (and (target-send-attack + arg0 + (the-as uint 'bonk) + (-> arg3 param 0) + (-> self control unknown-dword50) + (-> self control unknown-dword51) + ) + (zero? (logand (-> self state-flags) #x8008)) + ) + (set! (-> self control unknown-vector52 quad) (-> self control trans quad)) + (target-timed-invulnerable 30 self) + (go target-jump (-> *TARGET-bank* jump-height-min) (-> *TARGET-bank* jump-height-max) (the-as surface #f)) + ) + ) + ) + #f + ) + ((= arg2 'jump) + (sound-play-by-name (static-sound-name "jump-long") (new-sound-id) 1024 0 0 1 #t) + (go + target-jump + (the-as float (-> arg3 param 0)) + (the-as float (-> arg3 param 1)) + (the-as surface (-> arg3 param 2)) + ) + ) + ) + ) + ) + +;; definition for function target-jump-event-handler +(defbehavior target-jump-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (if (and (= arg2 'swim) (< 0.0 (vector-dot (-> self control dynam gravity-normal) (-> self control transv)))) + (return #f) + ) + (let ((v0-0 (target-bonk-event-handler arg0 arg1 arg2 arg3))) + (cond + (v0-0 + (empty) + v0-0 + ) + (else + (target-standard-event-handler arg0 arg1 arg2 arg3) + ) + ) + ) + ) + +;; definition for function target-walk-event-handler +(defbehavior target-walk-event-handler target ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (let ((v0-0 (target-bonk-event-handler arg0 arg1 arg2 arg3))) + (cond + (v0-0 + (empty) + v0-0 + ) + (else + (target-standard-event-handler arg0 arg1 arg2 arg3) + ) + ) + ) + ) + +;; failed to figure out what this is: +target-post + +;; failed to figure out what this is: +target-standard-event-handler + +;; definition for function target-exit +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defbehavior target-exit target () + (set! (-> self control unknown-surface00) *walk-mods*) + (set! (-> self control unknown-vector13 quad) (the-as uint128 0)) + (set! (-> self control unknown-vector14 quad) (the-as uint128 0)) + (set! (-> self control unknown-vector15 quad) (the-as uint128 0)) + (set! (-> self control unknown-vector11 quad) (the-as uint128 0)) + (set! (-> self control unknown-float41) 0.0) + (set! (-> self control unknown-float81) 0.0) + (set! (-> self state-flags) (logand -1835917 (-> self state-flags))) + (target-danger-set! 'harmless #f) + (logior! (-> self water flags) 16) + (set! (-> self water flags) (logand -65537 (-> self water flags))) + (set! (-> self water drip-mult) 1.0) + (set! (-> self neck flex-blend) 1.0) + (set! (-> self control unknown-float91) 0.0) + (logclear! (-> self draw status) (draw-status drwf01)) + (set! (-> self skel status) (logand -33 (-> self skel status))) + (set! (-> self control status) (logand -16385 (-> self control status))) + 0 + (none) + ) + +;; definition for function target-state-hook-exit +;; INFO: Return type mismatch (function none) vs none. +(defbehavior target-state-hook-exit target () + (set! (-> self state-hook) (the-as (function none :behavior target) nothing)) + (none) + ) + +;; definition for function target-effect-exit +;; INFO: Return type mismatch int vs none. +(defbehavior target-effect-exit target () + (let ((v1-1 (-> self skel effect))) + (set! (-> v1-1 channel-offset) 0) + ) + 0 + (none) + ) + + + + diff --git a/test/decompiler/reference/engine/ui/progress/progress_REF.gc b/test/decompiler/reference/engine/ui/progress/progress_REF.gc new file mode 100644 index 0000000000..b0849825f1 --- /dev/null +++ b/test/decompiler/reference/engine/ui/progress/progress_REF.gc @@ -0,0 +1,2750 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition of type progress-global-state +(deftype progress-global-state (basic) + ((aspect-ratio-choice symbol :offset-assert 4) + (video-mode-choice symbol :offset-assert 8) + (yes-no-choice symbol :offset-assert 12) + (which int32 :offset-assert 16) + (starting-state progress-screen :offset-assert 24) + (last-slot-saved int32 :offset-assert 32) + (slider-backup float :offset-assert 36) + (language-backup int64 :offset-assert 40) + (on-off-backup symbol :offset-assert 48) + (center-x-backup int32 :offset-assert 52) + (center-y-backup int32 :offset-assert 56) + (aspect-ratio-backup symbol :offset-assert 60) + (last-slider-sound int64 :offset-assert 64) + ) + :method-count-assert 9 + :size-assert #x48 + :flag-assert #x900000048 + ) + +;; definition for method 3 of type progress-global-state +(defmethod inspect progress-global-state ((obj progress-global-state)) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~Taspect-ratio-choice: ~A~%" (-> obj aspect-ratio-choice)) + (format #t "~Tvideo-mode-choice: ~A~%" (-> obj video-mode-choice)) + (format #t "~Tyes-no-choice: ~A~%" (-> obj yes-no-choice)) + (format #t "~Twhich: ~D~%" (-> obj which)) + (format #t "~Tstarting-state: ~D~%" (-> obj starting-state)) + (format #t "~Tlast-slot-saved: ~D~%" (-> obj last-slot-saved)) + (format #t "~Tslider-backup: ~f~%" (-> obj slider-backup)) + (format #t "~Tlanguage-backup: ~D~%" (-> obj language-backup)) + (format #t "~Ton-off-backup: ~A~%" (-> obj on-off-backup)) + (format #t "~Tcenter-x-backup: ~D~%" (-> obj center-x-backup)) + (format #t "~Tcenter-y-backup: ~D~%" (-> obj center-y-backup)) + (format #t "~Taspect-ratio-backup: ~A~%" (-> obj aspect-ratio-backup)) + (format #t "~Tlast-slider-sound: ~D~%" (-> obj last-slider-sound)) + obj + ) + +;; definition for symbol *progress-state*, type progress-global-state +(define *progress-state* (new 'static 'progress-global-state :yes-no-choice #f :which -1 :last-slot-saved -1)) + +;; definition for function get-game-count +(defun get-game-count ((arg0 int)) + (-> *game-counts* data arg0) + ) + +;; definition for function progress-allowed? +(defun progress-allowed? () + (with-pp + (not (or (-> *setting-control* current talking) + (-> *setting-control* current movie) + (movie?) + (handle->process (-> *game-info* pov-camera-handle)) + (handle->process (-> *game-info* other-camera-handle)) + (< (-> *display* base-frame-counter) (-> *game-info* letterbox-time)) + (< (-> *display* base-frame-counter) (-> *game-info* blackout-time)) + (!= (-> *setting-control* current bg-a) 0.0) + (!= (-> *setting-control* current bg-a-force) 0.0) + (not (-> *setting-control* current allow-progress)) + (or (and (handle->process (-> *game-info* auto-save-proc)) + (let ((a1-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-3 from) pp) + (set! (-> a1-3 num-params) 0) + (set! (-> a1-3 message) 'progress-allowed?) + (not (send-event-function (handle->process (-> *game-info* auto-save-proc)) a1-3)) + ) + ) + (not *target*) + ) + ) + ) + ) + ) + +;; definition for function pause-allowed? +(defun pause-allowed? () + (not (or (< (-> *display* base-frame-counter) (-> *game-info* blackout-time)) + (!= (-> *setting-control* current bg-a) 0.0) + (!= (-> *setting-control* current bg-a-force) 0.0) + (not (-> *setting-control* current allow-pause)) + (handle->process (-> *game-info* auto-save-proc)) + (not *target*) + ) + ) + ) + +;; definition for function init-game-options +;; INFO: Return type mismatch (pointer symbol) vs none. +(defun init-game-options ((arg0 progress)) + (dotimes (v1-0 35) + (set! (-> *options-remap* v1-0) #f) + ) + (let ((v1-3 *kernel-boot-message*)) + (set! (-> *options-remap* 3) (cond + ((= v1-3 'demo) + *main-options-demo* + ) + ((= v1-3 'demo-shared) + *main-options-demo-shared* + ) + (else + *main-options* + ) + ) + ) + ) + (set! (-> *options-remap* 4) + (cond + ((!= *kernel-boot-message* 'play) + (if (= (scf-get-territory) 1) + *game-options* + *game-options-demo* + ) + ) + ((and (= (scf-get-territory) 2) (not (and (= *progress-cheat* 'language) (cpad-hold? 0 l2) (cpad-hold? 0 r2)))) + *game-options-japan* + ) + (else + *game-options* + ) + ) + ) + (set! (-> *options-remap* 5) + (if (and (= (-> *progress-state* starting-state) (progress-screen title)) + (or (= (scf-get-territory) 1) (and (= *progress-cheat* 'pal) (cpad-hold? 0 l2) (cpad-hold? 0 r2))) + ) + *graphic-title-options-pal* + *graphic-options* + ) + ) + (set! (-> *options-remap* 6) *sound-options*) + (set! (-> *options-remap* 7) *ok-options*) + (set! (-> *options-remap* 8) *ok-options*) + (set! (-> *options-remap* 9) *ok-options*) + (set! (-> *options-remap* 10) *yes-no-options*) + (set! (-> *options-remap* 11) *yes-no-options*) + (set! (-> *options-remap* 19) *ok-options*) + (set! (-> *options-remap* 16) *load-options*) + (set! (-> *options-remap* 17) *save-options*) + (set! (-> *options-remap* 18) *save-options-title*) + (set! (-> *options-remap* 20) *ok-options*) + (set! (-> *options-remap* 21) *ok-options*) + (set! (-> *options-remap* 24) *ok-options*) + (set! (-> *options-remap* 25) *ok-options*) + (set! (-> *options-remap* 26) *ok-options*) + (set! (-> *options-remap* 22) *ok-options*) + (set! (-> *options-remap* 23) *yes-no-options*) + (set! (-> *options-remap* 27) *title*) + (set! (-> *options-remap* 28) *options*) + (set! (-> *options-remap* 29) *ok-options*) + (set! (-> *options-remap* 30) *yes-no-options*) + (set! (-> *options-remap* 31) *yes-no-options*) + (set! (-> *options-remap* 32) *ok-options*) + (set! (-> *options-remap* 33) *ok-options*) + (set! (-> *options-remap* 34) *yes-no-options*) + (set! (-> *progress-state* aspect-ratio-choice) (get-aspect-ratio)) + (set! (-> *progress-state* video-mode-choice) (get-video-mode)) + (set! (-> *progress-state* yes-no-choice) #f) + (set! (-> *game-options* 0 value-to-modify) (&-> *setting-control* default vibration)) + (set! (-> *game-options* 1 value-to-modify) (&-> *setting-control* default play-hints)) + (set! (-> *game-options* 2 value-to-modify) (&-> *setting-control* default language)) + (set! (-> *game-options-japan* 0 value-to-modify) (&-> *setting-control* default vibration)) + (set! (-> *game-options-japan* 1 value-to-modify) (&-> *setting-control* default play-hints)) + (set! (-> *game-options-demo* 0 value-to-modify) (&-> *setting-control* default vibration)) + (set! (-> *game-options-demo* 1 value-to-modify) (&-> *setting-control* default play-hints)) + (set! (-> *graphic-options* 1 value-to-modify) (&-> *progress-state* aspect-ratio-choice)) + (set! (-> *graphic-title-options-pal* 1 value-to-modify) (&-> *progress-state* video-mode-choice)) + (set! (-> *graphic-title-options-pal* 2 value-to-modify) (&-> *progress-state* aspect-ratio-choice)) + (set! (-> *sound-options* 0 value-to-modify) (&-> *setting-control* default sfx-volume)) + (set! (-> *sound-options* 1 value-to-modify) (&-> *setting-control* default music-volume)) + (set! (-> *sound-options* 2 value-to-modify) (&-> *setting-control* default dialog-volume)) + (set! (-> *yes-no-options* 0 value-to-modify) (&-> *progress-state* yes-no-choice)) + (none) + ) + +;; definition for function make-current-level-available-to-progress +;; INFO: Return type mismatch int vs none. +(defun make-current-level-available-to-progress () + (when (and *target* (-> *level* border?)) + (let* ((cur-lev (-> *target* current-level)) + (lev-idx (+ (-> cur-lev info index) -1)) + ) + (if (and (>= lev-idx 0) + (< lev-idx (-> *level-task-data-remap* length)) + (zero? (-> *game-info* level-opened (-> *level-task-data-remap* lev-idx))) + (or (= *kernel-boot-message* 'play) (= (-> cur-lev nickname) 'mis)) + ) + (set! (-> *game-info* level-opened (-> *level-task-data-remap* lev-idx)) (the-as uint 1)) + ) + ) + ) + 0 + (none) + ) + +;; definition for function make-levels-with-tasks-available-to-progress +;; INFO: Return type mismatch int vs none. +(defun make-levels-with-tasks-available-to-progress () + (dotimes (i (length *level-task-data*)) + (let ((tasks (-> *level-task-data* i))) + (when (not (or (= tasks #f) (= (-> *game-info* level-opened i) 1))) + (cond + ((!= *kernel-boot-message* 'play) + (if (= (-> tasks level-name-id) (game-text-id misty-level-name)) + (set! (-> *game-info* level-opened i) (the-as uint 1)) + ) + ) + (*cheat-mode* + (set! (-> *game-info* level-opened i) (the-as uint 1)) + ) + (else + (dotimes (ii (-> tasks nb-of-tasks)) + (if (and (zero? (-> *game-info* level-opened ii)) + (!= ii (-> tasks buzzer-task-index)) + (task-known? (-> tasks task-info ii task-id)) + ) + (set! (-> *game-info* level-opened ii) (the-as uint 1)) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for function get-next-task-up +(defun get-next-task-up ((cur-task-idx int) (lev-idx int)) + (let ((gp-0 cur-task-idx)) + (let ((s4-0 (+ cur-task-idx 1)) + (s3-0 (-> *level-task-data* lev-idx)) + ) + (while (and (< s4-0 (-> s3-0 nb-of-tasks)) (= gp-0 cur-task-idx)) + (if (or *cheat-mode* (task-known? (-> s3-0 task-info s4-0 task-id))) + (set! gp-0 s4-0) + ) + (+! s4-0 1) + ) + ) + gp-0 + ) + ) + +;; definition for function get-next-task-down +(defun get-next-task-down ((cur-task-idx int) (lev-idx int)) + (let ((gp-0 cur-task-idx)) + (let ((s4-0 (+ cur-task-idx -1)) + (s3-0 (-> *level-task-data* lev-idx)) + ) + (while (and (>= s4-0 0) (= gp-0 cur-task-idx)) + (if (or *cheat-mode* (task-known? (-> s3-0 task-info s4-0 task-id))) + (set! gp-0 s4-0) + ) + (+! s4-0 -1) + ) + ) + gp-0 + ) + ) + +;; definition for function get-next-level-up +(defun get-next-level-up ((lev-idx int)) + (let ((gp-0 lev-idx)) + (let ((s4-0 (+ lev-idx 1))) + (while (and (< s4-0 (length *level-task-data*)) (= gp-0 lev-idx)) + (if (= (-> *game-info* level-opened s4-0) 1) + (set! gp-0 s4-0) + ) + (+! s4-0 1) + ) + ) + gp-0 + ) + ) + +;; definition for function get-next-level-down +(defun get-next-level-down ((lev-idx int)) + (let ((v0-0 lev-idx)) + (let ((v1-0 (+ lev-idx -1))) + (while (and (>= v1-0 0) (= v0-0 lev-idx)) + (if (= (-> *game-info* level-opened v1-0) 1) + (set! v0-0 v1-0) + ) + (+! v1-0 -1) + ) + ) + v0-0 + ) + ) + +;; definition for function calculate-completion +(defun calculate-completion ((the-progress progress)) + (local-vars + (current-cells int) + (current-buzzers int) + (current-orbs int) + (total-cells int) + (total-buzzers int) + (total-orbs int) + ) + (set! current-cells 0) + (set! current-buzzers 0) + (set! current-orbs 0) + (set! total-cells 0) + (set! total-buzzers 0) + (set! total-orbs 0) + (dotimes (s5-0 (length *level-task-data*)) + (let ((s4-0 (-> *level-task-data* s5-0))) + (when (!= s4-0 #f) + (when (or (= *kernel-boot-message* 'play) (= (-> s4-0 level-name-id) (game-text-id misty-level-name))) + (dotimes (s3-0 (-> s4-0 nb-of-tasks)) + (if (= (get-task-status (-> s4-0 task-info s3-0 task-id)) (task-status invalid)) + (set! current-cells (+ current-cells 1)) + ) + ) + (set! total-cells (+ total-cells (-> s4-0 nb-of-tasks))) + (set! current-orbs (+ current-orbs (-> *game-info* money-per-level s5-0))) + (set! total-orbs (+ total-orbs (-> *game-counts* data s5-0 money-count))) + (let ((v1-20 (-> s4-0 buzzer-task-index))) + (when (!= v1-20 -1) + (set! current-buzzers (+ current-buzzers (buzzer-count *game-info* (-> s4-0 task-info v1-20 task-id)))) + (set! total-buzzers (+ total-buzzers (-> *game-counts* data s5-0 buzzer-count))) + ) + ) + ) + ) + ) + ) + (when the-progress + (set! (-> the-progress total-nb-of-power-cells) total-cells) + (set! (-> the-progress total-nb-of-buzzers) total-buzzers) + (set! (-> the-progress total-nb-of-orbs) total-orbs) + ) + (+ (/ (* 80.0 (the float current-cells)) (the float total-cells)) + (/ (* 10.0 (the float current-orbs)) (the float total-orbs)) + (/ (* 10.0 (the float current-buzzers)) (the float total-buzzers)) + ) + ) + +;; definition for symbol *progress-save-info*, type mc-slot-info +(define *progress-save-info* (new 'global 'mc-slot-info)) + +;; definition for method 33 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod initialize-icons progress ((obj progress)) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-0 (-> obj nb-of-icons))) + (set! (-> obj icons s5-0) (new 'static 'hud-icon)) + (let* ((s3-0 (get-process *default-dead-pool* manipy #x4000)) + (s4-0 (when s3-0 + (let ((t9-1 (method-of-type manipy activate))) + (t9-1 (the-as manipy s3-0) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-0 + manipy-init + (new 'static 'vector :w 1.0) + #f + *fuelcell-naked-sg* + #f + ) + (-> s3-0 ppointer) + ) + ) + ) + (when s4-0 + (set! (-> (the-as manipy (-> s4-0 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-0 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-0 0)) root scale) 0.006 0.006 0.006 1.0) + (if #f + (send-event (ppointer->process s4-0) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-0 icon) (the-as (pointer manipy) s4-0)) + (when s4-0 + (logior! (-> s4-0 0 mask) (process-mask pause)) + (logclear! (-> s4-0 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-0 0)) root trans z) 2048.0) + (set! (-> obj icons s5-0 icon-x) 256) + (set! (-> obj icons s5-0 icon-y) 77) + (set! (-> obj icons s5-0 icon-z) 0) + (set! (-> obj icons s5-0 scale-x) 0.006) + (set! (-> obj icons s5-0 scale-y) 0.006) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-1 (-> obj nb-of-icons))) + (set! (-> obj icons s5-1) (new 'static 'hud-icon)) + (let* ((s3-1 (get-process *default-dead-pool* manipy #x4000)) + (s4-1 (when s3-1 + (let ((t9-5 (method-of-type manipy activate))) + (t9-5 (the-as manipy s3-1) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-1 + manipy-init + (new 'static 'vector :w 1.0) + #f + *fuelcell-naked-sg* + #f + ) + (-> s3-1 ppointer) + ) + ) + ) + (when s4-1 + (set! (-> (the-as manipy (-> s4-1 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-1 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-1 0)) root scale) 0.006 0.006 0.006 1.0) + (if #f + (send-event (ppointer->process s4-1) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-1 icon) (the-as (pointer manipy) s4-1)) + (when s4-1 + (logior! (-> s4-1 0 mask) (process-mask pause)) + (logclear! (-> s4-1 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-1 0)) root trans z) 2048.0) + (set! (-> obj icons s5-1 icon-x) 256) + (set! (-> obj icons s5-1 icon-y) 77) + (set! (-> obj icons s5-1 icon-z) 0) + (set! (-> obj icons s5-1 scale-x) 0.006) + (set! (-> obj icons s5-1 scale-y) 0.006) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-2 (-> obj nb-of-icons))) + (set! (-> obj icons s5-2) (new 'static 'hud-icon)) + (let* ((s3-2 (get-process *default-dead-pool* manipy #x4000)) + (s4-2 (when s3-2 + (let ((t9-9 (method-of-type manipy activate))) + (t9-9 (the-as manipy s3-2) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-2 + manipy-init + (new 'static 'vector :w 1.0) + #f + *fuelcell-naked-sg* + #f + ) + (-> s3-2 ppointer) + ) + ) + ) + (when s4-2 + (set! (-> (the-as manipy (-> s4-2 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-2 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-2 0)) root scale) 0.006 0.006 0.006 1.0) + (if #f + (send-event (ppointer->process s4-2) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-2 icon) (the-as (pointer manipy) s4-2)) + (when s4-2 + (logior! (-> s4-2 0 mask) (process-mask pause)) + (logclear! (-> s4-2 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-2 0)) root trans z) 2048.0) + (set! (-> obj icons s5-2 icon-x) 256) + (set! (-> obj icons s5-2 icon-y) 77) + (set! (-> obj icons s5-2 icon-z) 0) + (set! (-> obj icons s5-2 scale-x) 0.006) + (set! (-> obj icons s5-2 scale-y) 0.006) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-3 (-> obj nb-of-icons))) + (set! (-> obj icons s5-3) (new 'static 'hud-icon)) + (let* ((s3-3 (get-process *default-dead-pool* manipy #x4000)) + (s4-3 (when s3-3 + (let ((t9-13 (method-of-type manipy activate))) + (t9-13 (the-as manipy s3-3) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-3 + manipy-init + (new 'static 'vector :w 1.0) + #f + *fuelcell-naked-sg* + #f + ) + (-> s3-3 ppointer) + ) + ) + ) + (when s4-3 + (set! (-> (the-as manipy (-> s4-3 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-3 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-3 0)) root scale) 0.006 0.006 0.006 1.0) + (if #f + (send-event (ppointer->process s4-3) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-3 icon) (the-as (pointer manipy) s4-3)) + (when s4-3 + (logior! (-> s4-3 0 mask) (process-mask pause)) + (logclear! (-> s4-3 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-3 0)) root trans z) 2048.0) + (set! (-> obj icons s5-3 icon-x) 256) + (set! (-> obj icons s5-3 icon-y) 77) + (set! (-> obj icons s5-3 icon-z) 0) + (set! (-> obj icons s5-3 scale-x) 0.006) + (set! (-> obj icons s5-3 scale-y) 0.006) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-4 (-> obj nb-of-icons))) + (set! (-> obj icons s5-4) (new 'static 'hud-icon)) + (let* ((s3-4 (get-process *default-dead-pool* manipy #x4000)) + (s4-4 (when s3-4 + (let ((t9-17 (method-of-type manipy activate))) + (t9-17 (the-as manipy s3-4) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-4 + manipy-init + (new 'static 'vector :w 1.0) + #f + *money-sg* + #f + ) + (-> s3-4 ppointer) + ) + ) + ) + (when s4-4 + (set! (-> (the-as manipy (-> s4-4 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-4 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-4 0)) root scale) 0.013 -0.015 0.013 1.0) + (if #f + (send-event (ppointer->process s4-4) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-4 icon) (the-as (pointer manipy) s4-4)) + (when s4-4 + (logior! (-> s4-4 0 mask) (process-mask pause)) + (logclear! (-> s4-4 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-4 0)) root trans z) 69632.0) + (set! (-> obj icons s5-4 icon-x) -320) + (set! (-> obj icons s5-4 icon-y) 253) + (set! (-> obj icons s5-4 icon-z) 0) + (set! (-> obj icons s5-4 scale-x) 0.013) + (set! (-> obj icons s5-4 scale-y) -0.015) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (when (< (-> obj nb-of-icons) 6) + (let ((s5-5 (-> obj nb-of-icons))) + (set! (-> obj icons s5-5) (new 'static 'hud-icon)) + (let* ((s3-5 (get-process *default-dead-pool* manipy #x4000)) + (s4-5 (when s3-5 + (let ((t9-21 (method-of-type manipy activate))) + (t9-21 (the-as manipy s3-5) obj 'manipy (the-as pointer #x70004000)) + ) + ((the-as (function process function object object object object object) run-function-in-process) + s3-5 + manipy-init + (new 'static 'vector :w 1.0) + #f + *money-sg* + #f + ) + (-> s3-5 ppointer) + ) + ) + ) + (when s4-5 + (set! (-> (the-as manipy (-> s4-5 0)) draw dma-add-func) dma-add-process-drawable-hud) + (set-vector! (-> (the-as manipy (-> s4-5 0)) root trans) 0.0 0.0 0.0 1.0) + (set-vector! (-> (the-as manipy (-> s4-5 0)) root scale) 0.008 -0.009 0.008 1.0) + (if #f + (send-event (ppointer->process s4-5) 'trans-hook #f) + ) + ) + (set! (-> obj icons s5-5 icon) (the-as (pointer manipy) s4-5)) + (when s4-5 + (logior! (-> s4-5 0 mask) (process-mask pause)) + (logclear! (-> s4-5 0 mask) (process-mask menu progress)) + (set! (-> (the-as manipy (-> s4-5 0)) root trans z) 1024.0) + (set! (-> obj icons s5-5 icon-x) -320) + (set! (-> obj icons s5-5 icon-y) 253) + (set! (-> obj icons s5-5 icon-z) 0) + (set! (-> obj icons s5-5 scale-x) 0.008) + (set! (-> obj icons s5-5 scale-y) -0.009) + ) + ) + ) + (+! (-> obj nb-of-icons) 1) + ) + (send-event (ppointer->process (-> obj icons 1 icon)) 'set-frame-num 2.5) + (send-event (ppointer->process (-> obj icons 2 icon)) 'set-frame-num 10.0) + (send-event (ppointer->process (-> obj icons 3 icon)) 'set-frame-num 15.5) + 0 + (none) + ) + +;; definition for method 48 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod enter! progress ((obj progress) (screen progress-screen) (option int)) + (when (!= (-> obj display-state) screen) + (set! (-> *progress-state* yes-no-choice) #f) + (set! (-> obj selected-option) #f) + (set! (-> obj option-index) option) + (set! (-> obj last-option-index-change) (-> *display* real-frame-counter)) + (set! (-> obj display-state) screen) + (set! (-> obj next-display-state) screen) + (set-transition-speed! obj) + (case (-> obj display-state) + (((progress-screen memcard-creating)) + (auto-save-command 'create-file 0 0 obj) + ) + (((progress-screen memcard-loading)) + (set! (-> *progress-state* last-slot-saved) (-> *progress-state* which)) + (sound-volume-off) + (auto-save-command 'restore 0 (-> *progress-state* which) obj) + ) + (((progress-screen memcard-saving)) + (set! (-> *progress-state* last-slot-saved) (-> *progress-state* which)) + (auto-save-command 'save 0 (-> *progress-state* which) obj) + ) + (((progress-screen memcard-formatting)) + (auto-save-command 'format-card 0 0 obj) + ) + (((progress-screen save-game) (progress-screen load-game)) + (set! (-> obj option-index) (max 0 (-> *progress-state* last-slot-saved))) + ) + (((progress-screen memcard-removed)) + (set! (-> *progress-state* last-slot-saved) 0) + 0 + ) + ) + ) + 0 + (none) + ) + +;; definition for method 45 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod push! progress ((obj progress)) + (let ((v1-0 (-> obj display-state-pos))) + (cond + ((< v1-0 5) + (set! (-> obj display-state-stack v1-0) (-> obj display-state)) + (set! (-> obj option-index-stack v1-0) (-> obj option-index)) + (set! (-> obj display-state-pos) (+ v1-0 1)) + ) + (else + (format #t "ERROR: Can't push any more states on the display-state-stack.~%") + ) + ) + ) + 0 + (none) + ) + +;; definition for method 46 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod pop! progress ((obj progress)) + (let ((v1-0 (-> obj display-state-pos))) + (cond + ((> v1-0 0) + (let ((a2-0 (+ v1-0 -1))) + (set! (-> obj display-state-pos) a2-0) + (enter! obj (-> obj display-state-stack a2-0) (-> obj option-index-stack a2-0)) + ) + ) + (else + (set-master-mode 'game) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 51 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod set-transition-progress! progress ((obj progress) (arg0 int)) + (set! (-> obj transition-offset) arg0) + (set! (-> obj transition-offset-invert) (- 512 arg0)) + (set! (-> obj transition-percentage) (* 0.001953125 (the float arg0))) + (set! (-> obj transition-percentage-invert) (- 1.0 (-> obj transition-percentage))) + 0 + (none) + ) + +;; definition for method 52 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod set-transition-speed! progress ((obj progress)) + (case (-> obj display-state) + (((progress-screen fuel-cell) + (progress-screen money) + (progress-screen buzzer) + (progress-screen load-game) + (progress-screen save-game) + (progress-screen save-game-title) + ) + (set! (-> obj transition-speed) 15.0) + ) + (else + (set! (-> obj transition-speed) 45.0) + ) + ) + 0 + (none) + ) + +;; definition for function progress-init-by-other +;; INFO: Return type mismatch object vs none. +(defbehavior progress-init-by-other progress () + (logclear! (-> self mask) (process-mask menu progress)) + (set! (-> self nb-of-particles) 0) + (set! (-> self max-nb-of-particles) 40) + (set! (-> self nb-of-icons) 0) + (set! (-> self in-out-position) 4096) + (set! (-> self current-debug-string) 0) + (set! (-> self current-debug-group) 0) + (set! (-> self display-level-index) 0) + (set! (-> self next-level-index) 0) + (set! (-> self option-index) 0) + (set! (-> self selected-option) #f) + (set! (-> self card-info) #f) + (set! (-> self last-option-index-change) (-> *display* real-frame-counter)) + (set! (-> self display-state-pos) 0) + (set! (-> self in-transition) #f) + (set! (-> self force-transition) #f) + (set! (-> self stat-transition) #f) + (set! (-> self level-transition) 0) + (set! (-> self left-side-x-scale) 0.0) + (set! (-> self left-side-y-scale) 0.0) + (set! (-> self right-side-x-scale) 0.0) + (set! (-> self right-side-y-scale) 0.0) + (dotimes (v1-6 5) + (set! (-> self display-state-stack v1-6) (progress-screen fuel-cell)) + ) + (init-game-options self) + (initialize-icons self) + (initialize-particles self) + (set! (-> self particle-state 0) 0) + (set! (-> self particle-state 1) 0) + (set! (-> self particle-state 2) 0) + (set! (-> self particle-state 3) 0) + (set! (-> self particle-state 4) 0) + (set! (-> self particle-state 5) 0) + (set! (-> self particle-state 6) 1) + (set! (-> self particle-state 7) 1) + (set! (-> self particle-state 8) 1) + (set! (-> self particle-state 9) 1) + (set! (-> self particle-state 10) 1) + (set! (-> self particle-state 11) 1) + (set! (-> self particle-state 12) 1) + (set! (-> self particle-state 13) 1) + (set! (-> self particle-state 14) 0) + (set! (-> self particle-state 15) 0) + (set! (-> self particle-state 16) 3) + (set! (-> self particle-state 17) 0) + (set! (-> self particle-state 18) 0) + (set! (-> self particle-state 19) 0) + (set! (-> self particle-state 20) 0) + (set! (-> self particle-state 21) 0) + (set! (-> self particle-state 22) 0) + (set! (-> self particle-state 23) 0) + (set! (-> self particle-state 24) 0) + (set! (-> self particle-state 25) 0) + (set! (-> self particle-state 26) 0) + (set! (-> self particle-state 27) 0) + (set! (-> self particle-state 28) 0) + (set! (-> self particle-state 29) 0) + (set! (-> self particle-state 30) 0) + (set! (-> self particle-state 31) 0) + (let ((gp-0 (new 'stack-no-clear 'quaternion))) + (quaternion-axis-angle! gp-0 (the-as float 0.0) (the-as float 1.0) (the-as float 0.0) (the-as float 16384.0)) + (quaternion*! (-> self icons 0 icon 0 root quat) gp-0 (-> self icons 0 icon 0 root quat)) + (quaternion-axis-angle! gp-0 (the-as float 0.0) (the-as float 1.0) (the-as float 0.0) (the-as float 32768.0)) + (quaternion*! (-> self icons 1 icon 0 root quat) gp-0 (-> self icons 1 icon 0 root quat)) + (quaternion-axis-angle! gp-0 (the-as float 0.0) (the-as float 1.0) (the-as float 0.0) (the-as float 49152.0)) + (quaternion*! (-> self icons 2 icon 0 root quat) gp-0 (-> self icons 2 icon 0 root quat)) + (quaternion-axis-angle! gp-0 (the-as float 0.0) (the-as float 1.0) (the-as float 0.0) (the-as float 0.0)) + (quaternion*! (-> self icons 3 icon 0 root quat) gp-0 (-> self icons 3 icon 0 root quat)) + ) + (adjust-ratios self (get-aspect-ratio) (get-video-mode)) + (adjust-icons self) + (set! (-> self event-hook) (-> progress-waiting event)) + (go progress-waiting) + (none) + ) + +;; definition for symbol *progress-stack*, type (pointer uint8) +(define *progress-stack* (the-as (pointer uint8) (malloc 'global #x3800))) + +;; definition for function activate-progress +;; INFO: Return type mismatch int vs none. +(defun activate-progress ((creator process) (screen progress-screen)) + (when *target* + (cond + ((not *progress-process*) + (when (progress-allowed?) + (hide-hud) + (make-levels-with-tasks-available-to-progress) + (disable-level-text-file-loading) + (set! (-> *progress-state* starting-state) screen) + (let ((s4-0 (get-process *default-dead-pool* progress #x4000))) + (set! *progress-process* + (the-as (pointer progress) (when s4-0 + (let ((t9-5 (method-of-type progress activate))) + (t9-5 (the-as progress s4-0) creator 'progress (&-> *progress-stack* 14336)) + ) + (run-now-in-process s4-0 progress-init-by-other) + (-> s4-0 ppointer) + ) + ) + ) + ) + (let ((s5-1 *progress-process*)) + (set! (-> s5-1 0 completion-percentage) (calculate-completion (-> s5-1 0))) + (set! *master-mode* 'progress) + (let ((s4-1 (-> *target* current-level))) + (cond + ((!= *kernel-boot-message* 'play) + (set! (-> s5-1 0 display-level-index) 4) + ) + ((or (= s4-1 #f) (< (length *level-task-data-remap*) (-> s4-1 info index))) + (set! (-> s5-1 0 display-level-index) 0) + 0 + ) + (else + (set! (-> s5-1 0 display-level-index) (-> *level-task-data-remap* (+ (-> s4-1 info index) -1))) + ) + ) + ) + (set! (-> s5-1 0 next-level-index) (-> s5-1 0 display-level-index)) + (set! (-> s5-1 0 display-state) (progress-screen invalid)) + (set-transition-progress! (-> s5-1 0) 512) + (set! (-> s5-1 0 task-index) (get-next-task-up -1 (-> s5-1 0 display-level-index))) + ) + ) + (when *progress-process* + (enter! (-> *progress-process* 0) screen 0) + (set! (-> *progress-process* 0 card-info) #f) + ) + ) + (else + (push! (-> *progress-process* 0)) + (set! (-> *progress-process* 0 next-display-state) screen) + (set! (-> *progress-process* 0 card-info) #f) + ) + ) + ) + 0 + (none) + ) + +;; definition for function deactivate-progress +;; INFO: Return type mismatch int vs none. +(defun deactivate-progress () + (when (and *progress-process* (= (-> *progress-process* 0 next-state name) 'progress-gone)) + (copy-settings-from-target! *setting-control*) + (dotimes (gp-0 (-> *progress-process* 0 nb-of-particles)) + (kill-and-free-particles (-> *progress-process* 0 particles gp-0 part)) + (set! (-> *progress-process* 0 particles gp-0 part matrix) -1) + ) + (set! (-> *progress-process* 0 nb-of-particles) 0) + (deactivate (-> *progress-process* 0)) + (set! *progress-process* (the-as (pointer progress) #f)) + (enable-level-text-file-loading) + ) + 0 + (none) + ) + +;; definition for function hide-progress-screen +;; INFO: Return type mismatch int vs none. +(defun hide-progress-screen () + (if *progress-process* + (send-event (ppointer->process *progress-process*) 'go-away) + ) + 0 + (none) + ) + +;; definition for function hide-progress-icons +;; INFO: Return type mismatch int vs none. +(defun hide-progress-icons () + (let ((v1-0 6)) + (dotimes (a0-0 8) + (set! (-> *progress-process* 0 particles v1-0 init-pos x) -320.0) + (+! v1-0 1) + ) + ) + (set! (-> *progress-process* 0 particles 5 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 14 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 15 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 19 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 20 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 21 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 22 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 23 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 24 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 25 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 26 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 27 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 28 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 29 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 30 init-pos x) -320.0) + (set! (-> *progress-process* 0 particles 31 init-pos x) -320.0) + (set! (-> *progress-process* 0 icons 4 icon-x) -320) + 0 + (none) + ) + +;; definition for method 7 of type game-count-info +(defmethod relocate game-count-info ((obj game-count-info) (arg0 int)) + (set! *game-counts* obj) + obj + ) + +;; definition for method 7 of type progress +;; INFO: Return type mismatch process vs progress. +(defmethod relocate progress ((obj progress) (arg0 int)) + (dotimes (v1-0 (-> obj nb-of-particles)) + (when (-> obj particles v1-0 part) + (if (nonzero? (-> obj particles v1-0 part)) + (set! (-> obj particles v1-0 part) + (the-as sparticle-launch-control (&+ (the-as pointer (-> obj particles v1-0 part)) arg0)) + ) + ) + ) + ) + (the-as progress ((method-of-type process relocate) obj arg0)) + ) + +;; definition for method 21 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod adjust-sprites progress ((obj progress)) + (let ((f0-1 (* 0.00024414062 (the float (-> obj in-out-position))))) + (set! (-> obj particles 2 init-pos x) (the float (+ (-> obj right-x-offset) 409 (the int (* 301.5 f0-1))))) + (set! (-> obj particles 1 init-pos x) (the float (+ (-> obj left-x-offset) 59))) + (set! (-> obj left-side-x-scale) (* 4096.0 (+ (/ 3.5 (-> obj sides-x-scale)) (* 10.0 f0-1)))) + (set! (-> obj left-side-y-scale) (* 4096.0 (+ (-> obj sides-y-scale) (* 10.0 f0-1)))) + (set! (-> obj right-side-x-scale) (* 4096.0 (+ (/ 6.0 (-> obj sides-x-scale)) (* 4.0 f0-1)))) + (set! (-> obj right-side-y-scale) (* 4096.0 (+ (-> obj sides-y-scale) (* 4.0 f0-1)))) + ) + (dotimes (s5-0 (-> obj nb-of-particles)) + (set! (-> obj particles s5-0 pos x) (+ -256.0 (-> obj particles s5-0 init-pos x))) + (set! (-> obj particles s5-0 pos y) + (* 0.5 (- (* (-> obj particles s5-0 init-pos y) (-> *video-parms* relative-y-scale)) + (the float (-> *video-parms* screen-sy)) + ) + ) + ) + (set! (-> obj particles s5-0 pos z) (-> obj particles s5-0 init-pos z)) + (if (> (-> obj particles s5-0 part matrix) 0) + (set-vector! + (sprite-get-user-hvdf (-> obj particles s5-0 part matrix)) + (the float (+ (the int (-> obj particles s5-0 pos x)) 2048)) + (the float (+ (the int (-> obj particles s5-0 pos y)) 2048)) + (- (-> *math-camera* hvdf-off z) (* 1024.0 (-> obj particles s5-0 pos z))) + (-> *math-camera* hvdf-off w) + ) + ) + (spawn (-> obj particles s5-0 part) *null-vector*) + ) + 0 + (none) + ) + +;; definition for method 22 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod adjust-icons progress ((obj progress)) + (dotimes (v1-0 (-> obj nb-of-icons)) + (when (>= v1-0 4) + (set-vector! + (-> obj icons v1-0 icon 0 root scale) + (* (-> obj icons v1-0 scale-x) (-> *video-parms* relative-x-scale)) + (* (-> obj icons v1-0 scale-y) (-> *video-parms* relative-y-scale)) + (* (-> obj icons v1-0 scale-x) (-> *video-parms* relative-x-scale)) + 1.0 + ) + (set! (-> obj icons v1-0 icon 0 root trans x) (the float (+ (-> obj icons v1-0 icon-x) -256))) + (set! (-> obj icons v1-0 icon 0 root trans y) + (* (-> *video-parms* relative-y-scale) + (- (* (-> *video-parms* relative-y-scale) (the float (-> obj icons v1-0 icon-y))) + (the float (-> *video-parms* screen-sy)) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 23 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod adjust-ratios progress ((obj progress) (aspect symbol) (video-mode symbol)) + (case aspect + (('aspect4x3) + (set! (-> obj sides-x-scale) 1.0) + (set! (-> obj sides-y-scale) 13.0) + (set! (-> obj left-x-offset) 0) + (set! (-> obj right-x-offset) 0) + (set! (-> obj button-scale) 1.0) + (set! (-> obj slot-scale) 8192.0) + (set! (-> obj small-orb-y-offset) 58) + (set! (-> obj icons 5 scale-x) 0.008) + (set! (-> obj icons 5 scale-y) -0.009) + (set! (-> obj big-orb-y-offset) 243) + (set! (-> obj icons 4 scale-x) 0.013) + (set! (-> obj icons 4 scale-y) -0.015) + ) + (('aspect16x9) + (set! (-> obj sides-x-scale) 1.2) + (set! (-> obj sides-y-scale) 9.8) + (set! (-> obj left-x-offset) -10) + (set! (-> obj right-x-offset) 17) + (set! (-> obj button-scale) 1.05) + (set! (-> obj slot-scale) 6144.0) + (set! (-> obj small-orb-y-offset) 59) + (set! (-> obj icons 5 scale-x) 0.008) + (set! (-> obj icons 5 scale-y) -0.0098) + (set! (-> obj big-orb-y-offset) 255) + (set! (-> obj icons 4 scale-x) 0.017) + (set! (-> obj icons 4 scale-y) -0.0205) + ) + ) + (when (= video-mode 'pal) + (set! (-> obj icons 5 scale-y) (* 1.15 (-> obj icons 5 scale-y))) + (set! (-> obj icons 4 scale-x) (* 1.05 (-> obj icons 4 scale-x))) + (set! (-> obj icons 4 scale-y) (* (-> obj icons 4 scale-y) (the-as float (if (= aspect 'aspect16x9) + 1.18 + 1.15 + ) + ) + ) + ) + (+! (-> obj big-orb-y-offset) (if (= aspect 'aspect16x9) + 3 + 2 + ) + ) + ) + 0 + (none) + ) + +;; definition for method 32 of type progress +(defmethod dummy-32 progress ((obj progress)) + (let ((v1-2 (-> *progress-process* 0 display-state)) + (a1-1 (-> *progress-state* starting-state)) + ) + (and (= (-> obj next-state name) 'progress-normal) + (not (-> obj in-transition)) + (not (-> obj selected-option)) + (or (= v1-2 (progress-screen fuel-cell)) + (= v1-2 (progress-screen money)) + (= v1-2 (progress-screen buzzer)) + (and (or (= a1-1 (progress-screen fuel-cell)) + (= a1-1 (progress-screen money)) + (= a1-1 (progress-screen buzzer)) + (= a1-1 (progress-screen title)) + ) + (or (= v1-2 (progress-screen settings)) + (= v1-2 (progress-screen game-settings)) + (= v1-2 (progress-screen graphic-settings)) + (= v1-2 (progress-screen sound-settings)) + (= v1-2 (progress-screen title)) + (= v1-2 (progress-screen settings-title)) + ) + ) + ) + ) + ) + ) + +;; definition for method 19 of type progress +;; INFO: Return type mismatch object vs symbol. +(defmethod dummy-19 progress ((obj progress)) + (the-as symbol (and *progress-process* (zero? (-> *progress-process* 0 in-out-position)))) + ) + +;; definition for method 20 of type progress +(defmethod hidden? progress ((obj progress)) + (or (not *progress-process*) (= (-> *progress-process* 0 in-out-position) 4096)) + ) + +;; failed to figure out what this is: +(defstate progress-waiting (progress) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('go-away) + (go progress-gone) + ) + ) + ) + :code + (behavior () + (while #t + (when (hud-hidden?) + (dotimes (gp-0 (-> self nb-of-particles)) + (if (= (-> self particles gp-0 part matrix) -1) + (set! (-> self particles gp-0 part matrix) (sprite-allocate-user-hvdf)) + ) + ) + (set-setting! *setting-control* self 'common-page 'set (the-as float 0.0) 1) + (suspend) + (go progress-coming-in) + ) + (suspend) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate progress-gone (progress) + :code + (behavior () + (clear-pending-settings-from-process *setting-control* self 'process-mask) + (copy-settings-from-target! *setting-control*) + (logior! (-> self mask) (process-mask sleep)) + (suspend) + 0 + (none) + ) + ) + +;; definition for method 53 of type progress +(defmethod dummy-53 progress ((obj progress) (arg0 progress-screen)) + (let ((s4-0 (-> obj card-info)) + (gp-0 arg0) + ) + (when s4-0 + (case arg0 + (((progress-screen memcard-no-space) + (progress-screen memcard-not-inserted) + (progress-screen memcard-not-formatted) + ) + (cond + ((zero? (-> s4-0 handle)) + (set! gp-0 (progress-screen memcard-not-inserted)) + ) + ((zero? (-> s4-0 formatted)) + (cond + ((or (zero? (-> obj display-state-pos)) + (and (!= (-> *progress-state* starting-state) 27) (nonzero? (-> *progress-state* starting-state))) + ) + (set-master-mode 'game) + ) + (else + (if (!= arg0 (progress-screen memcard-not-formatted)) + (set! gp-0 (progress-screen memcard-format)) + ) + ) + ) + ) + ((and (zero? (-> s4-0 inited)) (< (-> s4-0 mem-actual) (-> s4-0 mem-required))) + (set! gp-0 (progress-screen memcard-no-space)) + ) + ((or (zero? (-> obj display-state-pos)) + (and (!= (-> *progress-state* starting-state) 27) (nonzero? (-> *progress-state* starting-state))) + ) + (set-master-mode 'game) + ) + (else + (set! gp-0 (progress-screen save-game)) + ) + ) + ) + (((progress-screen memcard-insert)) + (if (= (-> s4-0 inited) 1) + (set! gp-0 (progress-screen load-game)) + ) + ) + ) + (cond + ((zero? (-> s4-0 handle)) + (cond + ((-> *setting-control* current auto-save) + (set! gp-0 (progress-screen memcard-removed)) + ) + (else + (cond + ((= arg0 (progress-screen load-game)) + (set! gp-0 (progress-screen memcard-insert)) + ) + ((or (= arg0 (progress-screen memcard-format)) + (= arg0 (progress-screen memcard-no-space)) + (= arg0 (progress-screen memcard-not-formatted)) + (= arg0 (progress-screen save-game)) + (= arg0 (progress-screen save-game-title)) + (= arg0 (progress-screen memcard-no-data)) + (= arg0 (progress-screen memcard-data-exists)) + ) + (set! gp-0 (progress-screen memcard-not-inserted)) + ) + ) + ) + ) + ) + ((zero? (-> s4-0 formatted)) + (case arg0 + (((progress-screen load-game)) + (set! gp-0 (progress-screen memcard-insert)) + ) + (((progress-screen save-game) (progress-screen save-game-title)) + (set! gp-0 (progress-screen memcard-format)) + ) + ) + ) + ((zero? (-> s4-0 inited)) + (case arg0 + (((progress-screen save-game) (progress-screen save-game-title)) + (if (>= (-> s4-0 mem-actual) (-> s4-0 mem-required)) + (set! gp-0 (progress-screen memcard-no-data)) + (set! gp-0 (progress-screen memcard-no-space)) + ) + ) + (((progress-screen load-game)) + (set! gp-0 (progress-screen memcard-insert)) + ) + ) + ) + ) + ) + gp-0 + ) + ) + +;; definition for method 31 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod dummy-31 progress ((obj progress)) + (let ((s5-0 (-> obj card-info))) + (when (and s5-0 (not (-> obj in-transition))) + (when (or (cpad-pressed? 0 x) (cpad-pressed? 0 circle)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons circle)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons circle)) + (case (-> obj display-state) + (((progress-screen load-game)) + (cond + ((< (-> obj option-index) 4) + (when (nonzero? (-> s5-0 file (-> obj option-index) present)) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> *progress-state* which) (-> obj option-index)) + (set! (-> obj next-display-state) (progress-screen memcard-loading)) + ) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + (((progress-screen save-game) (progress-screen save-game-title)) + (cond + ((< (-> obj option-index) 4) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> *progress-state* which) (-> obj option-index)) + (if (zero? (-> s5-0 file (-> obj option-index) present)) + (set! (-> obj next-display-state) (progress-screen memcard-saving)) + (set! (-> obj next-display-state) (progress-screen memcard-data-exists)) + ) + ) + ((and (= (-> obj display-state) (progress-screen save-game-title)) (= (-> obj option-index) 4)) + (sound-play-by-name (static-sound-name "starts-options") (new-sound-id) 1024 0 0 1 #t) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "intro-start") + (set-master-mode 'game) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + (((progress-screen memcard-insert)) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + (((progress-screen memcard-data-exists)) + (cond + ((-> *progress-state* yes-no-choice) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen memcard-saving)) + ) + ((begin + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (= (-> obj display-state-stack 0) (progress-screen title)) + ) + (set! (-> obj next-display-state) (progress-screen save-game-title)) + ) + (else + (set! (-> obj next-display-state) (progress-screen save-game)) + ) + ) + ) + (((progress-screen memcard-no-data)) + (cond + ((-> *progress-state* yes-no-choice) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen memcard-creating)) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "intro-start") + (set-master-mode 'game) + ) + ) + ) + (((progress-screen memcard-no-space) + (progress-screen memcard-not-inserted) + (progress-screen memcard-not-formatted) + ) + (cond + ((= (-> obj display-state-stack 0) (progress-screen title)) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "intro-start") + (set-master-mode 'game) + ) + ((nonzero? (-> obj display-state-stack 0)) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set-master-mode 'game) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + (((progress-screen memcard-error-loading) + (progress-screen memcard-error-saving) + (progress-screen memcard-error-formatting) + (progress-screen memcard-error-creating) + (progress-screen memcard-auto-save-error) + (progress-screen memcard-removed) + (progress-screen auto-save) + ) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + (((progress-screen pal-change-to-60hz)) + (cond + ((-> *progress-state* yes-no-choice) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> *setting-control* default video-mode) (-> *progress-state* video-mode-choice)) + (set! (-> obj video-mode-timeout) (-> *display* real-frame-counter)) + (set! (-> obj next-display-state) (progress-screen pal-now-60hz)) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> *progress-state* video-mode-choice) 'pal) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + (((progress-screen pal-now-60hz)) + (cond + ((not (-> *progress-state* yes-no-choice)) + (set! (-> *progress-state* video-mode-choice) 'pal) + (set! (-> *setting-control* default video-mode) (-> *progress-state* video-mode-choice)) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + ) + (else + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + ) + ) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + (((progress-screen no-disc) (progress-screen bad-disc)) + (when (is-cd-in?) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + (((progress-screen quit)) + (cond + ((-> *progress-state* yes-no-choice) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "title-start") + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + (((progress-screen memcard-format)) + (cond + ((-> *progress-state* yes-no-choice) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen memcard-formatting)) + ) + ((= (-> obj display-state-stack 0) (progress-screen title)) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "intro-start") + (set-master-mode 'game) + ) + (else + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 29 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod dummy-29 progress ((obj progress)) + (mc-get-slot-info 0 *progress-save-info*) + (set! (-> obj card-info) *progress-save-info*) + (let ((s5-0 (-> *options-remap* (-> obj display-state)))) + (when (and s5-0 (not (-> obj in-transition))) + (cond + ((cpad-hold? 0 up) + (cond + ((cpad-pressed? 0 up) + (when (not (-> obj selected-option)) + (if (!= (length s5-0) 1) + (sound-play-by-name (static-sound-name "cursor-up-down") (new-sound-id) 1024 0 0 1 #t) + ) + (set! (-> obj last-option-index-change) (-> *display* real-frame-counter)) + (if (> (-> obj option-index) 0) + (+! (-> obj option-index) -1) + (set! (-> obj option-index) (+ (length s5-0) -1)) + ) + ) + ) + (else + (when (-> obj selected-option) + (let ((v1-34 #f)) + (case (-> s5-0 (-> obj option-index) option-type) + ((3) + (when (< -48 (-> *setting-control* current screeny)) + (set! v1-34 #t) + (+! (-> *setting-control* default screeny) -1) + ) + ) + ) + (when v1-34 + (when (< 90 (- (-> *display* real-frame-counter) (-> *progress-state* last-slider-sound))) + (set! (-> *progress-state* last-slider-sound) (-> *display* real-frame-counter)) + (sound-play-by-name (static-sound-name "slider2001") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ) + ) + ) + ) + ((cpad-hold? 0 down) + (cond + ((cpad-pressed? 0 down) + (when (not (-> obj selected-option)) + (if (!= (length s5-0) 1) + (sound-play-by-name (static-sound-name "cursor-up-down") (new-sound-id) 1024 0 0 1 #t) + ) + (set! (-> obj last-option-index-change) (-> *display* real-frame-counter)) + (cond + ((< (-> obj option-index) (+ (length s5-0) -1)) + (+! (-> obj option-index) 1) + ) + (else + (set! (-> obj option-index) 0) + 0 + ) + ) + ) + ) + (else + (when (-> obj selected-option) + (let ((v1-69 #f)) + (case (-> s5-0 (-> obj option-index) option-type) + ((3) + (when (< (-> *setting-control* current screeny) 48) + (set! v1-69 #t) + (+! (-> *setting-control* default screeny) 1) + ) + ) + ) + (when v1-69 + (when (< 90 (- (-> *display* real-frame-counter) (-> *progress-state* last-slider-sound))) + (set! (-> *progress-state* last-slider-sound) (-> *display* real-frame-counter)) + (sound-play-by-name (static-sound-name "slider2001") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ) + ) + ) + ) + ((cpad-hold? 0 left) + (cond + ((cpad-pressed? 0 left) + (when (or (-> obj selected-option) (= (-> s5-0 (-> obj option-index) option-type) 7)) + (let ((s4-5 #f)) + (case (-> s5-0 (-> obj option-index) option-type) + ((2 7) + (when (not (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + (set! s4-5 #t) + (if (= (-> s5-0 (-> obj option-index) value-to-modify) (&-> *setting-control* current vibration)) + (cpad-set-buzz! (-> *cpad-list* cpads 0) 1 255 90) + ) + ) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) #t) + ) + ((4) + (set! s4-5 (= (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'aspect16x9)) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'aspect4x3) + ) + ((5) + (set! s4-5 (= (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'ntsc)) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'pal) + ) + ((1) + (if (> (the-as int (-> (the-as (pointer uint64) (-> s5-0 (-> obj option-index) value-to-modify)))) 0) + (+! (-> (the-as (pointer uint64) (-> s5-0 (-> obj option-index) value-to-modify))) -1) + (set! (-> (the-as (pointer int64) (-> s5-0 (-> obj option-index) value-to-modify))) + (if (and (zero? (scf-get-territory)) + (not (and (= *progress-cheat* 'language) (cpad-hold? 0 l2) (cpad-hold? 0 r2))) + ) + 4 + 5 + ) + ) + ) + (set! (-> obj language-transition) #t) + (set! (-> obj language-direction) #t) + (set! s4-5 #t) + ) + ) + (if s4-5 + (sound-play-by-name (static-sound-name "cursor-l-r") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ) + (else + (when (-> obj selected-option) + (let ((v1-157 #f)) + (let ((a0-101 (-> s5-0 (-> obj option-index) option-type))) + (cond + ((zero? a0-101) + (cond + ((>= (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (+ 1.0 (-> s5-0 (-> obj option-index) param1)) + ) + (set! (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (+ -1.0 (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + (set! v1-157 #t) + ) + ((< (-> s5-0 (-> obj option-index) param1) + (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + ) + (set! (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (-> s5-0 (-> obj option-index) param1) + ) + (set! v1-157 #t) + ) + ) + ) + ((= a0-101 3) + (when (< -96 (-> *setting-control* default screenx)) + (set! v1-157 #t) + (+! (-> *setting-control* default screenx) -1) + ) + ) + ) + ) + (when v1-157 + (let ((f30-0 100.0)) + (case (-> s5-0 (-> obj option-index) name) + (((game-text-id music-volume) (game-text-id speech-volume)) + (set! f30-0 (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + (when (< 90 (- (-> *display* real-frame-counter) (-> *progress-state* last-slider-sound))) + (set! (-> *progress-state* last-slider-sound) (-> *display* real-frame-counter)) + (sound-play-by-name (static-sound-name "slider2001") (new-sound-id) (the int (* 10.24 f30-0)) 0 0 1 #t) + ) + ) + ) + ) + ) + ) + ) + ) + ((cpad-hold? 0 right) + (cond + ((cpad-pressed? 0 right) + (when (or (-> obj selected-option) (= (-> s5-0 (-> obj option-index) option-type) 7)) + (let ((v1-217 (the-as object #f))) + (case (-> s5-0 (-> obj option-index) option-type) + ((2 7) + (set! v1-217 (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) #f) + ) + ((4) + (set! v1-217 (= (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'aspect4x3)) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'aspect16x9) + ) + ((5) + (set! v1-217 (= (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'pal)) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) 'ntsc) + ) + ((1) + (let ((v1-243 (if (and (zero? (scf-get-territory)) + (not (and (= *progress-cheat* 'language) (cpad-hold? 0 l2) (cpad-hold? 0 r2))) + ) + 4 + 5 + ) + ) + ) + (cond + ((< (the-as int (-> (the-as (pointer uint64) (-> s5-0 (-> obj option-index) value-to-modify)))) v1-243) + (+! (-> (the-as (pointer uint64) (-> s5-0 (-> obj option-index) value-to-modify))) 1) + ) + (else + (set! (-> (the-as (pointer int64) (-> s5-0 (-> obj option-index) value-to-modify))) 0) + 0 + ) + ) + ) + (set! (-> obj language-transition) #t) + (set! (-> obj language-direction) #f) + (set! v1-217 #t) + ) + ) + (if v1-217 + (sound-play-by-name (static-sound-name "cursor-l-r") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ) + (else + (when (-> obj selected-option) + (let ((v1-263 #f)) + (let ((a0-177 (-> s5-0 (-> obj option-index) option-type))) + (cond + ((zero? a0-177) + (cond + ((>= (+ -1.0 (-> s5-0 (-> obj option-index) param2)) + (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + ) + (set! (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (+ 1.0 (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + (set! v1-263 #t) + ) + ((< (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (-> s5-0 (-> obj option-index) param2) + ) + (set! (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (-> s5-0 (-> obj option-index) param2) + ) + (set! v1-263 #t) + ) + ) + ) + ((= a0-177 3) + (when (< (-> *setting-control* default screenx) 96) + (set! v1-263 #t) + (+! (-> *setting-control* default screenx) 1) + ) + ) + ) + ) + (when v1-263 + (let ((f30-1 100.0)) + (case (-> s5-0 (-> obj option-index) name) + (((game-text-id music-volume) (game-text-id speech-volume)) + (set! f30-1 (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + (when (< 90 (- (-> *display* real-frame-counter) (-> *progress-state* last-slider-sound))) + (set! (-> *progress-state* last-slider-sound) (-> *display* real-frame-counter)) + (sound-play-by-name (static-sound-name "slider2001") (new-sound-id) (the int (* 10.24 f30-1)) 0 0 1 #t) + ) + ) + ) + ) + ) + ) + ) + ) + ((or (cpad-pressed? 0 square) (cpad-pressed? 0 triangle)) + (cond + ((-> obj selected-option) + (let ((v1-319 (-> s5-0 (-> obj option-index) option-type))) + (cond + ((zero? v1-319) + (set! (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + (-> *progress-state* slider-backup) + ) + ) + ((= v1-319 1) + (set! (-> (the-as (pointer int64) (-> s5-0 (-> obj option-index) value-to-modify))) + (-> *progress-state* language-backup) + ) + ) + ((= v1-319 2) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) + (-> *progress-state* on-off-backup) + ) + ) + ((= v1-319 3) + (set! (-> *setting-control* default screenx) (-> *progress-state* center-x-backup)) + (set! (-> *setting-control* default screeny) (-> *progress-state* center-y-backup)) + ) + ((or (= v1-319 4) (= v1-319 5)) + (set! (-> (the-as (pointer symbol) (-> s5-0 (-> obj option-index) value-to-modify)) 0) + (-> *progress-state* aspect-ratio-backup) + ) + ) + ) + ) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj selected-option) #f) + ) + ((or (dummy-32 obj) + (= (-> obj display-state) (progress-screen load-game)) + (= (-> obj display-state) (progress-screen save-game)) + (= (-> obj display-state) (progress-screen save-game-title)) + ) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons square)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons square)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons triangle)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons triangle)) + (if (= (-> obj display-state) (progress-screen settings)) + (sound-play-by-name (static-sound-name "menu-stats") (new-sound-id) 1024 0 0 1 #t) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + ) + (load-level-text-files (-> *level-task-data* (-> obj display-level-index) text-group-index)) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + ((or (cpad-pressed? 0 x) (cpad-pressed? 0 circle)) + (cond + ((not (-> obj selected-option)) + (cond + ((= (-> s5-0 (-> obj option-index) option-type) 6) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons circle)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons circle)) + (push! obj) + (sound-play-by-name (static-sound-name "select-option") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (the-as progress-screen (-> s5-0 (-> obj option-index) param3))) + (case (-> obj next-display-state) + (((progress-screen load-game) (progress-screen save-game) (progress-screen save-game-title)) + (set! (-> obj next-display-state) (dummy-53 obj (-> obj next-display-state))) + ) + ) + ) + ((= (-> s5-0 (-> obj option-index) option-type) 8) + (cond + ((= (-> s5-0 (-> obj option-index) name) (game-text-id exit-demo)) + (set! *master-exit* 'force) + (set-master-mode 'game) + ) + ((= (-> s5-0 (-> obj option-index) name) (game-text-id back)) + (if (= (-> obj display-state) (progress-screen settings)) + (sound-play-by-name (static-sound-name "menu-stats") (new-sound-id) 1024 0 0 1 #t) + (sound-play-by-name (static-sound-name "cursor-options") (new-sound-id) 1024 0 0 1 #t) + ) + (load-level-text-files (-> *level-task-data* (-> obj display-level-index) text-group-index)) + (set! (-> obj next-display-state) (progress-screen invalid)) + ) + ) + ) + ((!= (-> s5-0 (-> obj option-index) option-type) 7) + (let ((v1-427 (-> s5-0 (-> obj option-index) option-type))) + (cond + ((zero? v1-427) + (set! (-> *progress-state* slider-backup) + (-> (the-as (pointer float) (-> s5-0 (-> obj option-index) value-to-modify))) + ) + ) + ((= v1-427 1) + (set! (-> *progress-state* language-backup) + (the-as int (-> (the-as (pointer uint64) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + ((= v1-427 2) + (set! (-> *progress-state* on-off-backup) + (the-as symbol (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + ((= v1-427 3) + (set! (-> *progress-state* center-x-backup) (-> *setting-control* default screenx)) + (set! (-> *progress-state* center-y-backup) (-> *setting-control* default screeny)) + ) + ((or (= v1-427 4) (= v1-427 5)) + (set! (-> *progress-state* aspect-ratio-backup) + (the-as symbol (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + ) + ) + (sound-play-by-name (static-sound-name "select-option") (new-sound-id) 1024 0 0 1 #t) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons x)) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons circle)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons circle)) + (set! (-> obj selected-option) #t) + (when (= (-> s5-0 (-> obj option-index) option-type) 1) + (set! (-> obj language-selection) (the-as uint (-> *setting-control* current language))) + (set! (-> obj language-direction) #t) + (set! (-> obj language-transition) #f) + (set! (-> obj language-x-offset) 0) + 0 + ) + ) + ) + ) + (else + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj selected-option) #f) + (case (-> s5-0 (-> obj option-index) option-type) + ((4) + (set! (-> *setting-control* default aspect-ratio) + (the-as symbol (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + ((5) + (case (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify))) + (('pal) + (set! (-> *setting-control* default video-mode) + (the-as symbol (-> (the-as (pointer uint32) (-> s5-0 (-> obj option-index) value-to-modify)))) + ) + ) + (('ntsc) + (push! obj) + (set! (-> obj next-display-state) (progress-screen pal-change-to-60hz)) + ) + ) + ) + ((1) + (if (not (-> obj language-transition)) + (load-level-text-files (-> obj display-level-index)) + ) + ) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 30 of type progress +;; INFO: Return type mismatch int vs none. +(defmethod respond-progress progress ((obj progress)) + (when (not (-> obj in-transition)) + (cond + ((cpad-pressed? 0 up) + (let ((s5-0 (-> obj display-level-index))) + (set! (-> obj next-level-index) (get-next-level-down s5-0)) + (when (!= s5-0 (-> obj next-level-index)) + (sound-play-by-name (static-sound-name "cursor-up-down") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj level-transition) 2) + ) + ) + ) + ((cpad-pressed? 0 down) + (let ((s5-2 (-> obj next-level-index))) + (set! (-> obj next-level-index) (get-next-level-up s5-2)) + (when (!= s5-2 (-> obj next-level-index)) + (sound-play-by-name (static-sound-name "cursor-up-down") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj level-transition) 1) + ) + ) + ) + ((cpad-pressed? 0 square) + (when (nonzero? (-> obj display-state)) + (sound-play-by-name (static-sound-name "select-option") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen fuel-cell)) + (set! (-> obj stat-transition) #t) + ) + ) + ((cpad-pressed? 0 x) + (when (!= (-> obj display-state) (progress-screen money)) + (sound-play-by-name (static-sound-name "select-option") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen money)) + (set! (-> obj stat-transition) #t) + ) + ) + ((cpad-pressed? 0 triangle) + (when (!= (-> obj display-state) (progress-screen buzzer)) + (sound-play-by-name (static-sound-name "select-option") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj next-display-state) (progress-screen buzzer)) + (set! (-> obj stat-transition) #t) + ) + ) + ((cpad-pressed? 0 circle) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons circle)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons circle)) + (sound-play-by-name (static-sound-name "start-options") (new-sound-id) 1024 0 0 1 #t) + (push! obj) + (set! (-> obj next-display-state) (progress-screen settings)) + ) + ((= (-> obj display-state) (progress-screen fuel-cell)) + (cond + ((cpad-pressed? 0 left) + (let ((s5-8 (-> obj task-index))) + (set! (-> obj task-index) (get-next-task-down (-> obj task-index) (-> obj display-level-index))) + (if (!= s5-8 (-> obj task-index)) + (sound-play-by-name (static-sound-name "cursor-l-r") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ((cpad-pressed? 0 right) + (let ((s5-10 (-> obj task-index))) + (set! (-> obj task-index) (get-next-task-up (-> obj task-index) (-> obj display-level-index))) + (if (!= s5-10 (-> obj task-index)) + (sound-play-by-name (static-sound-name "cursor-l-r") (new-sound-id) 1024 0 0 1 #t) + ) + ) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate progress-normal (progress) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-0 none)) + (let ((v1-0 arg2)) + (the-as object (cond + ((= v1-0 'go-away) + (go progress-going-out) + ) + ((= v1-0 'notify) + (cond + ((= (-> arg3 param 0) 'done) + (case (-> self display-state) + (((progress-screen memcard-saving)) + (cond + ((= (-> self display-state-stack 0) (progress-screen title)) + (let ((gp-1 (-> *setting-control* default auto-save))) + (sound-volume-off) + (set! (-> *game-info* mode) 'play) + (initialize! *game-info* 'game (the-as game-save #f) "intro-start") + (set! (-> *setting-control* default auto-save) gp-1) + ) + (set-master-mode 'game) + ) + (else + (set! v0-0 (the-as none -1)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + ) + ) + (((progress-screen memcard-formatting)) + (set! (-> self force-transition) #t) + (set! v0-0 (the-as none 15)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + (((progress-screen memcard-creating)) + (cond + ((= (-> self display-state-stack 0) (progress-screen title)) + (set! v0-0 (the-as none 18)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + ) + (else + (set! v0-0 (the-as none 17)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + ) + ) + v0-0 + ) + ) + ) + ((= (-> arg3 param 0) 'error) + (let ((t9-4 format) + (a0-17 #t) + (a1-2 "ERROR NOTIFY: ~S ~D~%") + (v1-13 (-> arg3 param 1)) + ) + (t9-4 + a0-17 + a1-2 + (cond + ((= v1-13 17) + "no-auto-save" + ) + ((= v1-13 16) + "no-process" + ) + ((= v1-13 15) + "bad-version" + ) + ((= v1-13 14) + "no-space" + ) + ((= v1-13 13) + "no-save" + ) + ((= v1-13 12) + "no-file" + ) + ((= v1-13 11) + "no-format" + ) + ((= v1-13 10) + "no-last" + ) + ((= v1-13 9) + "no-card" + ) + ((= v1-13 8) + "no-memory" + ) + ((= v1-13 7) + "new-game" + ) + ((= v1-13 6) + "read-error" + ) + ((= v1-13 5) + "write-error" + ) + ((= v1-13 4) + "internal-error" + ) + ((= v1-13 3) + "format-failed" + ) + ((= v1-13 2) + "bad-handle" + ) + ((= v1-13 1) + "ok" + ) + ((zero? v1-13) + "busy" + ) + (else + "*unknown*" + ) + ) + (-> self display-state) + ) + ) + (case (-> arg3 param 1) + ((14) + (set! v0-0 (the-as none 7)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + (else + (case (-> self display-state) + (((progress-screen memcard-formatting)) + (set! v0-0 (the-as none 24)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + (((progress-screen memcard-creating)) + (set! v0-0 (the-as none 25)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + (((progress-screen memcard-saving)) + (set! v0-0 (the-as none 21)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + (((progress-screen memcard-loading)) + (set! v0-0 (the-as none 20)) + (set! (-> self next-display-state) (the-as progress-screen v0-0)) + v0-0 + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + :code + (behavior () + (while #t + (when (and (cpad-hold? 0 l1) (cpad-hold? 0 r1) *cheat-mode*) + (when (and (< (-> self task-index) (-> *level-task-data* (-> self display-level-index) nb-of-tasks)) + (>= (-> self task-index) 0) + ) + (let ((gp-0 (-> *level-task-data* (-> self display-level-index) task-info (-> self task-index) task-id))) + (close-specific-task! gp-0 (task-status need-resolution)) + (send-event *target* 'get-pickup 6 (the float gp-0)) + ) + ) + ) + (if (and (= (-> self display-state) (-> self next-display-state)) + (= (-> self display-level-index) (-> self next-level-index)) + ) + (set! (-> self transition-offset) + (seekl + (-> self transition-offset) + 0 + (* (the int (* (-> self transition-speed) (-> *display* time-adjust-ratio))) + (if (or (-> self stat-transition) (nonzero? (-> self level-transition))) + 2 + 1 + ) + ) + ) + ) + (set! (-> self transition-offset) + (seekl + (-> self transition-offset) + 512 + (* (the int (* (-> self transition-speed) (-> *display* time-adjust-ratio))) + (if (or (-> self stat-transition) (nonzero? (-> self level-transition))) + 2 + 1 + ) + ) + ) + ) + ) + (set-transition-progress! self (-> self transition-offset)) + (set! (-> self in-transition) (or (-> self force-transition) (nonzero? (-> self transition-offset)))) + (when (and (not (handle->process (-> *game-info* auto-save-proc))) + (or (-> self force-transition) (-> self in-transition)) + (>= (-> self transition-offset) (if (and (zero? (-> self level-transition)) + (nonzero? (-> self next-display-state)) + (!= (-> self next-display-state) 1) + (!= (-> self next-display-state) 2) + ) + 512 + 256 + ) + ) + ) + (if (>= (the-as int (-> self next-display-state)) 0) + (enter! self (-> self next-display-state) 0) + (pop! self) + ) + (set! (-> self display-level-index) (-> self next-level-index)) + (when (nonzero? (-> self level-transition)) + (set! (-> self task-index) (get-next-task-up -1 (-> self display-level-index))) + (case (-> self level-transition) + ((1) + (set! (-> self level-transition) 2) + ) + ((2) + (set! (-> self level-transition) 1) + ) + ) + ) + (set! (-> self force-transition) #f) + ) + (when (zero? (-> self transition-offset)) + (set! (-> self stat-transition) #f) + (set! (-> self level-transition) 0) + 0 + ) + (let ((gp-1 #f)) + (let ((v1-62 #f)) + (case (-> self display-state) + (((progress-screen fuel-cell) (progress-screen money) (progress-screen buzzer)) + (let ((s5-0 (-> self display-level-index))) + (when (and (< (mod (-> *display* real-frame-counter) 60) 30) + (zero? (-> *progress-process* 0 in-out-position)) + (not (-> self in-transition)) + (zero? (-> self transition-offset)) + ) + (set! gp-1 (!= s5-0 (get-next-level-up s5-0))) + (set! v1-62 (!= s5-0 (get-next-level-down s5-0))) + ) + ) + ) + ) + (set! (-> self particles 3 init-pos x) (the float (if v1-62 + (- 195 (-> *progress-process* 0 left-x-offset)) + -320 + ) + ) + ) + ) + (set! (-> self particles 4 init-pos x) (the float (if gp-1 + (- 195 (-> *progress-process* 0 left-x-offset)) + -320 + ) + ) + ) + ) + (dummy-29 self) + (set! (-> self next-display-state) (dummy-53 self (-> self next-display-state))) + (let ((v1-74 (-> self display-state))) + (cond + ((or (= v1-74 (progress-screen fuel-cell)) + (or (= v1-74 (progress-screen money)) (= v1-74 (progress-screen buzzer))) + ) + (respond-progress self) + ) + ((or (= v1-74 (progress-screen memcard-no-space)) + (= v1-74 (progress-screen memcard-format)) + (= v1-74 (progress-screen memcard-data-exists)) + (= v1-74 (progress-screen memcard-insert)) + (= v1-74 (progress-screen load-game)) + (= v1-74 (progress-screen save-game)) + (= v1-74 (progress-screen save-game-title)) + (= v1-74 (progress-screen memcard-error-loading)) + (= v1-74 (progress-screen memcard-error-saving)) + (= v1-74 (progress-screen memcard-error-formatting)) + (= v1-74 (progress-screen memcard-error-creating)) + (= v1-74 (progress-screen memcard-auto-save-error)) + (= v1-74 (progress-screen memcard-removed)) + (= v1-74 (progress-screen memcard-no-data)) + (= v1-74 (progress-screen memcard-not-inserted)) + (= v1-74 (progress-screen memcard-not-formatted)) + (= v1-74 (progress-screen auto-save)) + (= v1-74 (progress-screen pal-change-to-60hz)) + (= v1-74 (progress-screen pal-now-60hz)) + (= v1-74 (progress-screen no-disc)) + (= v1-74 (progress-screen bad-disc)) + (= v1-74 (progress-screen quit)) + ) + (dummy-31 self) + ) + ) + ) + (suspend) + ) + (none) + ) + :post + (behavior () + (let* ((a1-0 (-> self display-level-index)) + (gp-0 (-> *level-task-data* a1-0)) + ) + #t + (let ((s5-0 #f)) + (case (-> self display-state) + (((progress-screen fuel-cell)) + (set! s5-0 #t) + (draw-fuel-cell-screen self a1-0) + ) + (((progress-screen money)) + (set! s5-0 #t) + (draw-money-screen self a1-0) + ) + (((progress-screen buzzer)) + (set! s5-0 #t) + (draw-buzzer-screen self a1-0) + ) + (((progress-screen game-settings) (progress-screen settings)) + (hide-progress-icons) + (draw-options self 115 30 (the-as float 0.82)) + ) + (((progress-screen graphic-settings) + (progress-screen sound-settings) + (progress-screen settings-title) + (progress-screen title) + ) + (hide-progress-icons) + (draw-options self 115 30 (the-as float 0.82)) + ) + (((progress-screen memcard-removed) (progress-screen memcard-auto-save-error)) + (draw-notice-screen self) + (draw-options self 192 0 (the-as float 0.82)) + ) + (((progress-screen memcard-no-data)) + (draw-notice-screen self) + (draw-options self 165 0 (the-as float 0.82)) + ) + (((progress-screen memcard-format)) + (draw-notice-screen self) + (draw-options self 172 0 (the-as float 0.82)) + ) + (((progress-screen memcard-no-space) + (progress-screen memcard-not-inserted) + (progress-screen memcard-not-formatted) + ) + (draw-notice-screen self) + (draw-options self 195 0 (the-as float 0.82)) + ) + (((progress-screen memcard-error-loading) + (progress-screen memcard-error-saving) + (progress-screen memcard-error-formatting) + (progress-screen memcard-error-creating) + (progress-screen memcard-auto-save-error) + ) + (draw-notice-screen self) + (draw-options self 190 0 (the-as float 0.82)) + ) + (((progress-screen pal-change-to-60hz)) + (draw-notice-screen self) + (draw-options self 190 0 (the-as float 0.82)) + ) + (((progress-screen pal-now-60hz)) + (when (< 3000 (- (-> *display* real-frame-counter) (-> self video-mode-timeout))) + (set! (-> *progress-state* video-mode-choice) 'pal) + (set! (-> *setting-control* default video-mode) (-> *progress-state* video-mode-choice)) + (set! (-> self next-display-state) (progress-screen invalid)) + ) + (draw-notice-screen self) + (draw-options self 140 0 (the-as float 0.82)) + ) + (((progress-screen no-disc) (progress-screen bad-disc)) + (draw-notice-screen self) + (if (is-cd-in?) + (draw-options self 170 0 (the-as float 0.82)) + ) + ) + (((progress-screen quit)) + (draw-notice-screen self) + (draw-options self 110 0 (the-as float 0.82)) + ) + (((progress-screen auto-save)) + (draw-notice-screen self) + (draw-options self 190 0 (the-as float 0.82)) + ) + (((progress-screen memcard-insert)) + (draw-notice-screen self) + (draw-options self 165 0 (the-as float 0.82)) + ) + (((progress-screen memcard-data-exists)) + (draw-notice-screen self) + (draw-options self 168 0 (the-as float 0.82)) + ) + (((progress-screen memcard-loading) + (progress-screen memcard-saving) + (progress-screen memcard-formatting) + (progress-screen memcard-creating) + ) + (draw-notice-screen self) + ) + (((progress-screen load-game) (progress-screen save-game)) + (draw-notice-screen self) + (draw-options self 190 0 (the-as float 0.82)) + ) + (((progress-screen save-game-title)) + (draw-notice-screen self) + (draw-options self 169 15 (the-as float 0.6)) + ) + ) + (when s5-0 + (let* ((v1-98 (cond + ((-> self stat-transition) + 0 + ) + ((= (-> self level-transition) 1) + (- (-> self transition-offset)) + ) + (else + (-> self transition-offset) + ) + ) + ) + (f30-0 (the-as float (if (-> self stat-transition) + 1.0 + (-> self transition-percentage-invert) + ) + ) + ) + (s5-1 + (new + 'stack + 'font-context + *font-default-matrix* + (- 32 (-> self left-x-offset)) + (the int (* (+ 42.0 (the float (/ v1-98 2))) f30-0)) + (the-as float 8325000.0) + (font-color lighter-lighter-blue) + (font-flags shadow kerning) + ) + ) + ) + (let ((v1-103 s5-1)) + (set! (-> v1-103 width) (the float 328)) + ) + (let ((v1-104 s5-1)) + (set! (-> v1-104 height) (the float 45)) + ) + (set! (-> s5-1 flags) (font-flags shadow kerning middle left large)) + (print-game-text-scaled + (lookup-text! *common-text* (-> gp-0 level-name-id) #f) + f30-0 + s5-1 + (the int (* 128.0 f30-0)) + ) + ) + ) + ) + ) + (case (-> self display-state) + (((progress-screen fuel-cell) (progress-screen money) (progress-screen buzzer)) + (draw-progress self) + ) + ) + (adjust-sprites self) + (adjust-icons self) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate progress-coming-in (progress) + :event + (-> progress-waiting event) + :enter + (behavior () + (sound-group-pause (the-as uint 255)) + (logclear! (-> *setting-control* default process-mask) (process-mask pause menu)) + (push-setting! *setting-control* self 'process-mask 'set 0.0 16) + (copy-settings-from-target! *setting-control*) + (sound-play-by-name (static-sound-name "select-menu") (new-sound-id) 1024 0 0 1 #t) + (set-blackout-frames 0) + (set! *pause-lock* #f) + (none) + ) + :code + (behavior () + (while #t + (set! (-> self in-out-position) + (seekl (-> self in-out-position) 0 (the int (* 170.0 (-> *display* time-adjust-ratio)))) + ) + (when (< (-> self in-out-position) 2867) + (set! (-> self transition-offset) (seekl + (-> self transition-offset) + 0 + (the int (* (-> self transition-speed) (-> *display* time-adjust-ratio))) + ) + ) + (set-transition-progress! self (-> self transition-offset)) + ) + (if (zero? (-> self in-out-position)) + (go progress-normal) + ) + (suspend) + ) + (none) + ) + :post + (-> progress-normal post) + ) + +;; failed to figure out what this is: +(defstate progress-going-out (progress) + :enter + (behavior () + (sound-play-by-name (static-sound-name "menu-close") (new-sound-id) 1024 0 0 1 #t) + (hide-progress-icons) + (set! (-> self particles 3 init-pos x) -320.0) + (set! (-> self particles 4 init-pos x) -320.0) + (case (-> self display-state) + (((progress-screen load-game) (progress-screen save-game) (progress-screen save-game-title)) + (set! (-> self transition-speed) 30.0) + ) + ) + (none) + ) + :code + (behavior () + (while #t + (set! (-> self transition-offset) (seekl + (-> self transition-offset) + 512 + (the int (* (-> self transition-speed) (-> *display* time-adjust-ratio))) + ) + ) + (set-transition-progress! self (-> self transition-offset)) + (when (< 153 (-> self transition-offset)) + (set! (-> self in-out-position) + (seekl (-> self in-out-position) 4096 (the int (* 170.0 (-> *display* time-adjust-ratio)))) + ) + (if (= (-> self in-out-position) 4096) + (go progress-gone) + ) + ) + (suspend) + ) + (none) + ) + :post + (-> progress-normal post) + ) + +;; failed to figure out what this is: +(defstate progress-debug (progress) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('go-away) + (go progress-going-out) + ) + ) + ) + :code + (behavior () + (while #t + (cond + ((cpad-pressed? 0 left) + (if (> (-> self current-debug-string) 0) + (+! (-> self current-debug-string) -1) + ) + ) + ((cpad-pressed? 0 right) + (if (< (-> self current-debug-string) (+ (-> *common-text* length) -1)) + (+! (-> self current-debug-string) 1) + ) + ) + ((cpad-pressed? 0 up) + (when (> (-> self current-debug-group) 0) + (+! (-> self current-debug-group) -1) + (set! (-> self current-debug-string) 0) + 0 + ) + ) + ((cpad-pressed? 0 down) + (when (< (-> self current-debug-group) (+ (-> *text-group-names* length) -1)) + (+! (-> self current-debug-group) 1) + (set! (-> self current-debug-string) 0) + 0 + ) + ) + ((cpad-pressed? 0 l1) + (if (> (the-as int (-> *setting-control* default language)) 0) + (+! (-> *setting-control* default language) -1) + ) + ) + ((cpad-pressed? 0 r1) + (if (< (the-as int (-> *setting-control* default language)) 6) + (+! (-> *setting-control* default language) 1) + ) + ) + ((cpad-pressed? 0 l2) + (logclear! (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons l2)) + (logclear! (-> *cpad-list* cpads 0 button0-rel 0) (pad-buttons l2)) + (go progress-normal) + ) + ) + (load-game-text-info (-> *text-group-names* (-> self current-debug-group)) '*common-text* *common-text-heap*) + (suspend) + ) + (none) + ) + :post + (behavior () + (let* ((s5-0 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-0 (-> s5-0 base)) + ) + (let ((s4-0 draw-string-xy)) + (let ((s3-0 format) + (a0-4 (clear *temp-string*)) + (a1-0 "TEXT DEBUG: LANGUAGE ~S ID 0x~X") + (v1-4 (-> *setting-control* current language)) + ) + (s3-0 + a0-4 + a1-0 + (cond + ((= v1-4 (language-enum uk-english)) + "uk-english" + ) + ((= v1-4 (language-enum japanese)) + "japanese" + ) + ((= v1-4 (language-enum italian)) + "italian" + ) + ((= v1-4 (language-enum spanish)) + "spanish" + ) + ((= v1-4 (language-enum german)) + "german" + ) + ((= v1-4 (language-enum french)) + "french" + ) + ((= v1-4 (language-enum english)) + "english" + ) + (else + "*unknown*" + ) + ) + (-> *common-text* data (-> self current-debug-string) id) + ) + ) + (s4-0 *temp-string* s5-0 40 40 (font-color default) (font-flags shadow kerning)) + ) + (let ((a3-4 (-> s5-0 base))) + (let ((v1-7 (the-as dma-packet (-> s5-0 base)))) + (set! (-> v1-7 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-7 vif0) (new 'static 'vif-tag)) + (set! (-> v1-7 vif1) (new 'static 'vif-tag)) + (set! (-> s5-0 base) (&+ (the-as pointer v1-7) 16)) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id debug-draw0) + gp-0 + (the-as (pointer dma-tag) a3-4) + ) + ) + ) + (let* ((s5-1 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-1 (-> s5-1 base)) + ) + (let ((s4-1 draw-string-xy)) + (format (clear *temp-string*) "USE LEFT/RIGHT TO SELECT STRING") + (s4-1 *temp-string* s5-1 40 155 (font-color default) (font-flags shadow kerning)) + ) + (let ((a3-6 (-> s5-1 base))) + (let ((v1-16 (the-as dma-packet (-> s5-1 base)))) + (set! (-> v1-16 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-16 vif0) (new 'static 'vif-tag)) + (set! (-> v1-16 vif1) (new 'static 'vif-tag)) + (set! (-> s5-1 base) (the-as pointer (the-as dma-packet (&+ v1-16 16)))) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id debug-draw0) + gp-1 + (the-as (pointer dma-tag) a3-6) + ) + ) + ) + (let* ((s5-2 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-2 (-> s5-2 base)) + ) + (let ((s4-2 draw-string-xy)) + (format (clear *temp-string*) "USE UP/DOWN TO SELECT GROUP") + (s4-2 *temp-string* s5-2 40 165 (font-color default) (font-flags shadow kerning)) + ) + (let ((a3-8 (-> s5-2 base))) + (let ((v1-25 (the-as dma-packet (-> s5-2 base)))) + (set! (-> v1-25 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-25 vif0) (new 'static 'vif-tag)) + (set! (-> v1-25 vif1) (new 'static 'vif-tag)) + (set! (-> s5-2 base) (the-as pointer (the-as dma-packet (&+ v1-25 16)))) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id debug-draw0) + gp-2 + (the-as (pointer dma-tag) a3-8) + ) + ) + ) + (let* ((s5-3 (-> *display* frames (-> *display* on-screen) frame global-buf)) + (gp-3 (-> s5-3 base)) + ) + (let ((s4-3 draw-string-xy)) + (format (clear *temp-string*) "USE L1/R1 TO SELECT LANGUAGE") + (s4-3 *temp-string* s5-3 40 175 (font-color default) (font-flags shadow kerning)) + ) + (let ((a3-10 (-> s5-3 base))) + (let ((v1-34 (the-as dma-packet (-> s5-3 base)))) + (set! (-> v1-34 dma) (new 'static 'dma-tag :id (dma-tag-id next))) + (set! (-> v1-34 vif0) (new 'static 'vif-tag)) + (set! (-> v1-34 vif1) (new 'static 'vif-tag)) + (set! (-> s5-3 base) (the-as pointer (the-as dma-packet (&+ v1-34 16)))) + ) + (dma-bucket-insert-tag + (-> *display* frames (-> *display* on-screen) frame bucket-group) + (bucket-id debug-draw0) + gp-3 + (the-as (pointer dma-tag) a3-10) + ) + ) + ) + (let ((gp-4 (new + 'stack + 'font-context + *font-default-matrix* + 32 + 50 + (the-as float 0.0) + (font-color default) + (font-flags shadow kerning) + ) + ) + ) + (let ((v1-42 gp-4)) + (set! (-> v1-42 width) (the float 328)) + ) + (let ((v1-43 gp-4)) + (set! (-> v1-43 height) (the float 100)) + ) + (logior! (-> gp-4 flags) (font-flags shadow kerning large)) + (draw-debug-text-box gp-4) + (print-game-text (-> *common-text* data (-> self current-debug-string) text) gp-4 #f 128 22) + ) + (none) + ) + ) + +;; failed to figure out what this is: +0 + + + + diff --git a/test/decompiler/reference/engine/util/glist-h_REF.gc b/test/decompiler/reference/engine/util/glist-h_REF.gc new file mode 100644 index 0000000000..154a56bab6 --- /dev/null +++ b/test/decompiler/reference/engine/util/glist-h_REF.gc @@ -0,0 +1,125 @@ +;;-*-Lisp-*- +(in-package goal) + +;; this file is debug only +(declare-file (debug)) +(when *debug-segment* +;; definition of type glst-node +(deftype glst-node (structure) + ((next glst-node :offset-assert 0) + (prev glst-node :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; definition for method 3 of type glst-node +(defmethod inspect glst-node ((obj glst-node)) + (format #t "[~8x] ~A~%" obj 'glst-node) + (format #t "~Tnext: #~%" (-> obj next)) + (format #t "~Tprev: #~%" (-> obj prev)) + obj + ) + +;; definition of type glst-named-node +(deftype glst-named-node (glst-node) + ((privname string :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +;; definition for method 3 of type glst-named-node +(defmethod inspect glst-named-node ((obj glst-named-node)) + (format #t "[~8x] ~A~%" obj 'glst-named-node) + (format #t "~Tnext: #~%" (-> obj next)) + (format #t "~Tprev: #~%" (-> obj prev)) + (format #t "~Tprivname: ~A~%" (-> obj privname)) + obj + ) + +;; definition of type glst-list +(deftype glst-list (structure) + ((head glst-node :offset-assert 0) + (tail glst-node :offset-assert 4) + (tailpred glst-node :offset-assert 8) + (numelem int32 :offset-assert 12) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; definition for method 3 of type glst-list +(defmethod inspect glst-list ((obj glst-list)) + (format #t "[~8x] ~A~%" obj 'glst-list) + (format #t "~Thead: #~%" (-> obj head)) + (format #t "~Ttail: #~%" (-> obj tail)) + (format #t "~Ttailpred: #~%" (-> obj tailpred)) + (format #t "~Tnumelem: ~D~%" (-> obj numelem)) + obj + ) + +;; definition for function glst-next +(defun glst-next ((arg0 glst-node)) + "return the next node in the list" + (-> arg0 next) + ) + +;; definition for function glst-prev +(defun glst-prev ((arg0 glst-node)) + "return the previous node in the list" + (-> arg0 prev) + ) + +;; definition for function glst-head +(defun glst-head ((arg0 glst-list)) + "return the start of the list" + (-> arg0 head) + ) + +;; definition for function glst-tail +(defun glst-tail ((arg0 glst-list)) + "return the tail of the list" + (-> arg0 tailpred) + ) + +;; definition for function glst-end-of-list? +(defun glst-end-of-list? ((arg0 glst-node)) + "is this node the end of the list. #t = end" + (not (-> arg0 next)) + ) + +;; definition for function glst-start-of-list? +(defun glst-start-of-list? ((arg0 glst-node)) + "is this node the start of the list. #t = start" + (not (-> arg0 prev)) + ) + +;; definition for function glst-empty? +(defun glst-empty? ((arg0 glst-list)) + "is the list empty, #t = empty" + (= (-> arg0 tailpred) arg0) + ) + +;; definition for function glst-node-name +(defun glst-node-name ((arg0 glst-named-node)) + (-> arg0 privname) + ) + +;; definition for function glst-set-name! +(defun glst-set-name! ((arg0 glst-named-node) (arg1 string)) + (set! (-> arg0 privname) arg1) + arg1 + ) + +;; failed to figure out what this is: +0 + +) + + + diff --git a/test/decompiler/reference/kernel/gkernel_REF.gc b/test/decompiler/reference/kernel/gkernel_REF.gc index 638c190dd1..399974426a 100644 --- a/test/decompiler/reference/kernel/gkernel_REF.gc +++ b/test/decompiler/reference/kernel/gkernel_REF.gc @@ -365,6 +365,7 @@ ) ;; definition for method 2 of type process +;; INFO: this function exists in multiple non-identical object files (defmethod print process ((obj process)) (format #t "#<~A ~S ~A :state ~S " (-> obj type) (-> obj name) (-> obj status) (if (-> obj state) (-> obj state name) diff --git a/test/decompiler/reference/levels/demo/static-screen_REF.gc b/test/decompiler/reference/levels/demo/static-screen_REF.gc new file mode 100644 index 0000000000..815896e802 --- /dev/null +++ b/test/decompiler/reference/levels/demo/static-screen_REF.gc @@ -0,0 +1,193 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition of type static-screen +(deftype static-screen (process) + ((part sparticle-launch-control 1 :offset-assert 112) + (state-time uint64 :offset-assert 120) + ) + :heap-base #x10 + :method-count-assert 15 + :size-assert #x80 + :flag-assert #xf00100080 + (:methods + (idle (int int symbol) _type_ :state 14) + ) + ) + +;; definition for method 3 of type static-screen +(defmethod inspect static-screen ((obj static-screen)) + (let ((t9-0 (method-of-type process inspect))) + (t9-0 obj) + ) + (format #t "~T~Tpart[1] @ #x~X~%" (-> obj stack)) + (format #t "~T~Tstate-time: ~D~%" (-> obj state-time)) + obj + ) + +;; definition for method 7 of type static-screen +;; INFO: Return type mismatch process vs static-screen. +(defmethod relocate static-screen ((obj static-screen) (arg0 int)) + (let ((v1-0 *kernel-context*)) + (set! (-> v1-0 relocating-process) obj) + (set! (-> v1-0 relocating-min) (the-as int (&-> obj type))) + (set! (-> v1-0 relocating-max) + (the-as int (+ (+ (-> obj allocated-length) -4 (-> process size)) (the-as int obj))) + ) + (set! (-> v1-0 relocating-offset) arg0) + ) + (dotimes (v1-2 1) + (if (nonzero? (-> obj part v1-2)) + (&+! (-> obj part v1-2) arg0) + ) + ) + (the-as static-screen ((method-of-type process relocate) obj arg0)) + ) + +;; definition for method 10 of type static-screen +(defmethod deactivate static-screen ((obj static-screen)) + (dotimes (s5-0 1) + (if (nonzero? (-> obj part s5-0)) + (kill-and-free-particles (-> obj part s5-0)) + ) + ) + ((method-of-type process deactivate) obj) + (none) + ) + +;; failed to figure out what this is: +(defpart 2966 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x5c6)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters 1.18)) + (sp-flt spt-scale-x (meters 15)) + (sp-flt spt-scale-y (meters 6.5)) + (sp-flt spt-r 128.0) + (sp-flt spt-g 128.0) + (sp-flt spt-b 128.0) + (sp-flt spt-a 128.0) + (sp-int spt-timer -1) + (sp-cpuinfo-flags bit2 bit9 bit13) + ) + ) + +;; failed to figure out what this is: +(defpart 2967 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x1 :page #x5c6)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters -1.264)) + (sp-flt spt-scale-x (meters 15)) + (sp-flt spt-scale-y (meters 3.25)) + (sp-flt spt-r 128.0) + (sp-flt spt-g 128.0) + (sp-flt spt-b 128.0) + (sp-flt spt-a 128.0) + (sp-int spt-timer -1) + (sp-cpuinfo-flags bit2 bit9 bit13) + ) + ) + +;; failed to figure out what this is: +(defpart 2968 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #x5c6)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters -2.482)) + (sp-flt spt-scale-x (meters 15)) + (sp-flt spt-scale-y (meters 1.625)) + (sp-flt spt-r 128.0) + (sp-flt spt-g 128.0) + (sp-flt spt-b 128.0) + (sp-flt spt-a 128.0) + (sp-int spt-timer -1) + (sp-cpuinfo-flags bit2 bit9 bit13) + ) + ) + +;; failed to figure out what this is: +(defpartgroup group-part-screen1 + :id 707 + :flags (screen-space) + :bounds (static-bspherem 0 0 0 1) + :parts + ((sp-item 2966 :flags (launch-asap)) (sp-item 2967 :flags (launch-asap)) (sp-item 2968 :flags (launch-asap))) + ) + +;; failed to figure out what this is: +(defstate idle (static-screen) + :virtual #t + :enter + (behavior ((arg0 int) (arg1 int) (arg2 symbol)) + (set! (-> *setting-control* current bg-a) 1.0) + (set! (-> *setting-control* default bg-a) 0.0) + (push-setting! *setting-control* self 'common-page 'set 0.0 (ash 1 (+ arg0 1))) + (none) + ) + :trans + (behavior () + (hide-hud-quick) + (spawn (-> self part 0) *zero-vector*) + 0 + (none) + ) + :code + (behavior ((arg0 int) (arg1 int) (arg2 symbol)) + (local-vars (v1-6 symbol)) + (set! (-> self state-time) (the-as uint (-> *display* base-frame-counter))) + (until v1-6 + (suspend) + (set! v1-6 + (or (and (> arg1 0) (>= (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) arg1)) + (and arg2 + (>= (- (-> *display* base-frame-counter) (the-as int (-> self state-time))) 300) + (cpad-pressed? 0 select start triangle circle x square) + ) + ) + ) + ) + (set! (-> *setting-control* default bg-a) 1.0) + (while (!= (-> *setting-control* current bg-a) (-> *setting-control* default bg-a)) + (suspend) + ) + (clear-pending-settings-from-process *setting-control* self 'common-page) + (suspend) + 0 + (none) + ) + ) + +;; definition for function static-screen-init-by-other +;; INFO: Return type mismatch int vs none. +(defbehavior static-screen-init-by-other static-screen ((arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int) (arg5 symbol)) + (let ((s3-0 (lookup-part-group-by-name "group-part-screen1"))) + (when (and s3-0 (nonzero? s3-0) (type-type? (-> s3-0 type) sparticle-launch-group)) + (set! (-> *part-id-table* 2966 init-specs 0 initial-valuef) (the-as float arg1)) + (set! (-> *part-id-table* 2967 init-specs 0 initial-valuef) (the-as float arg2)) + (set! (-> *part-id-table* 2968 init-specs 0 initial-valuef) (the-as float arg3)) + (set! (-> self part 0) (create-launch-control (the-as sparticle-launch-group s3-0) self)) + (go-virtual idle arg0 arg4 arg5) + ) + ) + 0 + (none) + ) + +;; definition for function static-screen-spawn +;; Used lq/sq +(defun static-screen-spawn ((arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int) (arg5 symbol) (arg6 target)) + (local-vars (sv-16 process)) + (set! sv-16 (get-process *default-dead-pool* static-screen #x4000)) + (when sv-16 + (let ((t9-1 (method-of-type static-screen activate))) + (t9-1 (the-as static-screen sv-16) arg6 'static-screen (the-as pointer #x70004000)) + ) + (run-now-in-process sv-16 static-screen-init-by-other arg0 arg1 arg2 arg3 arg4 arg5) + (-> sv-16 ppointer) + ) + ) + + + + diff --git a/test/decompiler/reference/levels/misty/babak-with-cannon_REF.gc b/test/decompiler/reference/levels/misty/babak-with-cannon_REF.gc new file mode 100644 index 0000000000..bd9da3bc97 --- /dev/null +++ b/test/decompiler/reference/levels/misty/babak-with-cannon_REF.gc @@ -0,0 +1,532 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition of type babak-with-cannon +(deftype babak-with-cannon (babak) + ((cannon-ent entity :offset-assert 400) + (distance float :offset-assert 404) + ) + :heap-base #x130 + :method-count-assert 76 + :size-assert #x198 + :flag-assert #x4c01300198 + (:states + babak-with-cannon-jump-off-cannon + babak-with-cannon-jump-onto-cannon + babak-with-cannon-shooting + ) + ) + +;; definition for method 3 of type babak-with-cannon +(defmethod inspect babak-with-cannon ((obj babak-with-cannon)) + (let ((t9-0 (method-of-type babak inspect))) + (t9-0 obj) + ) + (format #t "~T~Tcannon-ent: ~A~%" (-> obj cannon-ent)) + (format #t "~T~Tdistance: ~f~%" (-> obj distance)) + obj + ) + +;; failed to figure out what this is: +nav-enemy-default-event-handler + +;; failed to figure out what this is: +(defstate nav-enemy-idle (babak-with-cannon) + :virtual #t + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-default-event-handler + ) + :trans + (behavior () + (if (and (and *target* (>= (-> self enemy-info idle-distance) + (vector-vector-distance (-> self collide-info trans) (-> *target* control trans)) + ) + ) + (>= (- (-> *display* base-frame-counter) (-> self state-time)) (-> self state-timeout)) + ) + (go-virtual nav-enemy-patrol) + ) + (none) + ) + :code + (behavior () + (ja-channel-push! 1 22) + (let ((a0-1 (-> self skel root-channel 0))) + (set! (-> a0-1 frame-group) + (the-as art-joint-anim (-> self draw art-group data (-> self nav-info idle-anim))) + ) + (set! (-> a0-1 param 0) + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self nav-info idle-anim))) data 0 length) -1) + ) + ) + (set! (-> a0-1 param 1) 1.0) + (set! (-> a0-1 frame-num) 0.0) + (joint-control-channel-group! + a0-1 + (the-as art-joint-anim (-> self draw art-group data (-> self nav-info idle-anim))) + num-func-seek! + ) + ) + (until (ja-done? 0) + (ja-post) + (suspend) + (let ((a0-2 (-> self skel root-channel 0))) + (set! (-> a0-2 param 0) (the float (+ (-> a0-2 frame-group data 0 length) -1))) + (set! (-> a0-2 param 1) 1.0) + (joint-control-channel-group-eval! a0-2 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + (anim-loop) + (none) + ) + :post + (the-as (function none :behavior babak-with-cannon) #f) + ) + +;; failed to figure out what this is: +(defstate nav-enemy-patrol (babak-with-cannon) + :virtual #t + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-default-event-handler + ) + :trans + (behavior () + (when (>= (- (-> *display* base-frame-counter) (-> self state-time)) 30) + (let ((f30-0 (- (-> (target-pos 0) y) (-> self collide-info trans y)))) + (if (and (>= (- (-> *display* base-frame-counter) (-> self state-time)) 900) + (or (or (not *target*) + (< (-> self distance) (vector-vector-distance (-> self collide-info trans) (-> *target* control trans))) + ) + (< f30-0 -40960.0) + ) + ) + (go babak-run-to-cannon) + ) + ) + (when (>= (- (-> *display* base-frame-counter) (-> self state-time)) (-> self state-timeout)) + (if (or (not *target*) (< (-> self enemy-info idle-distance) + (vector-vector-distance (-> self collide-info trans) (-> *target* control trans)) + ) + ) + (go-virtual nav-enemy-idle) + ) + ) + (if (nav-enemy-notice-player?) + (go-virtual nav-enemy-notice) + ) + ) + (none) + ) + :code + (-> (method-of-type babak nav-enemy-patrol) code) + ) + +;; failed to figure out what this is: +(defstate babak-run-to-cannon (babak) + :event + (the-as + (function process int symbol event-message-block object :behavior babak) + nav-enemy-default-event-handler + ) + :enter + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (set! (-> self nav destination-pos quad) (-> self entity extra trans quad)) + (set! (-> self nav target-pos quad) (-> self entity extra trans quad)) + (none) + ) + :trans + (behavior () + (if (nav-enemy-notice-player?) + (go-virtual nav-enemy-chase) + ) + (if (logtest? (nav-control-flags bit19) (-> self nav flags)) + (go babak-with-cannon-jump-onto-cannon) + ) + (none) + ) + :code + (behavior () + (ja-channel-push! 1 22) + (while #t + (let ((a0-1 (-> self skel root-channel 0))) + (set! (-> a0-1 frame-group) (the-as art-joint-anim (-> self draw art-group data 8))) + (set! (-> a0-1 param 0) + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 8)) data 0 length) -1)) + ) + (set! (-> a0-1 param 1) 1.0) + (set! (-> a0-1 frame-num) 0.0) + (joint-control-channel-group! a0-1 (the-as art-joint-anim (-> self draw art-group data 8)) num-func-seek!) + ) + (until (ja-done? 0) + (suspend) + (let ((a0-2 (-> self skel root-channel 0))) + (set! (-> a0-2 param 0) (the float (+ (-> a0-2 frame-group data 0 length) -1))) + (set! (-> a0-2 param 1) 1.0) + (joint-control-channel-group-eval! a0-2 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + ) + (none) + ) + :post + (behavior () + (nav-enemy-travel-post) + (none) + ) + ) + +;; definition for function handle->process-safe +(defun handle->process-safe ((arg0 handle)) + (let ((v0-0 (the-as process #f))) + (if (handle->process arg0) + (set! v0-0 (-> arg0 process 0)) + ) + v0-0 + ) + ) + +;; definition for function babak-with-cannon-compute-cannon-dir +;; Used lq/sq +(defun babak-with-cannon-compute-cannon-dir ((arg0 mistycannon) (arg1 vector)) + (set! (-> arg1 quad) (-> arg0 node-list data 3 bone transform vector 2 quad)) + arg1 + ) + +;; definition for function babak-with-cannon-compute-ride-point +;; Used lq/sq +(defun babak-with-cannon-compute-ride-point ((arg0 mistycannon) (arg1 vector)) + (set! (-> arg1 quad) (-> arg0 root-override trans quad)) + (let ((a1-4 (new 'static 'vector :y 18149.377 :z -17289.217 :w 1.0)) + (a2-0 (-> arg0 node-list data 3 bone transform)) + ) + (vector-matrix*! arg1 a1-4 a2-0) + ) + arg1 + ) + +;; definition for function babak-with-cannon-ride-cannon-post +(defbehavior babak-with-cannon-ride-cannon-post babak-with-cannon () + (let* ((v1-0 (-> self cannon-ent)) + (s5-0 (if v1-0 + (-> v1-0 extra process) + ) + ) + (gp-0 (if (and (nonzero? s5-0) (type-type? (-> s5-0 type) process-drawable)) + s5-0 + ) + ) + ) + (when gp-0 + (let ((s5-1 (new 'stack-no-clear 'vector))) + (babak-with-cannon-compute-cannon-dir (the-as mistycannon gp-0) s5-1) + (forward-up->quaternion (-> self collide-info quat) s5-1 *y-vector*) + ) + (babak-with-cannon-compute-ride-point (the-as mistycannon gp-0) (-> self collide-info trans)) + ) + ) + (nav-enemy-simple-post) + (none) + ) + +;; failed to figure out what this is: +(defstate babak-with-cannon-jump-onto-cannon (babak-with-cannon) + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-jump-event-handler + ) + :exit + (behavior () + (logior! (-> self nav-enemy-flags) 24) + (none) + ) + :code + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (set! (-> self rotate-speed) (-> self nav-info run-rotate-speed)) + (set! (-> self turn-time) (the-as int (-> self nav-info run-turn-time))) + (set! (-> self nav-enemy-flags) (logand -25 (-> self nav-enemy-flags))) + (nav-enemy-neck-control-inactive) + (let* ((v1-7 (-> self cannon-ent)) + (gp-0 (if v1-7 + (-> v1-7 extra process) + ) + ) + (a0-2 (if (and (nonzero? gp-0) (type-type? (-> gp-0 type) process-drawable)) + gp-0 + ) + ) + ) + (cond + (a0-2 + (babak-with-cannon-compute-ride-point (the-as mistycannon a0-2) (-> self event-param-point)) + (nav-enemy-initialize-jump (-> self event-param-point)) + ) + (else + (go-virtual nav-enemy-idle) + ) + ) + ) + (when (not (nav-enemy-facing-point? (-> self jump-dest) 5461.3335)) + (ja-channel-push! 1 60) + (nav-enemy-turn-to-face-point (-> self jump-dest) 1820.4445) + ) + (logior! (-> self nav-enemy-flags) 16) + (nav-enemy-execute-jump) + (set! (-> self nav-enemy-flags) (logand -25 (-> self nav-enemy-flags))) + (let* ((v1-20 (-> self cannon-ent)) + (gp-1 (if v1-20 + (-> v1-20 extra process) + ) + ) + (a0-9 (if (and (nonzero? gp-1) (type-type? (-> gp-1 type) process-drawable)) + gp-1 + ) + ) + ) + (when a0-9 + (let ((gp-2 (babak-with-cannon-compute-cannon-dir (the-as mistycannon a0-9) (new 'stack-no-clear 'vector)))) + (when (not (nav-enemy-facing-direction? gp-2 1820.4445)) + (ja-channel-push! 1 60) + (nav-enemy-turn-to-face-dir gp-2 182.04445) + (forward-up->quaternion (-> self collide-info quat) gp-2 *y-vector*) + ) + ) + ) + ) + (ja-channel-push! 1 30) + (let ((a0-15 (-> self skel root-channel 0))) + (set! (-> a0-15 frame-group) (the-as art-joint-anim (-> self draw art-group data 17))) + (set! (-> a0-15 param 0) + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 17)) data 0 length) -1)) + ) + (set! (-> a0-15 param 1) 1.0) + (set! (-> a0-15 frame-num) 0.0) + (joint-control-channel-group! a0-15 (the-as art-joint-anim (-> self draw art-group data 17)) num-func-seek!) + ) + (until (ja-done? 0) + (suspend) + (let ((a0-16 (-> self skel root-channel 0))) + (set! (-> a0-16 param 0) (the float (+ (-> a0-16 frame-group data 0 length) -1))) + (set! (-> a0-16 param 1) 1.0) + (joint-control-channel-group-eval! a0-16 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + (go babak-with-cannon-shooting) + (none) + ) + :post + (the-as (function none :behavior babak-with-cannon) nav-enemy-jump-post) + ) + +;; failed to figure out what this is: +(defstate babak-with-cannon-jump-off-cannon (babak-with-cannon) + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-jump-event-handler + ) + :exit + (behavior () + (logior! (-> self nav-enemy-flags) 24) + (none) + ) + :code + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (nav-enemy-initialize-jump (-> self entity extra trans)) + (nav-enemy-neck-control-look-at) + (set! (-> self nav-enemy-flags) (logand -25 (-> self nav-enemy-flags))) + (let ((a0-2 (-> self skel root-channel 0))) + (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> self draw art-group data 17))) + (set! (-> a0-2 param 0) 0.0) + (set! (-> a0-2 param 1) 2.0) + (set! (-> a0-2 frame-num) + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 17)) data 0 length) -1)) + ) + (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> self draw art-group data 17)) num-func-seek!) + ) + (until (ja-done? 0) + (suspend) + (let ((a0-3 (-> self skel root-channel 0))) + (set! (-> a0-3 param 0) 0.0) + (set! (-> a0-3 param 1) 2.0) + (joint-control-channel-group-eval! a0-3 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + (when (not (nav-enemy-facing-point? (-> self jump-dest) 5461.3335)) + (ja-channel-push! 1 60) + (nav-enemy-turn-to-face-point (-> self jump-dest) 1820.4445) + ) + (logior! (-> self nav-enemy-flags) 16) + (nav-enemy-execute-jump) + (let ((a1-6 (dummy-16 (-> self nav) (-> self jump-dest)))) + (set-current-poly! (-> self nav) a1-6) + ) + (go-virtual nav-enemy-jump-land) + (none) + ) + :post + (the-as (function none :behavior babak-with-cannon) nav-enemy-jump-post) + ) + +;; failed to figure out what this is: +(defstate babak-with-cannon-shooting (babak-with-cannon) + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-default-event-handler + ) + :enter + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (let ((v1-2 (entity-actor-lookup (-> self entity) 'alt-actor 0))) + (if v1-2 + (logior! (-> v1-2 extra perm status) (entity-perm-status complete)) + ) + ) + (none) + ) + :exit + (behavior () + (let ((v1-0 (entity-actor-lookup (-> self entity) 'alt-actor 0))) + (if v1-0 + (logclear! (-> v1-0 extra perm status) (entity-perm-status complete)) + ) + ) + (none) + ) + :trans + (behavior () + (let ((f0-1 (- (-> (target-pos 0) y) (-> self collide-info trans y)))) + (if (and (< -40960.0 f0-1) + (and (and *target* + (>= (-> self distance) (vector-vector-distance (-> self collide-info trans) (-> *target* control trans))) + ) + (>= (- (-> *display* base-frame-counter) (-> self state-time)) 900) + ) + ) + (go babak-with-cannon-jump-off-cannon) + ) + ) + (none) + ) + :code + (behavior () + (while #t + (suspend) + ) + (none) + ) + :post + babak-with-cannon-ride-cannon-post + ) + +;; failed to figure out what this is: +(defstate nav-enemy-die (babak-with-cannon) + :virtual #t + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + nav-enemy-default-event-handler + ) + :trans + (behavior () + (if (and *target* (= (-> *target* current-level name) 'beach)) + (spool-push *art-control* "beachcam-cannon" 0 self -1.0) + ) + (if (and *target* (= (-> *target* current-level name) 'misty)) + (spool-push *art-control* "mistycam-cannon" 0 self -1.0) + ) + (let ((t9-3 (-> (the-as (state nav-enemy) (find-parent-method babak-with-cannon 23)) trans))) + (if t9-3 + (t9-3) + ) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate nav-enemy-fuel-cell (babak-with-cannon) + :virtual #t + :event + (the-as + (function process int symbol event-message-block object :behavior babak-with-cannon) + process-drawable-fuel-cell-handler + ) + :code + (behavior () + (ja-channel-set! 0) + (clear-collide-with-as (-> self collide-info)) + (ja-post) + (when (not (task-complete? *game-info* (-> self entity extra perm task))) + (when (not (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status complete)))) + (process-entity-status! self (entity-perm-status complete) #t) + (if (and *target* (= (-> *target* current-level name) 'beach)) + (beachcam-spawn) + ) + (if (and *target* (= (-> *target* current-level name) 'misty)) + (mistycam-spawn) + ) + ) + (if (not (-> self child)) + (birth-pickup-at-point + (-> self collide-info trans) + (pickup-type fuel-cell) + (the float (-> self entity extra perm task)) + #f + self + (the-as fact-info #f) + ) + ) + (while (-> self child) + (suspend) + ) + ) + (dummy-18 self) + (none) + ) + ) + +;; definition for method 39 of type babak-with-cannon +(defmethod common-post babak-with-cannon ((obj babak-with-cannon)) + (cond + ((= (level-status *level* 'beach) 'active) + (spool-push *art-control* "beachcam-cannon" 0 obj -99.0) + ) + ((= (level-status *level* 'misty) 'active) + (spool-push *art-control* "mistycam-cannon" 0 obj -99.0) + ) + ) + ((method-of-type nav-enemy common-post) obj) + (none) + ) + +;; definition for method 11 of type babak-with-cannon +;; INFO: Return type mismatch object vs none. +(defmethod init-from-entity! babak-with-cannon ((obj babak-with-cannon) (arg0 entity-actor)) + (initialize-collision obj) + (process-drawable-from-entity! obj arg0) + (TODO-RENAME-48 obj) + (set! (-> obj distance) (res-lump-float arg0 'distance :default 163840.0)) + (set! (-> obj cannon-ent) (entity-actor-lookup (-> obj entity) 'alt-actor 0)) + (logclear! (-> obj mask) (process-mask actor-pause)) + (if (or (not (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status complete)))) + (zero? (logand (-> obj enemy-info options) (fact-options fop1))) + ) + (go (method-of-object obj nav-enemy-idle)) + ) + (go (method-of-object obj nav-enemy-fuel-cell)) + (none) + ) + + + + diff --git a/test/decompiler/reference/levels/misty/mistycannon_REF.gc b/test/decompiler/reference/levels/misty/mistycannon_REF.gc new file mode 100644 index 0000000000..141814f24d --- /dev/null +++ b/test/decompiler/reference/levels/misty/mistycannon_REF.gc @@ -0,0 +1,2133 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition of type angle-tracker +(deftype angle-tracker (structure) + ((value float :offset-assert 0) + (min float :offset-assert 4) + (range float :offset-assert 8) + (speed float :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; definition for method 3 of type angle-tracker +(defmethod inspect angle-tracker ((obj angle-tracker)) + (format #t "[~8x] ~A~%" obj 'angle-tracker) + (format #t "~Tvalue: ~f~%" (-> obj value)) + (format #t "~Tmin: ~f~%" (-> obj min)) + (format #t "~Trange: ~f~%" (-> obj range)) + (format #t "~Tspeed: ~f~%" (-> obj speed)) + obj + ) + +;; definition for function angle-tracker-apply-move! +(defun angle-tracker-apply-move! ((arg0 angle-tracker) (arg1 float)) + (let* ((f0-2 (* arg1 (-> arg0 speed) (-> *display* seconds-per-frame))) + (f0-3 (+ (-> arg0 value) f0-2)) + ) + (when (!= (-> arg0 range) 0.0) + (if (< f0-3 0.0) + (set! f0-3 0.0) + ) + (if (< (-> arg0 range) f0-3) + (set! f0-3 (-> arg0 range)) + ) + ) + (let ((f1-7 (- (-> arg0 value) f0-3))) + (if (= (-> arg0 range) 0.0) + (set! f0-3 (the float (sar (shl (the int f0-3) 48) 48))) + ) + (set! (-> arg0 value) f0-3) + f1-7 + ) + ) + ) + +;; definition for function angle-tracker-init-range! +;; INFO: Return type mismatch int vs none. +(defun angle-tracker-init-range! ((arg0 angle-tracker) (arg1 float) (arg2 float) (arg3 float)) + (set! (-> arg0 min) arg1) + (set! (-> arg0 range) (the float (sar (shl (the int (- arg2 arg1)) 48) 48))) + (if (< (-> arg0 range) 0.0) + (set! (-> arg0 range) (+ 65536.0 (-> arg0 range))) + ) + (set! (-> arg0 value) (* 0.5 (-> arg0 range))) + (set! (-> arg0 speed) arg3) + 0 + (none) + ) + +;; definition for function angle-tracker-get-value +(defun angle-tracker-get-value ((arg0 angle-tracker)) + (the float (sar (shl (the int (+ (-> arg0 min) (-> arg0 value))) 48) 48)) + ) + +;; definition for function angle-tracker-set-value +(defun angle-tracker-set-value ((arg0 angle-tracker) (arg1 float)) + (let ((v1-0 (- arg1 (-> arg0 min)))) + (when (!= (-> arg0 range) 0.0) + (if (< v1-0 0.0) + (set! v1-0 0.0) + ) + (if (< (-> arg0 range) v1-0) + (set! v1-0 (-> arg0 range)) + ) + ) + (set! (-> arg0 value) v1-0) + (+ (-> arg0 min) v1-0) + ) + ) + +;; definition for function angle-tracker-seek! +(defun angle-tracker-seek! ((arg0 angle-tracker) (arg1 float)) + (let* ((v1-0 arg0) + (f1-1 (the float (sar (shl (the int (+ (-> v1-0 min) (-> v1-0 value))) 48) 48))) + (f0-6 (* (-> arg0 speed) (-> *display* seconds-per-frame))) + (v1-9 (the float (sar (shl (the int (- arg1 f1-1)) 48) 48))) + ) + (when (< (fabs v1-9) f0-6) + (let ((f0-8 (+ (-> arg0 value) v1-9))) + (cond + ((= (-> arg0 range) 0.0) + (set! (-> arg0 value) (the float (sar (shl (the int f0-8) 48) 48))) + (return #t) + ) + (else + (when (< f0-8 0.0) + (set! (-> arg0 value) 0.0) + (return #f) + ) + (when (< (-> arg0 range) f0-8) + (set! (-> arg0 value) (-> arg0 range)) + (return #f) + ) + (set! (-> arg0 value) f0-8) + (return #t) + ) + ) + ) + (set! v1-9 (the-as float 0)) + ) + (cond + ((< v1-9 0.0) + (let ((f0-14 (- (-> arg0 value) f0-6))) + (set! f0-14 (cond + ((= (-> arg0 range) 0.0) + (the float (sar (shl (the int f0-14) 48) 48)) + ) + (else + (if (< f0-14 0.0) + (set! f0-14 0.0) + ) + f0-14 + ) + ) + ) + (set! (-> arg0 value) (the float (sar (shl (the int f0-14) 48) 48))) + ) + ) + (else + (let ((f0-20 (+ (-> arg0 value) f0-6))) + (set! f0-20 (cond + ((= (-> arg0 range) 0.0) + (the float (sar (shl (the int f0-20) 48) 48)) + ) + (else + (if (< (-> arg0 range) f0-20) + (set! f0-20 (-> arg0 range)) + ) + f0-20 + ) + ) + ) + (set! (-> arg0 value) (the float (sar (shl (the int f0-20) 48) 48))) + ) + ) + ) + ) + #f + ) + +;; failed to figure out what this is: +(defpartgroup group-beach-sack-fuse + :id 117 + :bounds (static-bspherem 0 0 0 1) + :parts + ((sp-item 517 :fade-after (meters 30)) + (sp-item 518 :fade-after (meters 120) :falloff-to (meters 120)) + (sp-item 519 :fade-after (meters 80) :falloff-to (meters 80)) + ) + ) + +;; failed to figure out what this is: +(defpart 517 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #xf :page #x2)) + (sp-flt spt-num 4.0) + (sp-flt spt-scale-x (meters 0.1)) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 192.0) + (sp-flt spt-g 192.0) + (sp-rnd-flt spt-b 64.0 128.0 1.0) + (sp-rnd-flt spt-a 4.0 24.0 1.0) + (sp-flt spt-vel-y (meters 0.013333334)) + (sp-rnd-flt spt-rotvel-z (degrees -0.15) (degrees 0.3) 1.0) + (sp-flt spt-fade-a 2.1333334) + (sp-flt spt-accel-y -0.4096) + (sp-int-plain-rnd spt-timer 45 14 1) + (sp-cpuinfo-flags bit2 bit3) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 180.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 518 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 1.0) + (sp-rnd-flt spt-scale-x (meters 0.25) (meters 1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 192.0) + (sp-flt spt-g 192.0) + (sp-rnd-flt spt-b 64.0 128.0 1.0) + (sp-rnd-flt spt-a 48.0 48.0 1.0) + (sp-int spt-timer 5) + (sp-cpuinfo-flags bit2 bit3) + ) + ) + +;; failed to figure out what this is: +(defpart 519 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 4.0) + (sp-flt spt-scale-x (meters 0.2)) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 32.0) + (sp-flt spt-g 32.0) + (sp-rnd-flt spt-b 8.0 24.0 1.0) + (sp-rnd-flt spt-a 160.0 95.0 1.0) + (sp-flt spt-scalevel-x (meters 0.016666668)) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-a -8.366014) + (sp-flt spt-accel-y -8.192) + (sp-int spt-timer 15) + (sp-cpuinfo-flags bit2 bit3) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 180.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-conerot-radius (meters 0.6) (meters 0.2) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpartgroup group-beach-sack-explosion + :id 118 + :flags (use-local-clock) + :bounds (static-bspherem 0 0 0 16) + :parts + ((sp-item 520 :period 1200 :length 30) + (sp-item 521 :fade-after (meters 60) :period 1200 :length 15) + (sp-item 522 :period 1200 :length 15 :offset 15) + (sp-item 523 :period 1200 :length 15) + (sp-item 524 :fade-after (meters 80) :falloff-to (meters 80) :period 1200 :length 30 :binding 525) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + (sp-item 525 :flags (start-dead)) + ) + ) + +;; failed to figure out what this is: +(defpart 520 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x2)) + (sp-flt spt-num 1.5) + (sp-rnd-flt spt-y (meters 0.5) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-x (meters 2.5) (meters 1.5) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 70.0) + (sp-flt spt-g 70.0) + (sp-rnd-flt spt-b 70.0 16.0 1.0) + (sp-flt spt-a 96.0) + (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.033333335) 1.0) + (sp-flt spt-scalevel-x (meters 0.006)) + (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-accel-y 0.2048) + (sp-flt spt-friction 0.92) + (sp-int spt-timer 900) + (sp-cpuinfo-flags bit2 bit12 bit14) + (sp-int-plain-rnd spt-next-time 30 299 1) + (sp-launcher-by-id spt-next-launcher 526) + (sp-rnd-flt spt-conerot-x (degrees 70.0) (degrees 20.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-radius (meters 2)) + ) + ) + +;; failed to figure out what this is: +(defpart 526 + :init-specs + ((sp-flt spt-scalevel-x (meters 0)) (sp-copy-from-other spt-scalevel-y -4) (sp-flt spt-fade-a -0.32)) + ) + +;; failed to figure out what this is: +(defpart 521 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #x2)) + (sp-flt spt-num 6.0) + (sp-flt spt-y (meters 0.75)) + (sp-rnd-flt spt-scale-x (meters 8) (meters 8) 1.0) + (sp-int spt-rot-x 4) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 1.2) (meters 3) 1.0) + (sp-flt spt-r 192.0) + (sp-flt spt-g 192.0) + (sp-rnd-flt spt-b 64.0 128.0 1.0) + (sp-flt spt-a 0.0) + (sp-flt spt-scalevel-x (meters 0.009765625)) + (sp-rnd-flt spt-rotvel-z (degrees -0.15) (degrees 0.3) 1.0) + (sp-flt spt-scalevel-y (meters 0.009765625)) + (sp-flt spt-fade-a 2.1333334) + (sp-int spt-timer 30) + (sp-cpuinfo-flags bit2 bit3 bit14) + (sp-int spt-next-time 15) + (sp-launcher-by-id spt-next-launcher 527) + (sp-flt spt-rotate-y (degrees 0.0)) + ) + ) + +;; failed to figure out what this is: +(defpart 527 + :init-specs + ((sp-flt spt-fade-a -1.3333334)) + ) + +;; failed to figure out what this is: +(defpart 522 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters 1)) + (sp-rnd-flt spt-scale-x (meters 24) (meters 16) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 196.0) + (sp-flt spt-g 196.0) + (sp-flt spt-b 196.0) + (sp-flt spt-a 64.0) + (sp-int spt-timer 5) + (sp-cpuinfo-flags bit2 bit3 bit14) + ) + ) + +;; failed to figure out what this is: +(defpart 523 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters 1)) + (sp-rnd-flt spt-scale-x (meters 24) (meters 16) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 196.0) + (sp-flt spt-g 32.0) + (sp-flt spt-b 32.0) + (sp-flt spt-a 64.0) + (sp-int spt-timer 5) + (sp-cpuinfo-flags bit2 bit3 bit14) + ) + ) + +;; failed to figure out what this is: +(defpart 524 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #xf :page #x2)) + (sp-rnd-flt spt-num 5.0 10.0 1.0) + (sp-rnd-flt spt-x (meters -0.5) (meters 1) 1.0) + (sp-rnd-flt spt-y (meters 0.25) (meters 1.5) 1.0) + (sp-rnd-flt spt-z (meters -0.5) (meters 1) 1.0) + (sp-flt spt-scale-x (meters 0.5)) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 255.0) + (sp-rnd-int spt-g 1123942400 1 127.0) + (sp-flt spt-b 0.0) + (sp-flt spt-a 127.0) + (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.06666667) 1.0) + (sp-flt spt-fade-g -4.266667) + (sp-flt spt-fade-b -2.8444445) + (sp-flt spt-accel-y -16.384) + (sp-flt spt-friction 0.97) + (sp-int spt-timer 90) + (sp-cpuinfo-flags bit2 bit3 bit14) + (sp-int-plain-rnd spt-next-time 5 38 1) + (sp-launcher-by-id spt-next-launcher 528) + (sp-rnd-flt spt-conerot-x (degrees 40.0) (degrees 30.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 528 + :init-specs + ((sp-flt spt-scalevel-x (meters -0.0033333334)) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-r -4.266667) + (sp-flt spt-fade-g 0.7111111) + (sp-flt spt-fade-b 1.4222223) + (sp-flt spt-fade-a -2.8444445) + ) + ) + +;; failed to figure out what this is: +(defpart 525 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x2)) + (sp-flt spt-num 2.0) + (sp-rnd-flt spt-x (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-y (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-z (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-x (meters 0.5) (meters 0.5) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 70.0) + (sp-flt spt-g 70.0) + (sp-rnd-flt spt-b 70.0 16.0 1.0) + (sp-rnd-flt spt-a 20.0 8.0 1.0) + (sp-flt spt-scalevel-x (meters 0.0033333334)) + (sp-rnd-flt spt-rotvel-z (degrees -0.3) (degrees 0.6) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-a -0.11666667) + (sp-int spt-timer 300) + (sp-cpuinfo-flags bit2 bit12 bit14) + ) + ) + +;; failed to figure out what this is: +(defpartgroup group-beach-cannon-fire + :id 119 + :flags (use-local-clock) + :bounds (static-bspherem 0 0 0 24) + :parts + ((sp-item 529 :fade-after (meters 200) :falloff-to (meters 200) :period 1200 :length 30) + (sp-item 530 :fade-after (meters 100) :falloff-to (meters 100) :period 1200 :length 15) + (sp-item 531 :fade-after (meters 40) :falloff-to (meters 40) :period 1200 :length 15) + (sp-item 532 :period 1200 :length 15 :offset 15) + (sp-item 533 :period 1200 :length 15) + (sp-item 534 :fade-after (meters 40) :falloff-to (meters 40) :period 1200 :length 15 :binding 535) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + (sp-item 535 :flags (start-dead)) + ) + ) + +;; failed to figure out what this is: +(defpart 529 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x2)) + (sp-flt spt-num 6.0) + (sp-rnd-flt spt-scale-x (meters 1.5) (meters 1.5) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 64.0) + (sp-flt spt-g 64.0) + (sp-rnd-flt spt-b 64.0 16.0 1.0) + (sp-flt spt-a 48.0) + (sp-rnd-flt spt-vel-y (meters 0.1) (meters 0.013333334) 1.0) + (sp-flt spt-vel-z (meters -0.033333335)) + (sp-flt spt-scalevel-x (meters 0.016666668)) + (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-accel-y 0.27306667) + (sp-flt spt-friction 0.92) + (sp-int spt-timer 900) + (sp-cpuinfo-flags bit2 bit12) + (sp-int-plain-rnd spt-next-time 30 299 1) + (sp-launcher-by-id spt-next-launcher 536) + (sp-flt spt-launchrot-x (degrees 90.0)) + (sp-rnd-flt spt-launchrot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-x (degrees 45.0)) + (sp-flt spt-conerot-radius (meters 2)) + (sp-flt spt-rotate-y (degrees 90.0)) + ) + ) + +;; failed to figure out what this is: +(defpart 536 + :init-specs + ((sp-flt spt-scalevel-x (meters 0.006666667)) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-a -0.16) + ) + ) + +;; failed to figure out what this is: +(defpart 530 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x2)) + (sp-flt spt-num 5.0) + (sp-rnd-flt spt-scale-x (meters 1.5) (meters 1.5) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 64.0) + (sp-flt spt-g 64.0) + (sp-rnd-flt spt-b 64.0 16.0 1.0) + (sp-flt spt-a 48.0) + (sp-rnd-flt spt-vel-z (meters 0.3) (meters 0.06666667) 1.0) + (sp-flt spt-scalevel-x (meters 0.026666667)) + (sp-rnd-int-flt spt-rotvel-z (degrees -0.3) 1 109.22667) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-accel-y -0.27306667) + (sp-flt spt-friction 0.96) + (sp-int spt-timer 900) + (sp-cpuinfo-flags bit2 bit12) + (sp-int-plain-rnd spt-next-time 30 149 1) + (sp-launcher-by-id spt-next-launcher 536) + (sp-rnd-flt spt-launchrot-x (degrees -83.0) (degrees -7.0000005) 1.0) + (sp-rnd-flt spt-launchrot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-x (degrees 45.0)) + (sp-flt spt-conerot-radius (meters 2)) + (sp-flt spt-rotate-y (degrees 90.0)) + ) + ) + +;; failed to figure out what this is: +(defpart 531 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x2 :page #x2)) + (sp-flt spt-num 6.0) + (sp-flt spt-y (meters 0.75)) + (sp-rnd-flt spt-scale-x (meters 16) (meters 16) 1.0) + (sp-int spt-rot-x 4) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 1.2) (meters 3) 1.0) + (sp-flt spt-r 192.0) + (sp-flt spt-g 192.0) + (sp-rnd-flt spt-b 64.0 128.0 1.0) + (sp-flt spt-a 0.0) + (sp-flt spt-scalevel-x (meters 0.009765625)) + (sp-rnd-flt spt-rotvel-z (degrees -0.15) (degrees 0.3) 1.0) + (sp-flt spt-scalevel-y (meters 0.009765625)) + (sp-flt spt-fade-a 2.1333334) + (sp-int spt-timer 30) + (sp-cpuinfo-flags bit2 bit3) + (sp-int spt-next-time 15) + (sp-launcher-by-id spt-next-launcher 537) + ) + ) + +;; failed to figure out what this is: +(defpart 537 + :init-specs + ((sp-flt spt-fade-a -1.3333334)) + ) + +;; failed to figure out what this is: +(defpart 532 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters 1)) + (sp-rnd-flt spt-scale-x (meters 24) (meters 16) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 196.0) + (sp-flt spt-g 196.0) + (sp-flt spt-b 196.0) + (sp-flt spt-a 64.0) + (sp-int spt-timer 5) + (sp-cpuinfo-flags bit2 bit3) + ) + ) + +;; failed to figure out what this is: +(defpart 533 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #x12 :page #x2)) + (sp-flt spt-num 1.0) + (sp-flt spt-y (meters 1)) + (sp-rnd-flt spt-scale-x (meters 24) (meters 16) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 196.0) + (sp-flt spt-g 32.0) + (sp-flt spt-b 32.0) + (sp-flt spt-a 64.0) + (sp-int spt-timer 5) + (sp-cpuinfo-flags bit2 bit3) + ) + ) + +;; failed to figure out what this is: +(defpart 534 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :index #xf :page #x2)) + (sp-rnd-flt spt-num 5.0 10.0 1.0) + (sp-rnd-flt spt-scale-x (meters 0.5) (meters 1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 255.0) + (sp-flt spt-g 255.0) + (sp-flt spt-b 0.0) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-z (meters 0.16666667) (meters 0.16666667) 1.0) + (sp-flt spt-fade-g -4.2222223) + (sp-flt spt-fade-b -2.8) + (sp-rnd-flt spt-accel-y -6.826667 -3.4133334 1.0) + (sp-flt spt-friction 0.95) + (sp-int spt-timer 600) + (sp-cpuinfo-flags bit2 bit3) + (sp-int-plain-rnd spt-next-time 10 89 1) + (sp-launcher-by-id spt-next-launcher 538) + (sp-rnd-flt spt-launchrot-x (degrees -60.0) (degrees -60.0) 1.0) + (sp-rnd-flt spt-launchrot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-x (degrees 45.0)) + (sp-flt spt-rotate-y (degrees 90.0)) + ) + ) + +;; failed to figure out what this is: +(defpart 538 + :init-specs + ((sp-flt spt-scalevel-x (meters -0.0033333334)) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-r -0.6) + (sp-flt spt-fade-g -1.8) + (sp-flt spt-fade-a -0.85333335) + ) + ) + +;; failed to figure out what this is: +(defpart 535 + :init-specs + ((sp-tex spt-texture (new 'static 'texture-id :page #x2)) + (sp-flt spt-num 0.5) + (sp-rnd-flt spt-x (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-y (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-z (meters -0.25) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-x (meters 1) (meters 1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-flt spt-r 64.0) + (sp-flt spt-g 64.0) + (sp-flt spt-b 64.0) + (sp-rnd-flt spt-a 16.0 8.0 1.0) + (sp-flt spt-scalevel-x (meters 0.006666667)) + (sp-rnd-flt spt-rotvel-z (degrees -0.6) (degrees 1.2) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-a -0.08) + (sp-int spt-timer 300) + (sp-cpuinfo-flags bit2 bit12) + ) + ) + +;; definition of type mistycannon-missile +(deftype mistycannon-missile (process-drawable) + ((root-override collide-shape-moving :offset 112) + (muzzle-time float :offset-assert 176) + (tumble-quat quaternion :inline :offset-assert 192) + (blast-radius float :offset-assert 208) + (water-height float :offset-assert 212) + (sfx uint32 :offset-assert 216) + (part2 sparticle-launch-control :offset-assert 220) + (ground-time uint64 :offset-assert 224) + ) + :heap-base #x80 + :method-count-assert 21 + :size-assert #xe8 + :flag-assert #x15008000e8 + (:methods + (spawn-part (_type_) none 20) + ) + (:states + mistycannon-missile-explode + mistycannon-missile-idle + mistycannon-missile-in-water + ) + ) + +;; definition for method 3 of type mistycannon-missile +(defmethod inspect mistycannon-missile ((obj mistycannon-missile)) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~T~Tmuzzle-time: ~f~%" (-> obj muzzle-time)) + (format #t "~T~Ttumble-quat: #~%" (-> obj tumble-quat)) + (format #t "~T~Tblast-radius: ~f~%" (-> obj blast-radius)) + (format #t "~T~Twater-height: ~f~%" (-> obj water-height)) + (format #t "~T~Tsfx: ~D~%" (-> obj sfx)) + (format #t "~T~Tpart2: ~A~%" (-> obj part2)) + (format #t "~T~Tground-time: ~D~%" (-> obj ground-time)) + obj + ) + +;; definition for method 7 of type mistycannon-missile +;; INFO: Return type mismatch process-drawable vs mistycannon-missile. +(defmethod relocate mistycannon-missile ((obj mistycannon-missile) (arg0 int)) + (if (nonzero? (-> obj part2)) + (&+! (-> obj part2) arg0) + ) + (the-as mistycannon-missile ((method-of-type process-drawable relocate) obj arg0)) + ) + +;; definition for method 10 of type mistycannon-missile +(defmethod deactivate mistycannon-missile ((obj mistycannon-missile)) + (if (nonzero? (-> obj part2)) + (kill-and-free-particles (-> obj part2)) + ) + ((method-of-type process-drawable deactivate) obj) + (none) + ) + +;; failed to figure out what this is: +(defskelgroup *mistycannon-missile-sg* sack + 0 + 2 + ((1 (meters 999999))) + :bounds (static-spherem 0 0 0 4) + :longest-edge (meters 0) + ) + +;; definition for method 20 of type mistycannon-missile +;; INFO: Return type mismatch int vs none. +(defmethod spawn-part mistycannon-missile ((obj mistycannon-missile)) + (let ((gp-0 (-> obj part)) + (a1-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 7))) + ) + (spawn gp-0 a1-1) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate mistycannon-missile-idle (mistycannon-missile) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('attack) + (go mistycannon-missile-explode) + ) + ) + ) + :enter + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (set! (-> self sfx) (the-as uint 0)) + 0 + (none) + ) + :trans + (behavior () + (if (< (-> self root-override trans y) (-> self water-height)) + (go mistycannon-missile-in-water) + ) + (none) + ) + :code + (behavior () + (clear-collide-with-as (-> self root-override)) + (while (< (- (-> *display* base-frame-counter) (-> self state-time)) (the int (* 300.0 (-> self muzzle-time)))) + (quaternion*! (-> self root-override quat) (-> self root-override quat) (-> self tumble-quat)) + (suspend) + (let ((f0-1 + (fmin + 1.0 + (/ (the float (- (-> *display* base-frame-counter) (-> self state-time))) + (the float (the int (* 300.0 (-> self muzzle-time)))) + ) + ) + ) + ) + (set! (-> self root-override scale x) (* 0.6 f0-1)) + (set! (-> self root-override scale y) (* 0.6 f0-1)) + (set! (-> self root-override scale z) (* 0.6 f0-1)) + ) + ) + (restore-collide-with-as (-> self root-override)) + (set-vector! (-> self root-override scale) 0.6 0.6 0.6 1.0) + (while (zero? (logand (-> self root-override status) 1)) + (if (and (zero? (-> self sfx)) + (< (if *target* + (vector-vector-distance (-> self root-override trans) (-> *target* control trans)) + 4096000.0 + ) + 409600.0 + ) + ) + (set! (-> self sfx) + (the-as + uint + (sound-play-by-name + (static-sound-name "sack-incoming") + (new-sound-id) + 1024 + 0 + 0 + 1 + (the-as symbol (-> self root-override trans)) + ) + ) + ) + ) + (when (nonzero? (-> self sfx)) + (let ((gp-1 (the-as sound-rpc-set-param (get-sound-buffer-entry)))) + (set! (-> gp-1 command) (sound-command set-param)) + (set! (-> gp-1 id) (the-as sound-id (-> self sfx))) + (let ((a1-3 (-> self root-override trans))) + (let ((s5-1 self)) + (when (= a1-3 #t) + (if (and s5-1 (type-type? (-> s5-1 type) process-drawable) (nonzero? (-> s5-1 root-override))) + (set! a1-3 (-> s5-1 root-override trans)) + (set! a1-3 (the-as vector #f)) + ) + ) + ) + (sound-trans-convert (-> gp-1 parms trans) a1-3) + ) + (set! (-> gp-1 parms mask) (the-as uint 32)) + (-> gp-1 id) + ) + ) + (quaternion*! (-> self root-override quat) (-> self root-override quat) (-> self tumble-quat)) + (suspend) + ) + (quaternion-set! (-> self root-override quat) 0.0 0.0 0.0 1.0) + (update-transforms! (-> self root-override)) + (when (nonzero? (-> self sfx)) + (sound-stop (the-as sound-id (-> self sfx))) + (set! (-> self sfx) (the-as uint 0)) + 0 + ) + (set! (-> self ground-time) (the-as uint (-> *display* base-frame-counter))) + (sound-play-by-name + (static-sound-name "sack-land") + (new-sound-id) + 1024 + 0 + 0 + 1 + (the-as symbol (-> self root-override trans)) + ) + (let ((a0-18 (-> self skel root-channel 0))) + (set! (-> a0-18 frame-group) (the-as art-joint-anim (-> self draw art-group data 3))) + (set! (-> a0-18 param 0) + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 3)) data 0 length) -1)) + ) + (set! (-> a0-18 param 1) 1.0) + (set! (-> a0-18 frame-num) 0.0) + (joint-control-channel-group! a0-18 (the-as art-joint-anim (-> self draw art-group data 3)) num-func-seek!) + ) + (until (ja-done? 0) + (suspend) + (let ((a0-19 (-> self skel root-channel 0))) + (set! (-> a0-19 param 0) (the float (+ (-> a0-19 frame-group data 0 length) -1))) + (set! (-> a0-19 param 1) 1.0) + (joint-control-channel-group-eval! a0-19 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + (let ((a0-21 (-> self skel root-channel 0))) + (set! (-> a0-21 frame-group) (the-as art-joint-anim (-> self draw art-group data 4))) + (set! (-> a0-21 param 0) + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 4)) data 0 length) -1)) + ) + (set! (-> a0-21 param 1) 1.0) + (set! (-> a0-21 frame-num) 0.0) + (joint-control-channel-group! a0-21 (the-as art-joint-anim (-> self draw art-group data 4)) num-func-seek!) + ) + (until (ja-done? 0) + (suspend) + (let ((a0-22 (-> self skel root-channel 0))) + (set! (-> a0-22 param 0) (the float (+ (-> a0-22 frame-group data 0 length) -1))) + (set! (-> a0-22 param 1) 1.0) + (joint-control-channel-group-eval! a0-22 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + (go mistycannon-missile-explode) + (none) + ) + :post + (behavior () + (vector-v++! + (-> self root-override transv) + (compute-acc-due-to-gravity (-> self root-override) (new-stack-vector0) 1.0) + ) + (set! (-> self root-override root-prim prim-core offense) (collide-offense touch)) + (fill-cache-integrate-and-collide! + (-> self root-override) + (-> self root-override transv) + (-> self root-override root-prim collide-with) + ) + (set! (-> self root-override root-prim prim-core offense) (collide-offense indestructible)) + (spawn-part self) + (when (and (zero? (-> self draw cur-lod)) (logtest? (-> self draw status) (draw-status drwf03))) + (if (logtest? (-> self root-override status) 1) + (draw-shadow + (-> self root-override shadow-pos) + (-> self root-override shadow-pos) + (-> self root-override ground-poly-normal) + 8192.0 + 4096.0 + (the-as float 0) + ) + (find-ground-and-draw-shadow + (-> self root-override trans) + (-> self root-override shadow-pos) + 8192.0 + (collide-kind background) + (the-as process #f) + 0.0 + 81920.0 + ) + ) + ) + (ja-post) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate mistycannon-missile-in-water (mistycannon-missile) + :code + (behavior () + (when (nonzero? (-> self sfx)) + (sound-stop (the-as sound-id (-> self sfx))) + (set! (-> self sfx) (the-as uint 0)) + 0 + ) + (let ((a1-0 (new-stack-vector0))) + (set! (-> a1-0 x) (-> self root-override trans x)) + (set! (-> a1-0 y) (-> self water-height)) + (set! (-> a1-0 z) (-> self root-override trans z)) + (set! (-> a1-0 w) 1.0) + (splash-spawn (the-as basic 1.0) (the-as basic a1-0) 1) + ) + (label cfg-3) + (vector-v++! + (-> self root-override transv) + (compute-acc-due-to-gravity (-> self root-override) (new-stack-vector0) 1.0) + ) + (vector-float*! (-> self root-override transv) (-> self root-override transv) 0.5) + (update-transforms! (-> self root-override)) + (fill-cache-integrate-and-collide! + (-> self root-override) + (-> self root-override transv) + (-> self root-override root-prim collide-with) + ) + (set! (-> self root-override scale x) + (seek (-> self root-override scale x) 0.0 (* 0.01 (-> *display* time-adjust-ratio))) + ) + (set! (-> self root-override scale y) + (seek (-> self root-override scale y) 0.0 (* 0.01 (-> *display* time-adjust-ratio))) + ) + (set! (-> self root-override scale z) + (seek (-> self root-override scale z) 0.0 (* 0.01 (-> *display* time-adjust-ratio))) + ) + (when (< 0.05 (-> self root-override scale x)) + (suspend) + (goto cfg-3) + ) + (ja-channel-set! 0) + (none) + ) + :post + (the-as (function none :behavior mistycannon-missile) ja-post) + ) + +;; failed to figure out what this is: +(defstate mistycannon-missile-explode (mistycannon-missile) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('touched) + (let* ((s4-0 arg0) + (v1-2 (if (and (nonzero? s4-0) (type-type? (-> s4-0 type) process-drawable)) + s4-0 + ) + ) + ) + (when v1-2 + (let* ((v1-3 (-> (the-as mistycannon-missile v1-2) root-override)) + (a1-2 (-> self root-override root-prim prim-core)) + (v1-5 (-> v1-3 root-prim prim-core)) + (a2-1 (new 'stack-no-clear 'vector)) + (t2-0 (new 'stack-no-clear 'collide-mesh-cache-tri)) + ) + 0.0 + (vector-! a2-1 (the-as vector v1-5) (the-as vector a1-2)) + (when (< (fill-and-probe-using-line-sphere + *collide-cache* + (the-as vector a1-2) + a2-1 + 40.96 + (collide-kind background) + self + (the-as collide-tri-result t2-0) + 1 + ) + 0.0 + ) + (cond + ((= (-> arg0 type) target) + (let ((a1-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-3 from) self) + (set! (-> a1-3 num-params) 2) + (set! (-> a1-3 message) 'attack) + (set! (-> a1-3 param 0) (-> arg3 param 0)) + (let ((a0-8 (new 'static 'attack-info :mask #x20))) + (set! (-> a0-8 mode) 'explode) + (set! (-> a1-3 param 1) (the-as uint a0-8)) + ) + (send-event-function arg0 a1-3) + ) + ) + (else + (let ((a1-4 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-4 from) self) + (set! (-> a1-4 num-params) 4) + (set! (-> a1-4 message) 'attack) + (set! (-> a1-4 param 0) (-> arg3 param 0)) + (set! (-> a1-4 param 1) (the-as uint 'explode)) + (let ((v1-18 (+ *global-attack-id* 1))) + (set! *global-attack-id* v1-18) + (set! (-> a1-4 param 2) (the-as uint v1-18)) + ) + (set! (-> a1-4 param 3) (the-as uint 0)) + (send-event-function arg0 a1-4) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + :code + (behavior () + (if (and *target* (= (-> *target* next-state name) 'target-periscope)) + (sound-play-by-spec + (new 'static 'sound-spec + :mask #xc0 + :num 1.0 + :group #x1 + :sound-name (static-sound-name "explosion") + :volume #x400 + :fo-min #xc8 + :fo-max #x190 + ) + (new-sound-id) + (the-as vector #t) + ) + (sound-play-by-spec + (new 'static 'sound-spec :num 1.0 :group #x1 :sound-name (static-sound-name "explosion") :volume #x400) + (new-sound-id) + (the-as vector #t) + ) + ) + (spawn (-> self part2) (-> self root-override trans)) + (ja-channel-set! 0) + (let ((v1-11 (-> self root-override root-prim))) + (set! (-> v1-11 local-sphere w) (-> self blast-radius)) + (set! (-> v1-11 prim-core world-sphere w) (-> self blast-radius)) + (set! (-> v1-11 collide-with) (collide-kind cak-2 cak-3 target crate enemy wall-object)) + (set! (-> v1-11 prim-core collide-as) (collide-kind enemy)) + ) + (update-transforms! (-> self root-override)) + (let ((a1-3 (new 'stack-no-clear 'overlaps-others-params))) + (set! (-> a1-3 options) (the-as uint 0)) + (set! (-> a1-3 tlist) *touching-list*) + (find-overlapping-shapes (-> self root-override) a1-3) + ) + (suspend) + (clear-collide-with-as (-> self root-override)) + (let ((gp-2 (-> *display* base-frame-counter))) + (until (>= (- (-> *display* base-frame-counter) gp-2) 900) + (spawn (-> self part2) (-> self root-override trans)) + (suspend) + ) + ) + (kill-and-free-particles (-> self part2)) + (deactivate self) + (none) + ) + :post + (the-as (function none :behavior mistycannon-missile) ja-post) + ) + +;; definition for function mistycannon-collision-reaction +;; INFO: Return type mismatch int vs none. +(defun mistycannon-collision-reaction ((arg0 collide-shape-moving) (arg1 collide-shape-intersect)) + (let ((s5-0 0)) + (let ((a1-1 (new 'stack-no-clear 'vector))) + (vector-float*! a1-1 (-> arg1 move-vec) (-> arg1 best-u)) + (move-by-vector! arg0 a1-1) + ) + (let ((f0-2 (vector-dot (-> arg0 transv) (-> arg1 best-tri normal))) + (v1-6 (new 'stack-no-clear 'vector)) + ) + (vector-float*! v1-6 (-> arg1 best-tri normal) (* 2.0 f0-2)) + (vector-! (-> arg0 transv) (-> arg0 transv) v1-6) + ) + (vector-float*! (-> arg0 transv) (-> arg0 transv) 0.15) + (let ((v0-1 (logior s5-0 7))) + (logior! (-> arg0 status) v0-1) + ) + ) + (none) + ) + +;; definition of type mistycannon-init-data +(deftype mistycannon-init-data (structure) + ((pos vector :offset-assert 0) + (vel vector :offset-assert 4) + (rotate float :offset-assert 8) + (flight-time float :offset-assert 12) + (muzzle-time float :offset-assert 16) + (blast-radius float :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) + +;; definition for method 3 of type mistycannon-init-data +(defmethod inspect mistycannon-init-data ((obj mistycannon-init-data)) + (format #t "[~8x] ~A~%" obj 'mistycannon-init-data) + (format #t "~Tpos: #~%" (-> obj pos)) + (format #t "~Tvel: #~%" (-> obj vel)) + (format #t "~Trotate: ~f~%" (-> obj rotate)) + (format #t "~Tflight-time: ~f~%" (-> obj flight-time)) + (format #t "~Tmuzzle-time: ~f~%" (-> obj muzzle-time)) + (format #t "~Tblast-radius: ~f~%" (-> obj blast-radius)) + obj + ) + +;; definition for function mistycannon-missile-init-by-other +;; INFO: Return type mismatch object vs none. +;; Used lq/sq +(defbehavior mistycannon-missile-init-by-other mistycannon-missile ((arg0 mistycannon-init-data) (arg1 entity)) + (set! (-> self mask) (logior (process-mask projectile) (-> self mask))) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self entity) arg1) + (let ((s5-0 (new 'process 'collide-shape-moving self (collide-list-enum hit-by-player)))) + (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s5-0 reaction) + (the-as + (function collide-shape-moving collide-shape-intersect vector vector none) + mistycannon-collision-reaction + ) + ) + (set! (-> s5-0 no-reaction) + (the-as (function collide-shape-moving collide-shape-intersect vector vector none) nothing) + ) + (let ((s4-0 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> s4-0 prim-core collide-as) (collide-kind enemy)) + (set! (-> s4-0 collide-with) (collide-kind background cak-2 cak-3 target crate enemy wall-object)) + (set! (-> s4-0 prim-core action) (collide-action solid)) + (set! (-> s4-0 prim-core offense) (collide-offense touch)) + (set! (-> s4-0 transform-index) 0) + (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 1720.3201) + (set-root-prim! s5-0 s4-0) + ) + (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w))) + (backup-collide-with-as s5-0) + (set! (-> s5-0 event-self) 'touched) + (set! (-> s5-0 max-iteration-count) (the-as uint 4)) + (set! (-> self root-override) s5-0) + ) + (set! (-> self root-override trans quad) (-> arg0 pos quad)) + (set-vector! (-> self root-override scale) 0.0 0.0 0.0 1.0) + (set! (-> self muzzle-time) (-> arg0 muzzle-time)) + (quaternion-axis-angle! (-> self root-override quat) 0.0 1.0 0.0 (-> arg0 rotate)) + (let ((f0-13 (/ 655360.0 (the float (the int (* 300.0 (-> arg0 flight-time))))))) + (quaternion-axis-angle! (-> self tumble-quat) 1.0 0.0 0.0 f0-13) + ) + (initialize-skeleton self *mistycannon-missile-sg* '()) + (set! (-> self root-override transv quad) (-> arg0 vel quad)) + (set! (-> self blast-radius) (-> arg0 blast-radius)) + (set! (-> self water-height) (res-lump-float (-> self entity) 'water-height :default -4096000.0)) + (set! (-> self part) (create-launch-control (-> *part-group-id-table* 117) self)) + (set! (-> self part2) (create-launch-control (-> *part-group-id-table* 118) self)) + (go mistycannon-missile-idle) + (none) + ) + +;; definition for function spawn-mistycannon-missile +;; INFO: Return type mismatch int vs none. +(defun spawn-mistycannon-missile ((arg0 process-tree) + (arg1 vector) + (arg2 vector) + (arg3 float) + (arg4 float) + (arg5 float) + (arg6 float) + (arg7 entity) + ) + (let ((s5-0 (new 'stack-no-clear 'mistycannon-init-data))) + (set! (-> s5-0 pos) arg1) + (set! (-> s5-0 vel) arg2) + (set! (-> s5-0 rotate) arg3) + (set! (-> s5-0 flight-time) arg4) + (set! (-> s5-0 muzzle-time) arg5) + (set! (-> s5-0 blast-radius) arg6) + (let ((s3-0 (get-process *default-dead-pool* mistycannon-missile #x4000))) + (when s3-0 + (let ((t9-1 (method-of-type mistycannon-missile activate))) + (t9-1 (the-as mistycannon-missile s3-0) arg0 'mistycannon-missile (the-as pointer #x70004000)) + ) + (run-now-in-process s3-0 mistycannon-missile-init-by-other s5-0 arg7) + (-> s3-0 ppointer) + ) + ) + ) + 0 + (none) + ) + +;; definition of type mistycannon +(deftype mistycannon (process-drawable) + ((root-override collide-shape-moving :offset 112) + (rotate angle-tracker :inline :offset-assert 176) + (fact-info-override fact-info-enemy :offset 144) + (tilt angle-tracker :inline :offset-assert 192) + (front-wheel float :offset-assert 208) + (rear-wheel float :offset-assert 212) + (last-known-rotation float :offset-assert 216) + (part-timer uint64 :offset-assert 224) + (hellmouth vector :inline :offset-assert 240) + (postbindinfo-ok symbol :offset-assert 256) + (launch-origin vector :inline :offset-assert 272) + (goggles vector :inline :offset-assert 288) + (avoid-entity entity-actor :offset-assert 304) + (center-point vector :inline :offset-assert 320) + (at-point vector :inline :offset-assert 336) + (accuracy-range float :offset-assert 352) + (target-theta float :offset-assert 356) + (sound-id sound-id :offset-assert 360) + (aim-sound-id sound-id :offset-assert 364) + (player-touching-grips? symbol :offset-assert 368) + ) + :heap-base #x110 + :method-count-assert 24 + :size-assert #x174 + :flag-assert #x1801100174 + (:methods + (rotate! (_type_ float) none 20) + (tilt! (_type_ float) none 21) + (dummy-22 (_type_ float float float) none 22) + (dummy-23 (_type_) none 23) + ) + (:states + mistycannon-aim-at-player + mistycannon-idle + mistycannon-player-control + mistycannon-waiting-for-player + mistycannon-waiting-for-player-to-fuck-off + ) + ) + +;; definition for method 3 of type mistycannon +(defmethod inspect mistycannon ((obj mistycannon)) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~T~Trotate: #~%" (-> obj rotate)) + (format #t "~T~Ttilt: #~%" (-> obj tilt)) + (format #t "~T~Tfront-wheel: ~f~%" (-> obj front-wheel)) + (format #t "~T~Trear-wheel: ~f~%" (-> obj rear-wheel)) + (format #t "~T~Tlast-known-rotation: ~f~%" (-> obj last-known-rotation)) + (format #t "~T~Tpart-timer: ~D~%" (-> obj part-timer)) + (format #t "~T~Thellmouth: #~%" (-> obj hellmouth)) + (format #t "~T~Tpostbindinfo-ok: ~A~%" (-> obj postbindinfo-ok)) + (format #t "~T~Tlaunch-origin: #~%" (-> obj launch-origin)) + (format #t "~T~Tgoggles: #~%" (-> obj goggles)) + (format #t "~T~Tavoid-entity: ~A~%" (-> obj avoid-entity)) + (format #t "~T~Tcenter-point: #~%" (-> obj center-point)) + (format #t "~T~Tat-point: #~%" (-> obj at-point)) + (format #t "~T~Taccuracy-range: ~f~%" (-> obj accuracy-range)) + (format #t "~T~Ttarget-theta: ~f~%" (-> obj target-theta)) + (format #t "~T~Tsound-id: ~D~%" (-> obj sound-id)) + (format #t "~T~Taim-sound-id: ~D~%" (-> obj aim-sound-id)) + (format #t "~T~Tplayer-touching-grips?: ~A~%" (-> obj player-touching-grips?)) + obj + ) + +;; definition for function mistycannon-pick-random-target-point +(defbehavior mistycannon-pick-random-target-point mistycannon () + (let ((f30-0 (* (sqrtf (rand-vu)) (-> self center-point w))) + (f28-1 (* 65536.0 (rand-vu))) + ) + (set! (-> self at-point x) (+ (-> self center-point x) (* f30-0 (cos f28-1)))) + (set! (-> self at-point y) (-> self center-point y)) + (set! (-> self at-point z) (+ (-> self center-point z) (* f30-0 (sin f28-1)))) + ) + (set! (-> self at-point w) 1.0) + (let ((f0-11 (rand-vu-float-range 2730.6667 12743.111))) + (set! (-> self target-theta) f0-11) + f0-11 + ) + ) + +;; definition for method 20 of type mistycannon +;; INFO: Return type mismatch int vs none. +(defmethod rotate! mistycannon ((obj mistycannon) (arg0 float)) + (angle-tracker-apply-move! (-> obj rotate) arg0) + 0 + (none) + ) + +;; definition for method 21 of type mistycannon +;; INFO: Return type mismatch int vs none. +(defmethod tilt! mistycannon ((obj mistycannon) (arg0 float)) + (angle-tracker-apply-move! (-> obj tilt) arg0) + 0 + (none) + ) + +;; definition for method 22 of type mistycannon +;; INFO: Return type mismatch int vs none. +;; WARN: Expression building failed: Function (method 22 mistycannon) has a return type of none, but the expression builder found a return statement. +(defmethod dummy-22 mistycannon ((obj mistycannon) (arg0 float) (arg1 float) (arg2 float)) + (if (not (-> obj postbindinfo-ok)) + (return #f) + ) + (let* ((s3-0 (-> obj launch-origin)) + (s2-0 (new 'stack-no-clear 'vector)) + (v1-3 (-> obj rotate)) + (f30-0 (the float (sar (shl (the int (+ (-> v1-3 min) (-> v1-3 value))) 48) 48))) + (v1-8 (-> obj tilt)) + (f26-0 (the float (sar (shl (the int (+ (-> v1-8 min) (-> v1-8 value))) 48) 48))) + (f28-0 (/ 24576.0 arg0)) + ) + (let ((f24-0 (cos f26-0))) + (set! (-> s2-0 x) (* arg0 f24-0 (sin f30-0))) + (set! (-> s2-0 z) (* arg0 f24-0 (cos f30-0))) + ) + (set! (-> s2-0 y) (* arg0 (sin f26-0))) + (vector-float*! (-> obj hellmouth) s2-0 f28-0) + (vector+! (-> obj hellmouth) (-> obj hellmouth) s3-0) + (spawn-mistycannon-missile obj s3-0 s2-0 f30-0 arg1 f28-0 arg2 (-> obj entity)) + ) + (sound-play-by-name (static-sound-name "cannon-shot") (new-sound-id) 1024 0 0 1 #t) + (set! (-> obj part local-clock) 0) + (set! (-> obj part-timer) (the-as uint (-> *display* base-frame-counter))) + (mistycannon-pick-random-target-point) + 0 + (none) + ) + +;; definition for method 23 of type mistycannon +;; INFO: Return type mismatch int vs none. +(defmethod dummy-23 mistycannon ((obj mistycannon)) + (when (< (- (-> *display* base-frame-counter) (the-as int (-> obj part-timer))) 900) + (let ((v1-4 (-> obj rotate))) + (set! (-> *part-id-table* 529 init-specs 24 initial-valuef) + (the float (sar (shl (the int (+ (-> v1-4 min) (-> v1-4 value))) 48) 48)) + ) + ) + (let ((v1-12 (-> obj rotate))) + (set! (-> *part-id-table* 530 init-specs 23 initial-valuef) + (the float (sar (shl (the int (+ (-> v1-12 min) (-> v1-12 value))) 48) 48)) + ) + ) + (let ((v1-20 (-> obj rotate))) + (set! (-> *part-id-table* 534 init-specs 21 initial-valuef) + (the float (sar (shl (the int (+ (-> v1-20 min) (-> v1-20 value))) 48) 48)) + ) + ) + (let ((f0-18 16384.0) + (v1-28 (-> obj tilt)) + ) + (set! (-> *part-id-table* 529 init-specs 22 initial-valuef) + (- f0-18 (the float (sar (shl (the int (+ (-> v1-28 min) (-> v1-28 value))) 48) 48))) + ) + ) + (let ((f0-20 16384.0) + (v1-36 (-> obj tilt)) + ) + (set! (-> *part-id-table* 530 init-specs 21 initial-valuef) + (- f0-20 (the float (sar (shl (the int (+ (-> v1-36 min) (-> v1-36 value))) 48) 48))) + ) + ) + (let ((f0-22 16384.0) + (v1-44 (-> obj tilt)) + ) + (set! (-> *part-id-table* 534 init-specs 20 initial-valuef) + (- f0-22 (the float (sar (shl (the int (+ (-> v1-44 min) (-> v1-44 value))) 48) 48))) + ) + ) + (spawn (-> obj part) (-> obj hellmouth)) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defskelgroup *mistycannon-sg* mistycannon + 0 + 3 + ((1 (meters 20)) (2 (meters 999999))) + :bounds (static-spherem 0 5 0 9) + :longest-edge (meters 4) + ) + +;; definition for function mistycannon-prebind-function +;; INFO: Return type mismatch int vs none. +(defun mistycannon-prebind-function ((arg0 mistycannon) (arg1 int) (arg2 mistycannon)) + (let ((t9-0 quaternion-axis-angle!) + (a0-1 (&-> arg0 link)) + (a1-1 0.0) + (a2-1 1.0) + (a3-0 0.0) + (v1-0 (-> arg2 rotate)) + ) + (t9-0 + (the-as quaternion a0-1) + a1-1 + a2-1 + a3-0 + (the float (sar (shl (the int (+ (-> v1-0 min) (-> v1-0 value))) 48) 48)) + ) + ) + (let ((t9-1 quaternion-axis-angle!) + (a0-2 (&-> arg0 tilt min)) + (a1-2 -1.0) + (a2-2 0.0) + (a3-1 0.0) + (v1-4 (-> arg2 tilt)) + ) + (t9-1 + (the-as quaternion a0-2) + a1-2 + a2-2 + a3-1 + (the float (sar (shl (the int (+ (-> v1-4 min) (-> v1-4 value))) 48) 48)) + ) + ) + (let* ((v1-8 (-> arg2 rotate)) + (f0-16 + (- (the float (sar (shl (the int (+ (-> v1-8 min) (-> v1-8 value))) 48) 48)) (-> arg2 last-known-rotation)) + ) + ) + (set! (-> arg2 front-wheel) (the float (sar (shl (the int (+ (-> arg2 front-wheel) (* 5.0 f0-16))) 48) 48))) + (set! (-> arg2 rear-wheel) (the float (sar (shl (the int (+ (-> arg2 rear-wheel) (* 3.0 f0-16))) 48) 48))) + ) + (let ((v1-19 (-> arg2 rotate))) + (set! (-> arg2 last-known-rotation) + (the float (sar (shl (the int (+ (-> v1-19 min) (-> v1-19 value))) 48) 48)) + ) + ) + (quaternion-axis-angle! (the-as quaternion (&-> arg0 stack 324)) -1.0 0.0 0.0 (-> arg2 front-wheel)) + (quaternion-axis-angle! (the-as quaternion (&-> arg0 stack 276)) 1.0 0.0 0.0 (-> arg2 front-wheel)) + (quaternion-axis-angle! (the-as quaternion (&-> arg0 goggles y)) -1.0 0.0 0.0 (-> arg2 rear-wheel)) + (quaternion-axis-angle! (the-as quaternion (&-> arg0 at-point y)) 1.0 0.0 0.0 (-> arg2 rear-wheel)) + 0 + (none) + ) + +;; definition for function mistycannon-postbind-function +;; INFO: Return type mismatch int vs none. +;; Used lq/sq +(defun mistycannon-postbind-function ((arg0 mistycannon)) + (set! (-> arg0 launch-origin quad) (-> arg0 node-list data 4 bone transform vector 3 quad)) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (set-vector! s5-0 0.0 53248.0 -4096.0 1.0) + (vector-matrix*! s5-0 s5-0 (-> arg0 node-list data 3 bone transform)) + (set! (-> arg0 goggles quad) (-> s5-0 quad)) + ) + (set! (-> arg0 postbindinfo-ok) #t) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate mistycannon-idle (mistycannon) + :trans + (behavior () + (if (not (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status complete)))) + (go mistycannon-waiting-for-player) + ) + (if (and (-> self postbindinfo-ok) + *target* + (>= (-> self fact-info-override idle-distance) + (vector-vector-distance (-> self root-override trans) (-> *target* control trans)) + ) + ) + (go mistycannon-aim-at-player) + ) + (rider-trans) + (none) + ) + :code + (behavior () + (while #t + (dummy-23 self) + (suspend) + ) + (none) + ) + :post + (the-as (function none :behavior mistycannon) rider-post) + ) + +;; definition of type quadratic-solution +(deftype quadratic-solution (structure) + ((s1 float :offset-assert 0) + (s2 float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; definition for method 3 of type quadratic-solution +(defmethod inspect quadratic-solution ((obj quadratic-solution)) + (format #t "[~8x] ~A~%" obj 'quadratic-solution) + (format #t "~Ts1: ~f~%" (-> obj s1)) + (format #t "~Ts2: ~f~%" (-> obj s2)) + obj + ) + +;; definition for function solve-missile-tilt +(defun solve-missile-tilt ((arg0 quadratic-solution) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let* ((f1-3 (* 0.5 arg2 arg2 arg4)) + (f0-3 f1-3) + (f30-0 (- (* arg2 arg1 arg1))) + (f2-6 (+ f1-3 (* arg1 arg1 arg3))) + (f1-5 (- (* f30-0 f30-0) (* 4.0 f2-6 f0-3))) + (f28-0 (/ 0.5 f0-3)) + ) + (if (< f1-5 0.0) + (return #f) + ) + (let ((f26-0 (sqrtf f1-5))) + (set! (-> arg0 s1) (atan (* (+ (- f30-0) f26-0) f28-0) 1.0)) + (set! (-> arg0 s2) (atan (* (- (- f30-0) f26-0) f28-0) 1.0)) + ) + ) + #t + ) + +;; definition of type trajectory-params +(deftype trajectory-params (structure) + ((x float :offset-assert 0) + (y float :offset-assert 4) + (gravity float :offset-assert 8) + (theta float :offset-assert 12) + (speed float :offset-assert 16) + (time float :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) + +;; definition for method 3 of type trajectory-params +(defmethod inspect trajectory-params ((obj trajectory-params)) + (format #t "[~8x] ~A~%" obj 'trajectory-params) + (format #t "~Tx: ~f~%" (-> obj x)) + (format #t "~Ty: ~f~%" (-> obj y)) + (format #t "~Tgravity: ~f~%" (-> obj gravity)) + (format #t "~Ttheta: ~f~%" (-> obj theta)) + (format #t "~Tspeed: ~f~%" (-> obj speed)) + (format #t "~Ttime: ~f~%" (-> obj time)) + obj + ) + +;; definition for function solve-missile-velocity +;; INFO: Return type mismatch int vs none. +(defun solve-missile-velocity ((arg0 trajectory-params) (arg1 float)) + (set! (-> arg0 theta) arg1) + (let ((f0-4 (* (- (* (-> arg0 x) (tan arg1)) (-> arg0 y)) (/ 2.0 (-> arg0 gravity))))) + (when (< 0.0 f0-4) + (set! (-> arg0 time) (sqrtf f0-4)) + (set! (-> arg0 speed) (/ (-> arg0 x) (* (-> arg0 time) (cos arg1)))) + ) + ) + 0 + (none) + ) + +;; definition for function mistycannon-find-best-solution +(defbehavior mistycannon-find-best-solution mistycannon ((arg0 quadratic-solution)) + (let ((v1-0 #t) + (a1-0 #t) + (v0-0 -1) + ) + (let ((f1-0 (-> self tilt min)) + (f0-1 (+ (-> self tilt range) (-> self tilt min))) + ) + (if (< (-> arg0 s1) f1-0) + (set! v1-0 #f) + ) + (if (< f0-1 (-> arg0 s1)) + (set! v1-0 #f) + ) + (if (< (-> arg0 s2) f1-0) + (set! a1-0 #f) + ) + (if (< f0-1 (-> arg0 s2)) + (set! a1-0 #f) + ) + ) + (if v1-0 + (set! v0-0 0) + ) + (if a1-0 + (set! v0-0 1) + ) + (set! a1-0 (and v1-0 a1-0)) + (when a1-0 + (if (< (-> arg0 s1) (-> arg0 s2)) + (set! v0-0 0) + (set! v0-0 1) + ) + ) + v0-0 + ) + ) + +;; definition for function mistycannon-find-trajectory +(defbehavior mistycannon-find-trajectory mistycannon ((arg0 trajectory-params)) + (set! (-> arg0 time) 0.0) + (solve-missile-velocity arg0 (-> arg0 theta)) + (none) + ) + +;; definition for function mistycannon-do-aim +;; INFO: Return type mismatch int vs none. +;; WARN: Expression building failed: Function mistycannon-do-aim has a return type of none, but the expression builder found a return statement. +(defbehavior mistycannon-do-aim mistycannon ((arg0 vector) (arg1 vector)) + (if (not (-> self postbindinfo-ok)) + (return #f) + ) + (when (-> self avoid-entity) + (let ((a1-1 (-> self avoid-entity extra trans))) + (if (< (vector-vector-distance arg0 a1-1) 122880.0) + (return #f) + ) + ) + ) + (let ((gp-0 (new 'stack-no-clear 'trajectory-params))) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (vector-! s4-0 arg0 (-> self launch-origin)) + (set! (-> gp-0 x) (vector-xz-length s4-0)) + (set! (-> gp-0 y) (-> s4-0 y)) + ) + (set! (-> gp-0 gravity) (-> *standard-dynamics* gravity-length)) + (set! (-> gp-0 speed) 409600.0) + (set! (-> gp-0 theta) (-> self target-theta)) + (mistycannon-find-trajectory gp-0) + (let ((v1-12 (new 'stack-no-clear 'vector)) + (s4-1 (new 'stack-no-clear 'vector)) + ) + (vector-float*! v1-12 arg1 (* 0.4 (+ 2.0 (-> gp-0 time)))) + (vector+! s4-1 arg0 v1-12) + (let ((f30-0 (* (sqrtf (rand-vu)) (-> self accuracy-range))) + (f28-1 (* 65536.0 (rand-vu))) + ) + (+! (-> s4-1 x) (* f30-0 (cos f28-1))) + (+! (-> s4-1 z) (* f30-0 (sin f28-1))) + ) + (let ((s5-1 (new 'stack-no-clear 'vector))) + (vector-! s5-1 s4-1 (-> self launch-origin)) + (let ((f0-19 (atan (-> s5-1 x) (-> s5-1 z)))) + (angle-tracker-seek! (-> self rotate) f0-19) + ) + (set! (-> gp-0 x) (vector-xz-length s5-1)) + (set! (-> gp-0 y) (-> s5-1 y)) + ) + ) + (mistycannon-find-trajectory gp-0) + (when (= (-> gp-0 time) 0.0) + (when (>= (- (-> *display* base-frame-counter) (-> self state-time)) 900) + (dummy-22 self 409600.0 2.0 20480.0) + (set! (-> self state-time) (-> *display* base-frame-counter)) + ) + (return #f) + ) + (when (angle-tracker-seek! (-> self tilt) (-> gp-0 theta)) + (when (>= (- (-> *display* base-frame-counter) (-> self state-time)) 900) + (dummy-22 self (fmax 163840.0 (fmin 409600.0 (-> gp-0 speed))) (-> gp-0 time) 20480.0) + (set! (-> self state-time) (-> *display* base-frame-counter)) + ) + ) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate mistycannon-aim-at-player (mistycannon) + :enter + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (none) + ) + :trans + (behavior () + (if (not (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status complete)))) + (go mistycannon-waiting-for-player) + ) + (if (not (and *target* (>= (-> self fact-info-override idle-distance) + (vector-vector-distance (-> self root-override trans) (-> *target* control trans)) + ) + ) + ) + (go mistycannon-idle) + ) + (rider-trans) + (none) + ) + :code + (behavior () + (while #t + (if (< (vector-vector-xz-distance (target-pos 0) (-> self center-point)) (-> self center-point w)) + (mistycannon-do-aim (-> *target* control trans) (-> *target* control transv)) + (mistycannon-do-aim (-> self at-point) (new-stack-vector0)) + ) + (dummy-23 self) + (suspend) + ) + (none) + ) + :post + (the-as (function none :behavior mistycannon) rider-post) + ) + +;; failed to figure out what this is: +(defstate mistycannon-waiting-for-player (mistycannon) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('touch) + (when ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self root-override) + (the-as uint 1) + ) + (let ((v0-1 (the-as object #t))) + (set! (-> self player-touching-grips?) (the-as symbol v0-1)) + v0-1 + ) + ) + ) + (('change-mode) + (go mistycannon-player-control) + ) + ) + ) + :trans + (behavior () + (if (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status complete))) + (go mistycannon-aim-at-player) + ) + (rider-trans) + (none) + ) + :code + (behavior () + (set! (-> self player-touching-grips?) #f) + (while #t + (let ((f0-0 2730.6667) + (v1-0 (-> self tilt)) + ) + (if (< f0-0 (the float (sar (shl (the int (+ (-> v1-0 min) (-> v1-0 value))) 48) 48))) + (angle-tracker-seek! (-> self tilt) 2730.6667) + ) + ) + (dummy-23 self) + (when (and (-> self player-touching-grips?) (not (level-hint-displayed?))) + (set! (-> self player-touching-grips?) #f) + (hide-hud) + (level-hint-surpress!) + (kill-current-level-hint '() '(sidekick voicebox) 'exit) + (when (and (hud-hidden?) (can-grab-display? (the-as process-taskable self))) + (let ((gp-0 + (new 'stack 'font-context *font-default-matrix* 32 160 0.0 (font-color default) (font-flags shadow kerning)) + ) + ) + (let ((v1-15 gp-0)) + (set! (-> v1-15 width) (the float 440)) + ) + (let ((v1-16 gp-0)) + (set! (-> v1-16 height) (the float 80)) + ) + (set! (-> gp-0 flags) (font-flags shadow kerning large)) + (print-game-text (lookup-text! *common-text* (game-text-id press-to-use) #f) gp-0 #f 128 22) + ) + (when (cpad-pressed? 0 circle) + (while #t + (send-event *target* 'change-mode 'periscope self) + (suspend) + (suspend) + ) + ) + ) + ) + (suspend) + ) + (none) + ) + :post + (the-as (function none :behavior mistycannon) rider-post) + ) + +;; failed to figure out what this is: +(defstate cam-mistycannon (camera-slave) + :event + cam-standard-event-handler + :enter + (behavior () + (when (not (-> self enter-has-run)) + (set! (-> self blend-from-type) (the-as uint 1)) + (set! (-> self blend-to-type) (the-as uint 1)) + ) + (none) + ) + :trans + (behavior () + (if (zero? (logand (-> *camera* master-options) 2)) + (cam-slave-go cam-free-floating) + ) + (none) + ) + :code + (behavior () + (while #t + (let ((v1-0 (-> self change-event-from))) + (set! (-> self trans quad) (-> (the-as mistycannon (-> v1-0 0)) goggles quad)) + (let ((t9-0 matrix-rotate-yx!) + (a0-1 (-> self tracking)) + (v1-2 (-> (the-as mistycannon (-> v1-0 0)) rotate)) + ) + (t9-0 (the-as matrix a0-1) (the float (sar (shl (the int (+ (-> v1-2 min) (-> v1-2 value))) 48) 48)) 3640.889) + ) + ) + (suspend) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate mistycannon-player-control (mistycannon) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('change-mode) + (send-event *camera* 'change-state cam-mistycannon 0) + ) + ) + ) + :exit + (behavior () + (sound-stop (-> self sound-id)) + (sound-stop (-> self aim-sound-id)) + (none) + ) + :trans + (behavior () + (dummy-23 self) + (rider-trans) + (none) + ) + :code + (behavior () + (send-event *camera* 'change-state cam-mistycannon 0) + (suspend) + (set! (-> self state-time) (-> *display* base-frame-counter)) + (let ((gp-0 0) + (s5-0 0) + ) + (while #t + (when *camera-read-analog* + (let ((f30-0 (analog-input (the-as int (-> *cpad-list* cpads 0 leftx)) 128.0 48.0 110.0 -1.0)) + (f28-0 (analog-input (the-as int (-> *cpad-list* cpads 0 lefty)) 128.0 48.0 110.0 -1.0)) + ) + (rotate! self f30-0) + (tilt! self (- f28-0)) + (if (or (!= f30-0 0.0) (!= f28-0 0.0)) + (sound-play-by-name (static-sound-name "telescope") (-> self aim-sound-id) 1024 0 0 1 #t) + (sound-stop (-> self aim-sound-id)) + ) + ) + ) + (when (cpad-pressed? 0 triangle) + (process-entity-status! self (entity-perm-status bit-3) #t) + (sound-stop (-> self sound-id)) + (send-event *camera* 'change-to-entity-by-name "camera-111") + (suspend) + (while #t + (let ((a1-8 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-8 from) self) + (set! (-> a1-8 num-params) 0) + (set! (-> a1-8 message) 'end-mode) + (when (send-event-function *target* a1-8) + (send-event *camera* 'change-state *camera-base-mode* 0) + (process-entity-status! self (entity-perm-status bit-3) #f) + (go mistycannon-waiting-for-player-to-fuck-off) + ) + ) + (suspend) + ) + ) + (let ((v1-45 (and (cpad-hold? 0 x) (>= (- (-> *display* base-frame-counter) (-> self state-time)) 300)))) + (when (zero? s5-0) + (when v1-45 + (set! gp-0 (seekl gp-0 300 (- (-> *display* base-frame-counter) (-> *display* old-base-frame-counter)))) + (sound-play-by-name + (static-sound-name "cannon-charge") + (-> self sound-id) + 1024 + (the int (* 1524.0 (* 0.008 (the float gp-0)))) + 0 + 1 + #t + ) + ) + (when (or (= gp-0 300) + (and (zero? (logand (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons x))) (nonzero? gp-0)) + ) + (let ((gp-1 (+ 50 (the int (* 0.16666667 (the float gp-0)))))) + (level-hint-spawn (game-text-id daxter-get-some) "sksp009f" (the-as entity #f) *entity-pool* (game-task none)) + (dummy-22 self (* 4096.0 (the float gp-1)) 2.0 40960.0) + ) + (set! (-> self state-time) (-> *display* base-frame-counter)) + (set! gp-0 0) + (set! s5-0 1) + (sound-stop (-> self sound-id)) + ) + (if (nonzero? gp-0) + (debug-percent-bar + #t + (bucket-id debug-draw0) + 192 + 160 + (* 0.0033333334 (the float gp-0)) + (new 'static 'rgba :r #xff :a #x80) + ) + ) + ) + ) + (if (zero? (logand (-> *cpad-list* cpads 0 button0-abs 0) (pad-buttons x))) + (set! s5-0 0) + ) + (suspend) + ) + ) + (none) + ) + :post + (the-as (function none :behavior mistycannon) rider-post) + ) + +;; failed to figure out what this is: +(defstate mistycannon-waiting-for-player-to-fuck-off (mistycannon) + :event + (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (let ((v1-0 arg2)) + (the-as object (when (= v1-0 'touch) + (when ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self root-override) + (the-as uint 1) + ) + (let ((v0-0 (-> *display* base-frame-counter))) + (set! (-> self state-time) v0-0) + v0-0 + ) + ) + ) + ) + ) + ) + :enter + (behavior () + (set! (-> self state-time) (-> *display* base-frame-counter)) + (none) + ) + :trans + (the-as (function none :behavior mistycannon) rider-trans) + :code + (behavior () + (while #t + (suspend) + (dummy-23 self) + (if (>= (- (-> *display* base-frame-counter) (-> self state-time)) 300) + (go mistycannon-waiting-for-player) + ) + ) + (none) + ) + :post + (the-as (function none :behavior mistycannon) rider-post) + ) + +;; definition for method 11 of type mistycannon +;; INFO: Return type mismatch object vs none. +;; Used lq/sq +(defmethod init-from-entity! mistycannon ((obj mistycannon) (arg0 entity-actor)) + (local-vars (sv-16 res-tag) (sv-32 res-tag) (sv-48 res-tag)) + (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask))) + (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) default-collision-reaction) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-shape-intersect vector vector none) nothing) + ) + (alloc-riders s4-0 1) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 2) 0))) + (set! (-> s3-0 prim-core collide-as) (collide-kind ground-object)) + (set! (-> s3-0 collide-with) (collide-kind target)) + (set! (-> s3-0 prim-core action) (collide-action solid ca-1)) + (set! (-> s3-0 transform-index) 3) + (set-vector! (-> s3-0 local-sphere) 0.0 20480.0 0.0 40960.0) + (set-root-prim! s4-0 s3-0) + (let ((s2-0 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> s2-0 prim-core collide-as) (collide-kind ground-object)) + (set! (-> s2-0 collide-with) (collide-kind target)) + (set! (-> s2-0 prim-core action) (collide-action solid ca-1)) + (set! (-> s2-0 prim-core offense) (collide-offense indestructible)) + (set! (-> s2-0 transform-index) 3) + (set-vector! (-> s2-0 local-sphere) 0.0 20480.0 0.0 40960.0) + (append-prim s3-0 s2-0) + ) + (let ((s2-1 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 1)))) + (set! (-> s2-1 prim-core collide-as) (collide-kind enemy)) + (set! (-> s2-1 collide-with) (collide-kind target)) + (set! (-> s2-1 prim-core offense) (collide-offense indestructible)) + (set! (-> s2-1 transform-index) 3) + (set-vector! (-> s2-1 local-sphere) 0.0 28672.0 -8192.0 4096.0) + (append-prim s3-0 s2-1) + ) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (backup-collide-with-as s4-0) + (set! (-> obj root-override) s4-0) + ) + (process-drawable-from-entity! obj arg0) + (quaternion-identity! (-> obj root-override quat)) + (initialize-skeleton obj *mistycannon-sg* '()) + (logior! (-> obj skel status) 1) + (update-transforms! (-> obj root-override)) + (set! (-> obj skel prebind-function) + (the-as (function pointer int process-drawable none) mistycannon-prebind-function) + ) + (set! (-> obj skel postbind-function) mistycannon-postbind-function) + (set! (-> obj fact-info-override) + (new 'process 'fact-info-enemy obj (pickup-type eco-pill-random) (-> *FACT-bank* default-pill-inc)) + ) + (logclear! (-> obj mask) (process-mask actor-pause)) + (let ((f30-0 (res-lump-float arg0 'rotmin :default 16384.0)) + (f28-0 (res-lump-float arg0 'rotmax :default 32768.0)) + (f0-15 (res-lump-float arg0 'rotspeed :default 3640.889)) + ) + (angle-tracker-init-range! (-> obj rotate) f30-0 f28-0 f0-15) + ) + (let ((f30-1 (res-lump-float arg0 'tiltmin :default -1820.4445)) + (f28-1 (res-lump-float arg0 'tiltmax :default 12743.111)) + (f0-16 (res-lump-float arg0 'tiltspeed :default 3640.889)) + ) + (angle-tracker-init-range! (-> obj tilt) f30-1 f28-1 f0-16) + ) + (set! (-> obj avoid-entity) (entity-actor-lookup (-> obj entity) 'alt-actor 0)) + (set! (-> obj center-point w) (res-lump-float arg0 'center-radius)) + (cond + ((= (-> obj center-point w) 0.0) + (set! (-> obj center-point quad) (-> obj root-override trans quad)) + (set! (-> obj center-point w) (-> obj fact-info-override idle-distance)) + ) + (else + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-64 (res-lump-data arg0 'center-point pointer :tag-ptr (& sv-16)))) + (set! (-> obj center-point x) (if (and v1-64 (< 0.0 (the float (-> sv-16 elt-count)))) + (-> (the-as (pointer float) v1-64)) + 0.0 + ) + ) + ) + (set! sv-32 (new 'static 'res-tag)) + (let ((v1-67 (res-lump-data arg0 'center-point (pointer float) :tag-ptr (& sv-32)))) + (set! (-> obj center-point y) (if (and v1-67 (< 1.0 (the float (-> sv-32 elt-count)))) + (-> v1-67 1) + 0.0 + ) + ) + ) + (set! sv-48 (new 'static 'res-tag)) + (let ((v1-70 (res-lump-data arg0 'center-point (pointer float) :tag-ptr (& sv-48)))) + (set! (-> obj center-point z) (if (and v1-70 (< 2.0 (the float (-> sv-48 elt-count)))) + (-> v1-70 2) + 0.0 + ) + ) + ) + ) + ) + (set! (-> obj accuracy-range) 16384.0) + (mistycannon-pick-random-target-point) + (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 119) obj)) + (set! (-> obj part-timer) (the-as uint (+ (-> *display* base-frame-counter) -3000))) + (set! (-> obj postbindinfo-ok) #f) + (let ((v1-79 (-> obj rotate))) + (set! (-> obj last-known-rotation) + (the float (sar (shl (the int (+ (-> v1-79 min) (-> v1-79 value))) 48) 48)) + ) + ) + (set! (-> obj sound-id) (new-sound-id)) + (set! (-> obj aim-sound-id) (new-sound-id)) + (if (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status complete))) + (go mistycannon-idle) + (go mistycannon-waiting-for-player) + ) + (none) + ) + + + + diff --git a/test/decompiler/reference/levels/ogre/ogreboss_REF.gc b/test/decompiler/reference/levels/ogre/ogreboss_REF.gc index a8cf467ea7..fcbbfe4776 100644 --- a/test/decompiler/reference/levels/ogre/ogreboss_REF.gc +++ b/test/decompiler/reference/levels/ogre/ogreboss_REF.gc @@ -100,15 +100,15 @@ ;; definition of type ogreboss-missile (deftype ogreboss-missile (process-drawable) - ((parent-override (pointer ogreboss) :offset 12) - (root-override collide-shape-moving :offset 112) - (trajectory trajectory :inline :offset-assert 176) - (src-pos vector :inline :offset-assert 224) - (dest-pos vector :inline :offset-assert 240) - (start-time int64 :offset-assert 256) - (tumble-quat quaternion :inline :offset-assert 272) - (blast-radius float :offset-assert 288) - (pickup-type pickup-type :offset-assert 292) + ((parent-override (pointer process-drawable) :offset 12) + (root-override collide-shape-moving :offset 112) + (trajectory trajectory :inline :offset-assert 176) + (src-pos vector :inline :offset-assert 224) + (dest-pos vector :inline :offset-assert 240) + (start-time int64 :offset-assert 256) + (tumble-quat quaternion :inline :offset-assert 272) + (blast-radius float :offset-assert 288) + (pickup-type pickup-type :offset-assert 292) ) :heap-base #xc0 :method-count-assert 20 @@ -467,7 +467,7 @@ (set! (-> self root-override trans quad) (-> arg0 src quad)) (set! (-> self src-pos quad) (-> arg0 src quad)) (set! (-> self dest-pos quad) (-> arg0 dest quad)) - (set! (-> self root-override quat vec quad) (-> self parent-override 0 root-override quat vec quad)) + (set! (-> self root-override quat vec quad) (-> self parent-override 0 root quat vec quad)) (vector-identity! (-> self root-override scale)) (initialize-skeleton self *ogreboss-shoot-boulder-sg* '()) (set! (-> self mask) (logior (process-mask enemy projectile) (-> self mask))) @@ -515,19 +515,19 @@ ;; definition of type ogreboss-super-boulder (deftype ogreboss-super-boulder (process-drawable) - ((parent-override (pointer ogreboss) :offset 12) - (root-override collide-shape-moving :offset 112) - (orig-pos vector :inline :offset-assert 176) - (src-pos vector :inline :offset-assert 192) - (spin-axis vector :inline :offset-assert 208) - (joint joint-mod-blend-local :offset-assert 224) - (speed float :offset-assert 228) - (size float :offset-assert 232) - (grow-rate float :offset-assert 236) - (lava entity-actor :offset-assert 240) - (sound-id sound-id :offset-assert 244) - (hit-boss symbol :offset-assert 248) - (tumble-quat quaternion :inline :offset-assert 256) + ((parent-override (pointer process-drawable) :offset 12) + (root-override collide-shape-moving :offset 112) + (orig-pos vector :inline :offset-assert 176) + (src-pos vector :inline :offset-assert 192) + (spin-axis vector :inline :offset-assert 208) + (joint joint-mod-blend-local :offset-assert 224) + (speed float :offset-assert 228) + (size float :offset-assert 232) + (grow-rate float :offset-assert 236) + (lava entity-actor :offset-assert 240) + (sound-id sound-id :offset-assert 244) + (hit-boss symbol :offset-assert 248) + (tumble-quat quaternion :inline :offset-assert 256) ) :heap-base #xa0 :method-count-assert 20 @@ -1034,8 +1034,8 @@ (set! (-> self root-override) s4-0) ) (set! (-> self orig-pos quad) (-> arg0 quad)) - (set! (-> self root-override trans quad) (-> self parent-override 0 root-override trans quad)) - (set! (-> self root-override quat vec quad) (-> self parent-override 0 root-override quat vec quad)) + (set! (-> self root-override trans quad) (-> self parent-override 0 root trans quad)) + (set! (-> self root-override quat vec quad) (-> self parent-override 0 root quat vec quad)) (vector-identity! (-> self root-override scale)) (initialize-skeleton self *ogreboss-super-boulder-sg* '()) (logclear! (-> self mask) (process-mask actor-pause)) diff --git a/test/offline/config.jsonc b/test/offline/config.jsonc index 6aafe3560e..b6d09514a8 100644 --- a/test/offline/config.jsonc +++ b/test/offline/config.jsonc @@ -183,6 +183,23 @@ "display-loop", "on", + // target-handler + "target-generic-event-handler", // return type forced to none + + // shadow-cpu-h + "(method 3 shadow-edge)", // defined twice in the same file, one is wrong and old + + // sky - these are skipped and not used + "sky-draw", + "sky-upload", + "sky-add-frame-data", + + // drawable + "vis-cull", // unsupported asm + "draw-instance-info", // skipped for now, debug only + "foreground-engine-execute", + "real-main-draw-hook", // dma handling not complete + // generic-obs "command-get-process", // handle casts