diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ba727f6..d8f9743 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,6 +25,20 @@ jobs:
           ghc-version: '9.10.3'
           cabal-version: 'latest'
 
+      - name: Configure Cabal repository
+        run: |
+          mkdir -p ~/.cabal
+          cat > ~/.cabal/repositories.cfg << 'EOF'
+          repository hackage.haskell.org
+            url: https://hackage.haskell.org/
+            secure: True
+            root-keys: 07c59cb65787031cbb810701bd8ff5515f9ebe3e758d3b589d4a3a337f91dc08
+                       2e8555dde16ebd8df076f1a396506f99fcfa541ee7a37b104d33177db735604c
+                       8b9f40ae9b992d206ceabf2f4786226ae94036defc92874bd34ce6f1565d37b9
+            key-threshold: 3
+          EOF
+          cabal update
+
       - name: Update Cabal cache
         run: cabal update
 
@@ -52,4 +66,4 @@ jobs:
          make linker-test
       
       - name: LOC Report
-        run: python3 scripts/loc.py
\ No newline at end of file
+        run: python3 scripts/loc.py
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c895b8..8999db0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/) - while
 the project is in `0.x`, breaking changes may land in MINOR releases; PATCH
 releases are reserved for bug fixes only.
 
+## [1.7.1] 2026-07-24
+
+### Fixed:
+
+- **Fixed CG-11:** *Oversized structs permitted causing wrapping on 8-bit indexing* Structs are now hard capped at max size of 255 bytes
+- **Fixed FE-20:** *Nested field assignments not sticking* Added recursive load and store instructions for each nested field
+- **Fixed FE-19:** *increment / decrement of pointers, registers and struct values not modifying* Fixed issue by matching on operand type in `lowerExpr`.
+- **Addresed FE-22:** *compiler externs not injected* You must include the standard libarary header,
+  `stddef.c02h` to access these forward decls.
+- **Fixed FE-2:** *Root file self include:* Can no longer include yourself causing redefinition errors
+  instead it produces a better error message `cannot include yourself '<FILE>'.`
+- **Fixed CG-1, CG-2:** *Struct by value errors:* Added code to the analyzer to forbid passing or
+  returning struct types by value. This both keeps memory cleaner without copying structs around
+  and eliminates these two silent miscompiles.
+- **Fixed CG-8:** *binary footer overwritten error:* Added guards for `code`, `data`, and `symbol table`
+  sections overwriting the binary footer which contains the vector table and would produce a broken
+  binary if overwritten.
+- **Fixed CG-9:** *Added guards for exhausted ram on global emit:* Added guards for exhausting ram
+  space with global variables and compiler extern variables.
+- **Fixed FE-14, CG-6:** *interrupt handling:* Added warning for wrongly defining an interrupt that
+  does not match the golden format, the warning drops the interrupt qualifier and continues. Also
+  added error for explicitly calling interrupt functions, because interrupt functions us `RTI` and
+  not `RTS` instructions so directly calling them would corrupt the stack.
+
+
 ## [1.7.0] 2026-07-17
 
 - Added char literal to parser, 'a' now gets translated to its ascii value in that case, 97. 
diff --git a/c02-as/src/generator.c b/c02-as/src/generator.c
index 6a1b8c4..2377045 100644
--- a/c02-as/src/generator.c
+++ b/c02-as/src/generator.c
@@ -8,15 +8,29 @@
 // Memory map
 // ----------------------------------------------------------------
 
-#define RAM_START   0x0200 // 6502 hardware stack occupies 0x0100 - 0x01FF
-#define RAM_TOP     0x3FFF // see docs/memmap.md
-#define ROM_START   0x8000
-#define ROM_SIZE    0x8000
+#define RAM_START              0x0200 // 6502 hardware stack occupies 0x0100 - 0x01FF
+#define RAM_TOP                0x3FFF // see docs/memmap.md
+#define ROM_START              0x8000
+#define ROM_SIZE               0x8000
+
+// ROM footer layout (offsets from ROM_START):
+//   $FFF6-$FFF7  SYMTABLE_START_PTR:   little-endian absolute address of the "C02S" symbol
+//                table header, or $EAEA (NOP fill) if no table was written. The disassembler
+//                reads this first; old binaries that lack a table have $EAEA here, which is
+//                in range but fails the magic-byte check, so they degrade gracefully.
+//   $FFF8-$FFF9  SYMTABLE_BOUNDARY_PTR: little-endian absolute address of the first byte
+//                past the code+data region (= start of NOP fill). Used by the disassembler
+//                to know where executable/data bytes end and padding begins.
+//   $FFFA-$FFFF  NMI / Reset / IRQ vectors (written by emit_vectors).
+#define SYMTABLE_START_PTR     (0xFFF6 - ROM_START)
+#define SYMTABLE_BOUNDARY_PTR  (0xFFF8 - ROM_START)
+#define ROM_VECTOR_TABLE_START (0xFFFA - ROM_START)
 
-#define FP          0x00
-#define RET         0x02
-#define REG_START   0x04
-#define PARAM_START 0xEF
+
+#define FP                     0x00
+#define RET                    0x02
+#define REG_START              0x04
+#define PARAM_START            0xEF
 
 // ABI zone: fixed 2-byte slots per parameter ($EF/$F0, $F1/$F2, ..., $FD/$FE).
 // Using fixed 2-byte slots simplifies caller/callee agreement at the cost of 1 byte
@@ -298,6 +312,11 @@ static void allocate_globals(emitter_t *e, ir_gen_t *gen) {
     entry->size = (uint8_t)size;
     entry->type = g->type;
     e->ram_pos += (uint16_t)size;
+
+    if (e->ram_pos > RAM_TOP) {
+      e->overflow = 1;
+      return;
+    }
   }
 }
 
@@ -306,16 +325,16 @@ static void allocate_globals(emitter_t *e, ir_gen_t *gen) {
 // Op code emitters
 // ----------------------------------------------------------------
 
-#define EMIT(OP_CODE) do {                              \
-  if (e->code_pos >= ROM_SIZE) { e->overflow = 1; }     \
-  else { e->rom[e->code_pos++] = (uint8_t)(OP_CODE); }  \
+#define EMIT(OP_CODE) do {                                      \
+  if (e->code_pos >= SYMTABLE_START_PTR) { e->overflow = 1; }   \
+  else { e->rom[e->code_pos++] = (uint8_t)(OP_CODE); }          \
 } while (0)
 
 // Write one byte to an already-emitted position (branch offset backpatch).
-// Guards against positions recorded after an overflow (which would be >= ROM_SIZE).
-#define PATCH_BYTE(POS, VAL) do {                       \
-  if ((POS) < ROM_SIZE) e->rom[(POS)] = (uint8_t)(VAL); \
-  else e->overflow = 1;                                 \
+// Guards against positions recorded after an overflow (which would be >= SYMTABLE_START_PTR).
+#define PATCH_BYTE(POS, VAL) do {                                 \
+  if ((POS) < SYMTABLE_START_PTR) e->rom[(POS)] = (uint8_t)(VAL); \
+  else e->overflow = 1;                                           \
 } while (0)
 
 #define OP_EMITTER_SINGLE_ARG(NAME, OP_CODE)            \
@@ -529,7 +548,7 @@ static void emit_data_section(emitter_t *e, ir_gen_t *gen) {
 
 // Write NMI, Reset, and IRQ vectors at $FFFA-$FFFF.
 static void emit_vectors(emitter_t *e) {
-  unsigned pos = 0xFFFA - ROM_START;
+  unsigned pos = ROM_VECTOR_TABLE_START;
 
   // Only functions actually declared `interrupt` get wired into the vector table —
   // a plain function that happens to be named "nmi"/"irq" was emitted with a normal
@@ -553,11 +572,11 @@ static void emit_vectors(emitter_t *e) {
   }
 
   e->rom[pos++] = (uint8_t)(nmi_addr & 0xFF);     // NMI low
-  e->rom[pos++] = (uint8_t)(nmi_addr >> 8);        // NMI high
-  e->rom[pos++] = ROM_START & 0xFF;   // Reset low
-  e->rom[pos++] = ROM_START >> 8;     // Reset high
+  e->rom[pos++] = (uint8_t)(nmi_addr >> 8);       // NMI high
+  e->rom[pos++] = ROM_START & 0xFF;               // Reset low
+  e->rom[pos++] = ROM_START >> 8;                 // Reset high
   e->rom[pos++] = (uint8_t)(irq_addr & 0xFF);     // IRQ low
-  e->rom[pos++] = (uint8_t)(irq_addr >> 8);        // IRQ high
+  e->rom[pos++] = (uint8_t)(irq_addr >> 8);       // IRQ high
 }
 
 
@@ -1759,18 +1778,6 @@ static void emit_sdiv16_helper(emitter_t *e) {
 }
 
 
-// ROM footer layout (offsets from ROM_START):
-//   $FFF6-$FFF7  SYMTABLE_START_PTR:   little-endian absolute address of the "C02S" symbol
-//                table header, or $EAEA (NOP fill) if no table was written. The disassembler
-//                reads this first; old binaries that lack a table have $EAEA here, which is
-//                in range but fails the magic-byte check, so they degrade gracefully.
-//   $FFF8-$FFF9  SYMTABLE_BOUNDARY_PTR: little-endian absolute address of the first byte
-//                past the code+data region (= start of NOP fill). Used by the disassembler
-//                to know where executable/data bytes end and padding begins.
-//   $FFFA-$FFFF  NMI / Reset / IRQ vectors (written by emit_vectors).
-#define SYMTABLE_START_PTR    (0xFFF6 - ROM_START)
-#define SYMTABLE_BOUNDARY_PTR (0xFFF8 - ROM_START)
-
 // Write the "C02S" symbol table into the NOP fill area immediately after the data section,
 // then store its absolute address at SYMTABLE_START_PTR so the disassembler can find it.
 // Each entry is: u16 address (LE) + null-terminated name. Covers three symbol kinds —
@@ -1792,8 +1799,10 @@ static void emit_symbol_table(emitter_t *e) {
   for (unsigned i = 0; i < reg_count; i++)
     sym_size += 2 + strlen(e->gen->module.regs[i].name) + 1;
 
-  if (e->code_pos + sym_size > SYMTABLE_START_PTR)
+  if (e->code_pos + sym_size > SYMTABLE_START_PTR) {
+    e->overflow = 1;
     return;
+  }
 
   uint16_t symtab_addr = (uint16_t)(ROM_START + e->code_pos);
 
@@ -1826,8 +1835,9 @@ static void emit_symbol_table(emitter_t *e) {
     EMIT(0);
   }
 
-  PATCH_BYTE(SYMTABLE_START_PTR,     symtab_addr & 0xFF);
-  PATCH_BYTE(SYMTABLE_START_PTR + 1, symtab_addr >> 8);
+  // patch in symbol table ptr, can't use PATCH_BYTE because it checks if the pos < SYMTABLE_START_PTR wich will always fail in this case
+  e->rom[SYMTABLE_START_PTR]       = (uint8_t)(symtab_addr & 0xFF);
+  e->rom[(SYMTABLE_START_PTR + 1)] = (uint8_t)(symtab_addr >> 8);
 }
 
 
@@ -1871,14 +1881,18 @@ static int emit_compiler_extern_inits(emitter_t *e, ir_gen_t *gen) {
     ir_extern_t *ext = &gen->module.externs[i];
     if (ext->is_function) continue;
 
-    if (strcmp(ext->name, "__heap_start") == 0)
-      ALLOC_COMPILER_SLOT(ext);
-    else if (strcmp(ext->name, "__memory_top") == 0)
+    if (strcmp(ext->name, "__heap_start") == 0 || strcmp(ext->name, "__memory_top") == 0)
       ALLOC_COMPILER_SLOT(ext);
     else {
       fprintf(stderr, "codegen: unresolved extern '%s'\n", ext->name);
       return 0;
     }
+
+    if (e->ram_pos > RAM_TOP) {
+      e->overflow = 1;
+    }
+
+    return 1;
   }
 
   // Pass 2: emit initialisers (e->ram_pos is now fully settled).
@@ -1902,6 +1916,16 @@ static void emitter_free(emitter_t *e) {
 }
 
 
+#define OVERFLOW_ERROR_CHECK(msg) \
+  if (e.overflow) {               \
+    fprintf(stderr, msg);         \
+    free(e.rom);                  \
+    emitter_free(&e);             \
+    *final_rom_size = 0;          \
+    return NULL;                  \
+  }
+
+
 uint8_t *generate_rom(ir_gen_t *gen, size_t *final_rom_size, int emit_symbols) {
   emitter_t e = { 0 };
 
@@ -1918,6 +1942,8 @@ uint8_t *generate_rom(ir_gen_t *gen, size_t *final_rom_size, int emit_symbols) {
   e.zp_next = REG_START;
 
   allocate_globals(&e, gen);
+  OVERFLOW_ERROR_CHECK("Global variables overflowed RAM.\n")
+
   emit_bootstrap(&e);
   emit_global_init(&e, gen);
 
@@ -1927,6 +1953,9 @@ uint8_t *generate_rom(ir_gen_t *gen, size_t *final_rom_size, int emit_symbols) {
     *final_rom_size = 0;
     return NULL;
   }
+
+  // compiler externs are just globals and can also overflow ram
+  OVERFLOW_ERROR_CHECK("Global variables overflowed RAM.\n")
   
   if (!emit_call_main(&e)) {
     free(e.rom);
@@ -1960,15 +1989,6 @@ uint8_t *generate_rom(ir_gen_t *gen, size_t *final_rom_size, int emit_symbols) {
     return NULL;
   }
 
-  #define OVERFLOW_ERROR_CHECK(msg) \
-    if (e.overflow) {               \
-      fprintf(stderr, msg);         \
-      free(e.rom);                  \
-      emitter_free(&e);             \
-      *final_rom_size = 0;          \
-      return NULL;                  \
-    }
-
   OVERFLOW_ERROR_CHECK("Code section generation failed: output exceeds 32 KB ROM.\n");
 
   emit_data_section(&e, gen);
diff --git a/c02-frontend/app/Main.hs b/c02-frontend/app/Main.hs
index 1fbabc5..066bc03 100644
--- a/c02-frontend/app/Main.hs
+++ b/c02-frontend/app/Main.hs
@@ -31,7 +31,7 @@ import Text.Megaparsec
 import C02.Parser.Parser (parseProgram)
 import C02.Analyzer.Includes (resolveIncludes)
 import C02.Analyzer.Analyze (analyze)
-import C02.Analyzer.Diagnostic (Diag(..), Diagnostic, render)
+import C02.Analyzer.Diagnostic (Diag(..), Diagnostic, Severity(..), render, severityOf, diagWhat)
 import C02.Lowering.Module (lowerModule)
 import C02.Parser.AST (Program, Pos(..))
 import C02.Lowering.Serialize (serializeModule)
@@ -69,12 +69,19 @@ main = do
               resolved <- resolveIncludes path includeDirs prog
               case resolved of
                 Left err                    -> hPutStr stderr (errorBundlePretty err) >> exitFailure
-                Right (resolvedProg, srcs)  -> case analyze resolvedProg of
-                  []    -> if dumpAST then print resolvedProg else writeOutput resolvedProg outPath
+                Right (resolvedProg, srcs)  ->
                   -- The root file's source isn't in @srcs@ (the resolver only
                   -- records files it read); add it so the renderer can show root
                   -- diagnostics too.
-                  diags -> hPutStr stderr (renderDiags path (Map.insert path src srcs) diags) >> exitFailure
+                  let diags  = analyze resolvedProg
+                      hasErr = any ((== Error) . severityOf . diagWhat) diags
+                  in do
+                    if null diags
+                      then pure ()
+                      else hPutStr stderr (renderDiags path (Map.insert path src srcs) diags)
+                    if hasErr
+                      then exitFailure
+                      else if dumpAST then print resolvedProg else writeOutput resolvedProg outPath
     _ -> hPutStrLn stderr "usage: c02-frontend [--parse-only] [-I <dir>]... [-o <out.o>] <file.c02>" >> exitFailure
 
 
@@ -114,10 +121,17 @@ extractIncludeDirs = go [] []
 -- file, then a summary count closes the report.
 renderDiags :: FilePath -> Map FilePath String -> [Diag] -> String
 renderDiags rootPath srcs diags =
-  concatMap fileBundle (Map.toList byFile) ++ freeStr
-    ++ "\nSemantic analysis failed with " ++ show n ++ " errors.\n"
+  concatMap fileBundle (Map.toList byFile) ++ freeStr ++ summary
   where
-    n      = length diags
+    nErrors   = length [ () | d <- diags, severityOf (diagWhat d) == Error ]
+    nWarnings = length diags - nErrors
+    summary
+      -- Preserve the original wording exactly when there are no warnings
+      -- (every existing golden pins this string, always-plural "errors").
+      | nErrors > 0 && nWarnings == 0 = "\nSemantic analysis failed with " ++ show nErrors ++ " errors.\n"
+      | nErrors > 0                   = "\nSemantic analysis failed with " ++ show nErrors
+                                         ++ " errors and " ++ show nWarnings ++ " warnings.\n"
+      | otherwise                     = "\n" ++ show nWarnings ++ " warnings.\n"
     frees  = [ d | Free d <- diags ]
     -- group located diags by file; Map.toList then yields files in a stable
     -- (path-sorted) order, and each group is non-empty by construction.
diff --git a/c02-frontend/c02-frontend.cabal b/c02-frontend/c02-frontend.cabal
index 1b2da92..12fad88 100644
--- a/c02-frontend/c02-frontend.cabal
+++ b/c02-frontend/c02-frontend.cabal
@@ -72,6 +72,7 @@ library
                       C02.Lowering.Module
                       C02.Lowering.Serialize
     build-depends:    base ^>=4.20.2.0,
+                      directory,
                       megaparsec,
                       parser-combinators,
                       containers,
@@ -89,6 +90,7 @@ executable c02-frontend
 
     -- Other library packages from which modules are imported.
     build-depends:    base ^>=4.20.2.0,
+                      directory,
                       megaparsec,
                       containers,
                       bytestring,
diff --git a/c02-frontend/src/C02/Analyzer/Analyze.hs b/c02-frontend/src/C02/Analyzer/Analyze.hs
index 8c267eb..5422bfa 100644
--- a/c02-frontend/src/C02/Analyzer/Analyze.hs
+++ b/c02-frontend/src/C02/Analyzer/Analyze.hs
@@ -27,6 +27,7 @@
 --     offset-blind 'inferType' ever having to know about it.
 module C02.Analyzer.Analyze
   ( analyze
+  , checkDeclType
   , bindLocal
   ) where
 
@@ -65,7 +66,6 @@ data Ctx = Ctx
 
 type Analyze = ReaderT Ctx (Writer [Diag])
 
-
 -- | Run both passes over a program and return every diagnostic. Ordering within
 -- the list is by pass (pass-1 redeclarations, then top-level validation, then
 -- missing-main, then pass 2); the renderer sorts the located ones by offset.
@@ -239,7 +239,7 @@ buildGlobals = go Map.empty Map.empty Set.empty []
     classify (StructDef s)     = (structName s, Nothing, Just (structFields s))
 
     funcSym f = FuncSym (funcReturnType f, funcReturnPtrDepth f)
-                        [ (bt, depth) | (bt, depth, _) <- params f ]
+                        [ (bt, depth) | (bt, depth, _) <- params f ] (validInterrupt f)
 
 
 -- | After pass 1, validate the types written in top-level declarations (now that
@@ -258,18 +258,26 @@ validateTopLevel = mapM_ (\(Loc off d) -> withOffset off (one d))
     one (RegisterDecl r) = void $ checkDeclType (regName r) (regType r, regPtrDepth r)
     one (StructDef s)    = forM_ (structFields s) $ \(bt, d, nm) ->
                              void $ checkDeclType nm (bt, d)
-    one (FunctionDecl f) = validateReturn f
+    one (FunctionDecl f) = validateReturn f *> validateParams f
     one (FwdFuncDecl f)  = do
       validateReturn f
+      validateParams f
       forM_ (params f) $ \(bt, d, nm) -> void $ checkDeclType nm (bt, d)
 
     -- A function return type may legitimately be void; only an unknown struct is
     -- an error here (parameters are validated when the body is walked).
-    validateReturn f = case funcReturnType f of
+    validateReturn f@(FuncDecl _ _ d _ _ _) = case funcReturnType f of
       StructName sn -> do
-        known <- asks (Map.member sn . ctxStructs)
-        unless known (emit (UnknownStruct sn))
+        case d >= 1 of   -- returning structs by value is prohibited
+          True -> do
+            known <- asks (Map.member sn . ctxStructs)
+            unless known (emit (UnknownStruct sn))
+          False -> emit (ReturnStructByValue sn)
       _ -> pure ()
+    
+    validateParams f = forM_ (params f) $ \(bt, d, _) -> void $ case bt of
+      StructName n -> if d < 1 then emit (StructPassByValue n) else pure ()
+      _            -> pure ()
 
 
 checkMain :: [Loc TopLevelDecl] -> Analyze ()
@@ -305,7 +313,8 @@ analyzeFuncs = mapM_ go
 -- After the body, a non-void function whose last statement can't be seen to
 -- return is flagged (§7.5, shallow) at the function's offset.
 analyzeFunc :: FuncDecl -> Analyze ()
-analyzeFunc f =
+analyzeFunc f = do
+  when (isInterrupt f && not (validInterrupt f)) (emit (InvalidInterrupt (funcName f)))
   local (\c -> (pushScope c) { ctxReturn = (funcReturnType f, funcReturnPtrDepth f) }) $
     bindParams (params f) $ do
       analyzeBlock stmts
@@ -313,6 +322,7 @@ analyzeFunc f =
   where
     stmts = funcBodyStmts f
 
+
 -- | Declare each parameter in turn, threading them into the body walk.
 bindParams :: [NamedType] -> Analyze a -> Analyze a
 bindParams []       k = k
@@ -329,8 +339,8 @@ funcBodyStmts f = case body f of
 -- declaration into the tail via the "scope is 'local'" idiom.
 analyzeBlock :: [Loc Stmt] -> Analyze ()
 analyzeBlock []                                   = pure ()
-analyzeBlock (Loc off (LocVarDecl vd) : rest)      = declLocal off vd (analyzeBlock rest)
-analyzeBlock (Loc off (StructDeclStmt sd) : rest)  = declLocalStruct off sd (analyzeBlock rest)
+analyzeBlock (Loc off (LocVarDecl vd) : rest)     = declLocal off vd (analyzeBlock rest)
+analyzeBlock (Loc off (StructDeclStmt sd) : rest) = declLocalStruct off sd (analyzeBlock rest)
 analyzeBlock (Loc off s : rest)                   = withOffset off (analyzeStmt s) >> analyzeBlock rest
 
 -- | Declare a statement-position struct (§4.4/§5): validate its field types
diff --git a/c02-frontend/src/C02/Analyzer/Diagnostic.hs b/c02-frontend/src/C02/Analyzer/Diagnostic.hs
index 731beb1..ad3b58b 100644
--- a/c02-frontend/src/C02/Analyzer/Diagnostic.hs
+++ b/c02-frontend/src/C02/Analyzer/Diagnostic.hs
@@ -5,7 +5,10 @@
 module C02.Analyzer.Diagnostic
   ( Diagnostic(..)
   , Diag(..)
+  , Severity(..)
   , render
+  , severityOf
+  , diagWhat
   ) where
 
 import C02.Parser.AST (BaseType(..), Pos(..))
@@ -18,9 +21,14 @@ type TyPair = (BaseType, Int)
 data Diagnostic
   = LiteralOutOfRange Int      -- ^ ERR_LITERAL_OUT_OF_RANGE (§3.4): literal outside -32768..65535
   | StructCastByValue String   -- ^ ERR_STRUCT_CAST_BY_VALUE: @(Struct)expr@ with no pointer level
+  | StructPassByValue String   -- ^ ERR_STRUCT_PASS_BY_VALUE: Passing struct by value is prohibited
+  | ReturnStructByValue String -- ^ ERR_STRUCT_RETURN_BY_VALUE: Returning struct by value is prohibited
   | UnknownStruct String       -- ^ ERR_UNKNOWN_STRUCT: struct-typed name not registered
+  | OversizedStruct String Int -- ^ ERR_OVERSIZED_STRUCT: struct size is over 255 bytes
   | UndeclaredIdentifier String-- ^ ERR_UNDECLARED_IDENTIFIER: name not in any visible scope
   | NotAFunction String        -- ^ ERR_NOT_A_FUNCTION: call target is a non-function symbol
+  | InterruptCall String       -- ^ ERR_INTERRUPT_CALL: attempting to call an interrupt function explicitly 
+  | InvalidInterrupt String    -- ^ WRN_INVALID_INTERRUPT: function tagged interrupt but does not have valid signature. dropping interrupt qualifier.
   | NotAssignable String       -- ^ ERR_NOT_ASSIGNABLE: function/struct name used as a value
   | WrongArgCount String Int Int -- ^ ERR_WRONG_ARG_COUNT: name, expected count, actual count
   | TypeMismatch TyPair TyPair String -- ^ ERR_TYPE_MISMATCH: expected, actual, context tag
@@ -48,6 +56,25 @@ data Diag
   | Free Diagnostic
   deriving (Show, Eq)
 
+-- | Pull the underlying 'Diagnostic' out of a 'Diag', discarding its position.
+diagWhat :: Diag -> Diagnostic
+diagWhat (At _ d) = d
+diagWhat (Free d) = d
+
+-- | Whether a diagnostic blocks the build. 'Warning's still print (§4.2 wants
+-- 'WARN_INVALID_INTERRUPT' on stderr on an otherwise-successful build);
+-- 'Error's are what actually gate emitting the IR object.
+data Severity = Warning | Error
+  deriving (Show, Eq)
+
+-- | One severity per diagnostic *kind*, not per call site — 'emit' stays
+-- untouched, and every existing call site keeps working exactly as it did
+-- (defaulting to 'Error') without having to be revisited.
+severityOf :: Diagnostic -> Severity
+severityOf d = case d of
+  InvalidInterrupt _ -> Warning
+  _                  -> Error
+
 
 -- | The message body for a diagnostic, matching SPEC §8 wording. Location and
 -- the leading @error:@ tag are added later by the renderer that owns spans.
@@ -55,9 +82,14 @@ render :: Diagnostic -> String
 render d = case d of
   LiteralOutOfRange _     -> "integer literal is out of range (must fit in -32768..65535)"
   StructCastByValue n     -> "cannot cast to struct '" ++ n ++ "' by value; cast to '" ++ n ++ "*' instead"
+  StructPassByValue n     -> "'" ++ n ++ "': Passing struct by value is prohibited"
+  ReturnStructByValue n   -> "'" ++ n ++ "': Returning struct by value is prohibited"
   UnknownStruct n         -> "unknown struct '" ++ n ++ "'"
+  OversizedStruct n s     -> "'" ++ n ++ "': struct size is over 255 bytes: " ++ show s ++ " bytes"
   UndeclaredIdentifier n  -> "undeclared identifier '" ++ n ++ "'"
   NotAFunction n          -> "'" ++ n ++ "' is not a function"
+  InterruptCall n         -> "'" ++ n ++ "' attempting to call an interrupt function explicitly"
+  InvalidInterrupt n      -> "'" ++ n ++ "' function tagged interrupt but does not have valid signature. dropping interrupt qualifier."
   NotAssignable n         -> "'" ++ n ++ "' is not assignable"
   WrongArgCount n e a     -> "function '" ++ n ++ "' expects " ++ show e
                              ++ " argument(s), but " ++ show a ++ " were provided"
diff --git a/c02-frontend/src/C02/Analyzer/Includes.hs b/c02-frontend/src/C02/Analyzer/Includes.hs
index 7630c51..5388716 100644
--- a/c02-frontend/src/C02/Analyzer/Includes.hs
+++ b/c02-frontend/src/C02/Analyzer/Includes.hs
@@ -25,6 +25,7 @@ import qualified Data.Map             as Map
 import qualified Data.Set             as Set
 import           Data.Void            (Void)
 import           System.FilePath      (takeDirectory, (</>))
+import System.Directory (canonicalizePath)
 import           Text.Megaparsec      (ErrorFancy (ErrorFail),
                                        ParseError (FancyError),
                                        ParseErrorBundle (..), PosState (..),
@@ -58,27 +59,38 @@ resolveIncludes
   -> Program
   -> IO (Either (ParseErrorBundle String Void) (Program, Map FilePath String))
 resolveIncludes path searchDirs prog = runExceptT $ do
-  (tops, srcs) <- runStateT (runReaderT (flatten (takeDirectory path) prog) searchDirs) Map.empty
+  (tops, srcs) <- runStateT (runReaderT (flatten path (takeDirectory path) prog) searchDirs) Map.empty
   pure (Program [] tops, srcs)
 
 -- | Fully resolve a parsed program to a flat list of top-levels: expand its
 -- include list (recursively) and prepend the results to the program's own
 -- declarations. @dir@ is the base directory for this program's relative include
 -- paths.
-flatten :: FilePath -> Program -> Resolve [Loc TopLevelDecl]
-flatten dir (Program incls tops) = do
-  included <- concat <$> mapM (resolveInclude dir) incls
+flatten :: FilePath -> FilePath -> Program -> Resolve [Loc TopLevelDecl]
+flatten self dir (Program incls tops) = do
+  included <- concat <$> mapM (resolveInclude self dir) incls
   pure (included ++ tops)
 
 -- | Resolve one @include "name"@. The candidate paths are @name@ joined onto the
 -- including file's directory first, then each @-I@ search directory in order; the
 -- first that reads successfully is the file.
-resolveInclude :: FilePath -> Loc InclStmt -> Resolve [Loc TopLevelDecl]
-resolveInclude dir incl = do
+resolveInclude :: FilePath -> FilePath -> Loc InclStmt -> Resolve [Loc TopLevelDecl]
+resolveInclude self dir incl = do
   searchDirs <- ask
   let name       = includePath (unLoc incl)
       candidates = [ d </> name | d <- dir : searchDirs ]
-  resolveCandidates name candidates
+  
+  -- Check if any resolved candidate would refer to the same file as self
+  selfCanonicalized <- liftIO (canonicalizePath self)
+  isSelfInclude <- or <$> mapM (\path -> do
+    pathCanonicalized <- liftIO (try (canonicalizePath path) :: IO (Either IOException FilePath))
+    case pathCanonicalized of
+      Left _  -> pure False
+      Right p -> pure (p == selfCanonicalized)
+    ) candidates
+  case isSelfInclude of
+    True  -> throwError (selfIncludeBundle name)
+    False -> resolveCandidates self name candidates
 
 -- | Try each candidate path in order. A path already visited short-circuits to
 -- '[]' (this gives pragma-once dedup on diamond includes and terminates cycles —
@@ -88,8 +100,8 @@ resolveInclude dir incl = do
 -- includes resolved. A candidate that fails to read is skipped so the next search
 -- directory gets a turn; if every candidate is exhausted the include is reported
 -- as not found, listing everywhere we looked.
-resolveCandidates :: String -> [FilePath] -> Resolve [Loc TopLevelDecl]
-resolveCandidates name candidates = go candidates
+resolveCandidates :: FilePath -> String -> [FilePath] -> Resolve [Loc TopLevelDecl]
+resolveCandidates self name candidates = go candidates
   where
     go [] = throwError (notFoundBundle name candidates)
     go (path : rest) = do
@@ -104,7 +116,7 @@ resolveCandidates name candidates = go candidates
               modify (Map.insert path src)   -- mark visited + retain source before recursing
               case parseProgram path src of
                 Left err   -> throwError err
-                Right prog -> flatten (takeDirectory path) prog
+                Right prog -> flatten self (takeDirectory path) prog
 
 -- | A one-error bundle reporting that an @include@ couldn't be found in any search
 -- directory, listing the paths that were tried. There is no source text to show,
@@ -124,3 +136,20 @@ notFoundBundle name candidates = ParseErrorBundle
   }
   where msg = "cannot find included file '" ++ name ++ "'; searched: "
               ++ intercalate ", " candidates
+
+-- | A one-error bundle reporting that we tried to include ourselves.
+-- There is no source text to show, so the input is empty and the error sits
+-- at offset 0: 'errorBundlePretty' renders it as @name:1:1:@ followed by
+-- the message, matching the frontend's parse-error style.
+selfIncludeBundle :: String -> ParseErrorBundle String Void
+selfIncludeBundle name = ParseErrorBundle
+  { bundleErrors   = FancyError 0 (Set.singleton (ErrorFail msg)) :| []
+  , bundlePosState = PosState
+      { pstateInput      = ""
+      , pstateOffset     = 0
+      , pstateSourcePos  = initialPos name
+      , pstateTabWidth   = defaultTabWidth
+      , pstateLinePrefix = ""
+      }
+  }
+  where msg = "cannot include yourself '" ++ name ++ "'."
\ No newline at end of file
diff --git a/c02-frontend/src/C02/Analyzer/Layout.hs b/c02-frontend/src/C02/Analyzer/Layout.hs
index 3e9845f..bd6be37 100644
--- a/c02-frontend/src/C02/Analyzer/Layout.hs
+++ b/c02-frontend/src/C02/Analyzer/Layout.hs
@@ -108,10 +108,12 @@ computeStructLayouts prog = go Map.empty [] (collectStructSites prog)
   where
     go layouts diags [] = (layouts, reverse diags)
     go layouts diags (site : rest) =
-      let decl        = siteDecl site
-          name         = structName decl
+      let decl          = siteDecl site
+          name          = structName decl
           (layout, bad) = layOutStruct layouts name (structFields decl)
+          totalSize     = layoutSize layout
           diags'
+            | totalSize > 255   = [ At (siteOffset site) (OversizedStruct name totalSize) ] ++ diags            -- structs over 255 bytes overflow 6502 indirect addressing ops
             | siteTopLevel site = [ At (siteOffset site) (IncompleteStructField name r) | r <- bad ] ++ diags
             | otherwise         = diags
       in go (Map.insert name layout layouts) diags' rest
diff --git a/c02-frontend/src/C02/Analyzer/Types.hs b/c02-frontend/src/C02/Analyzer/Types.hs
index 69e30bd..c1aa4c0 100644
--- a/c02-frontend/src/C02/Analyzer/Types.hs
+++ b/c02-frontend/src/C02/Analyzer/Types.hs
@@ -169,8 +169,8 @@ isTypeCompatible (expKind, expDepth) (actKind, actDepth)
 -- function needs a return type /and/ its parameter types, which a variable
 -- doesn't have — so the stored value is a sum, one constructor per symbol kind.
 data Symbol
-  = VarSym  Ty          -- ^ a variable of this type
-  | FuncSym Ty [Ty]     -- ^ a function: return type, then parameter types
+  = VarSym  Ty           -- ^ a variable of this type
+  | FuncSym Ty [Ty] Bool -- ^ a function: return type, then parameter types, isInterrupt
   deriving (Show, Eq)
 
 data Env = Env
@@ -183,7 +183,7 @@ data Env = Env
                                           -- becomes a LOAD/STORE at the address rather
                                           -- than a var copy. Empty during analysis
                                           -- (registers type as ordinary 'VarSym').
-  }
+  } deriving (Show)
 
 
 -- | Resolve an expression's type (SPEC §3/§6.3/§6.4/§5.2).
@@ -194,12 +194,14 @@ inferType env (Cast bt d e)      = checkCast env bt d e
 inferType env (Var name)         = case symbolLookup env name of
   Left err            -> Left err
   Right (VarSym ty)   -> Right ty
-  Right (FuncSym _ _) -> Left (NotAssignable name)         -- ERR_NOT_ASSIGNABLE
+  Right (FuncSym _ _ _) -> Left (NotAssignable name)         -- ERR_NOT_ASSIGNABLE
 -- A call's type is the callee's RETURN type; a variable here can't be called.
 inferType env (Call name args)   = case symbolLookup env name of
-  Left err                   -> Left err
-  Right (VarSym _)           -> Left (NotAFunction name)   -- ERR_NOT_A_FUNCTION
-  Right (FuncSym ret params) -> checkArgs env name args params ret
+  Left err                         -> Left err
+  Right (VarSym _)                 -> Left (NotAFunction name)   -- ERR_NOT_A_FUNCTION
+  Right (FuncSym ret params i) -> case i of
+    True  -> Left (InterruptCall name)
+    False -> checkArgs env name args params ret
 -- Resolve left, then right (first error wins), then apply §6.3's rules.
 inferType env (Binary op l r)    = case inferType env l of
   Left err -> Left err
diff --git a/c02-frontend/src/C02/Lowering/Lower.hs b/c02-frontend/src/C02/Lowering/Lower.hs
index f43d74d..f8da236 100644
--- a/c02-frontend/src/C02/Lowering/Lower.hs
+++ b/c02-frontend/src/C02/Lowering/Lower.hs
@@ -1,64 +1,60 @@
 module C02.Lowering.Lower
-  ( LowerState(..)
-  , lowerExpr
-  , lowerStmt
-  , lowerBlock
-  , emptyInstr
-  ) where
-import C02.Analyzer.Types (Env (..), Ty, inferType, Symbol (VarSym))
-import C02.Lowering.TAC (Instr(..), Operand(..), TacOp(..), binOpToTac, operandType)
-import C02.Parser.AST (Expr(..), UnOp(..), BinOp(..), BaseType (..), Stmt (..), Loc (Loc), VarDecl (declName, varType, ptrDepth, declInit), AssignmentOp (..), StructDecl (structName, structFields), Block)
+  ( LowerState (..),
+    lowerExpr,
+    lowerStmt,
+    lowerBlock,
+    emptyInstr,
+  )
+where
+
+import C02.Analyzer.Types (Env (..), Symbol (VarSym), Ty, inferType)
+import C02.Lowering.TAC (Instr (..), Operand (..), TacOp (..), binOpToTac, operandType)
+import C02.Parser.AST (AssignmentOp (..), BaseType (..), BinOp (..), Block, Expr (..), Loc (Loc), Stmt (..), StructDecl (structFields, structName), UnOp (..), VarDecl (declInit, declName, ptrDepth, varType))
 import qualified Data.Map as Map
 
 data LowerState = LowerState
-  { nextTemp  :: Int
-  , nextLabel :: Int
+  { nextTemp :: Int,
+    nextLabel :: Int
   }
 
-
 noOperand :: Operand
 noOperand = OperandNone (Void, 0)
 
-
 -- | An instruction with the given op and every other field at its empty
 -- default. Build a real instruction by overriding only the fields that op
 -- actually uses, e.g. @(emptyInstr TacLoad) { instrDst = t, instrSrc1 = p }@.
 emptyInstr :: TacOp -> Instr
-emptyInstr op = Instr
-  { instrOp        = op
-  , instrDst       = noOperand
-  , instrSrc1      = noOperand
-  , instrSrc2      = noOperand
-  , instrLabel     = Nothing
-  , instrCallName  = Nothing
-  , instrCallArgs  = Nothing
-  , instrFieldName = Nothing
-  , instrCastType  = Nothing
-  }
-
+emptyInstr op =
+  Instr
+    { instrOp = op,
+      instrDst = noOperand,
+      instrSrc1 = noOperand,
+      instrSrc2 = noOperand,
+      instrLabel = Nothing,
+      instrCallName = Nothing,
+      instrCallArgs = Nothing,
+      instrFieldName = Nothing,
+      instrCastType = Nothing
+    }
 
 typeOf :: Env -> Expr -> Ty
 typeOf env e = case inferType env e of
   Right t -> t
-  Left _  -> error "typeOf: analyzer should have caught this"
- 
+  Left _ -> error "typeOf: analyzer should have caught this"
 
 freshTemp :: LowerState -> (Int, LowerState)
-freshTemp st = (nextTemp st, st { nextTemp = nextTemp st + 1 })
-
+freshTemp st = (nextTemp st, st {nextTemp = nextTemp st + 1})
 
 -- | Hand out the next label number and bump the counter. Same shape as
 -- 'freshTemp' but for the (until now unused) 'nextLabel' counter.
 freshLabel :: LowerState -> (Int, LowerState)
-freshLabel st = (nextLabel st, st { nextLabel = nextLabel st + 1 })
-
+freshLabel st = (nextLabel st, st {nextLabel = nextLabel st + 1})
 
 labelInstr :: Int -> Instr
-labelInstr l = (emptyInstr TacLabel) { instrLabel = Just (fromIntegral l) }
+labelInstr l = (emptyInstr TacLabel) {instrLabel = Just (fromIntegral l)}
 
 jumpInstr :: Int -> Instr
-jumpInstr l = (emptyInstr TacJump) { instrLabel = Just (fromIntegral l) }
-
+jumpInstr l = (emptyInstr TacJump) {instrLabel = Just (fromIntegral l)}
 
 -- | Emit code that jumps to @target@ when @cond@ evaluates to *false*.
 -- 'TacCondJump' fires when its operand is *true* (nonzero), so we negate the
@@ -68,19 +64,18 @@ jumpInstr l = (emptyInstr TacJump) { instrLabel = Just (fromIntegral l) }
 condJumpUnless :: Env -> LowerState -> Expr -> Int -> ([Instr], LowerState)
 condJumpUnless env st cond target =
   let (condOp, condInstrs, st1) = lowerExpr env st cond
-      (negTmp, st2)             = freshTemp st1
+      (negTmp, st2) = freshTemp st1
       negOp = OperandTemp (U8, 0) negTmp
-      notI  = (emptyInstr TacNot)      { instrDst = negOp, instrSrc1 = condOp }
-      jmpI  = (emptyInstr TacCondJump) { instrSrc1 = negOp, instrLabel = Just (fromIntegral target) }
-  in (condInstrs ++ [notI, jmpI], st2)
-
+      notI = (emptyInstr TacNot) {instrDst = negOp, instrSrc1 = condOp}
+      jmpI = (emptyInstr TacCondJump) {instrSrc1 = negOp, instrLabel = Just (fromIntegral target)}
+   in (condInstrs ++ [notI, jmpI], st2)
 
 -- | Byte width of a value: pointers and 16-bit types are 2, everything else 1.
 tyWidth :: Ty -> Int
 tyWidth (bt, depth)
-  | depth > 0              = 2
+  | depth > 0 = 2
   | bt == U16 || bt == I16 = 2
-  | otherwise              = 1
+  | otherwise = 1
 
 -- | Whether a type is signed (by its base kind, ignoring pointer-ness), matching
 -- cc02's @ir_is_signed@.
@@ -94,40 +89,37 @@ tySigned (bt, _) = bt == I8 || bt == I16
 binopCommonType :: Ty -> Ty -> Ty
 binopCommonType left right =
   let wider = if tyWidth left >= tyWidth right then left else right
-  in if not (tySigned left) || not (tySigned right)
-       then (if tyWidth wider == 2 then U16 else U8, snd wider)
-       else wider
+   in if not (tySigned left) || not (tySigned right)
+        then (if tyWidth wider == 2 then U16 else U8, snd wider)
+        else wider
 
 -- | Widen @op@ to @target@, emitting a 'TacCast' only if the types actually
 -- differ. A constant is re-typed in place (no instruction); anything else casts
 -- into a fresh temp.
 widenIfNeeded :: LowerState -> Operand -> Ty -> (Operand, [Instr], LowerState)
 widenIfNeeded st op target
-  | operandType op == target      = (op, [], st)
-  | OperandConstInt _ n <- op     = (OperandConstInt target n, [], st)
+  | operandType op == target = (op, [], st)
+  | OperandConstInt _ n <- op = (OperandConstInt target n, [], st)
   | otherwise =
       let (t, st1) = freshTemp st
-          dst  = OperandTemp target t
-          cast = (emptyInstr TacCast) { instrDst = dst, instrSrc1 = op, instrCastType = Just target }
-      in (dst, [cast], st1)
-
+          dst = OperandTemp target t
+          cast = (emptyInstr TacCast) {instrDst = dst, instrSrc1 = op, instrCastType = Just target}
+       in (dst, [cast], st1)
 
 lowerArgs :: Env -> LowerState -> [Expr] -> ([Operand], [Instr], LowerState)
-lowerArgs _   st []     = ([], [], st)                    -- no args: nothing lowered, state untouched
-lowerArgs env st (e:es) =
-  let (op,  instrsHead, st1) = lowerExpr env st  e         -- lower the first arg
-      (ops, instrsTail, st2) = lowerArgs env st1 es        -- lower the rest
-  in (op : ops, instrsHead ++ instrsTail, st2)             -- prepend this op, concat instrs in order
-
+lowerArgs _ st [] = ([], [], st) -- no args: nothing lowered, state untouched
+lowerArgs env st (e : es) =
+  let (op, instrsHead, st1) = lowerExpr env st e -- lower the first arg
+      (ops, instrsTail, st2) = lowerArgs env st1 es -- lower the rest
+   in (op : ops, instrsHead ++ instrsTail, st2) -- prepend this op, concat instrs in order
 
 lowerInitters :: Env -> LowerState -> Operand -> [(String, Expr)] -> ([Instr], LowerState)
-lowerInitters _   st _          []                    = ([], st)   -- no fields left
-lowerInitters env st structTemp ((field, expr):rest)  =
+lowerInitters _ st _ [] = ([], st) -- no fields left
+lowerInitters env st structTemp ((field, expr) : rest) =
   let (valOp, valInstrs, st1) = lowerExpr env st expr
-      store = (emptyInstr TacFieldStore) { instrDst = structTemp, instrSrc1 = valOp, instrFieldName = Just field }
-      (restInstrs, st2)       = lowerInitters env st1 structTemp rest
-  in (valInstrs ++ [store] ++ restInstrs, st2)
-
+      store = (emptyInstr TacFieldStore) {instrDst = structTemp, instrSrc1 = valOp, instrFieldName = Just field}
+      (restInstrs, st2) = lowerInitters env st1 structTemp rest
+   in (valInstrs ++ [store] ++ restInstrs, st2)
 
 lowerExpr :: Env -> LowerState -> Expr -> (Operand, [Instr], LowerState)
 lowerExpr env st e@(IntLit n) = (OperandConstInt (typeOf env e) n, [], st)
@@ -138,9 +130,9 @@ lowerExpr env st e@(StrLit s) = (OperandConstStr (typeOf env e) s, [], st)
 lowerExpr env st e@(Var name) = case Map.lookup name (registers env) of
   Just addr ->
     let (t, st1) = freshTemp st
-        dst      = OperandTemp (typeOf env e) t
-        instr    = (emptyInstr TacLoad) { instrDst = dst, instrSrc1 = OperandConstInt (U16, 0) addr }
-    in (dst, [instr], st1)
+        dst = OperandTemp (typeOf env e) t
+        instr = (emptyInstr TacLoad) {instrDst = dst, instrSrc1 = OperandConstInt (U16, 0) addr}
+     in (dst, [instr], st1)
   Nothing -> (OperandVar (typeOf env e) name, [], st)
 -- Logical && / || lower to short-circuit control flow (cc02 ir.c NODE_BINOP),
 -- NOT a TAC_AND/TAC_OR op: c02-as's generator has no case for those because the
@@ -148,121 +140,150 @@ lowerExpr env st e@(Var name) = case Map.lookup name (registers env) of
 -- order (result temp, then labels) mirrors cc02 so temp/label ids line up.
 --   &&: if !left, skip to (result = 0); otherwise result = right.
 lowerExpr env st (Binary And a b) =
-  let (resTmp,   st1) = freshTemp st
+  let (resTmp, st1) = freshTemp st
       (falseLbl, st2) = freshLabel st1
-      (endLbl,   st3) = freshLabel st2
-      result          = OperandTemp (U8, 0) resTmp
+      (endLbl, st3) = freshLabel st2
+      result = OperandTemp (U8, 0) resTmp
       (leftOp, lInstrs, st4) = lowerExpr env st3 a
-      (negTmp, st5)   = freshTemp st4
-      negOp           = OperandTemp (U8, 0) negTmp
-      notI  = (emptyInstr TacNot)      { instrDst = negOp, instrSrc1 = leftOp }
-      cjI   = (emptyInstr TacCondJump) { instrSrc1 = negOp, instrLabel = Just (fromIntegral falseLbl) }
+      (negTmp, st5) = freshTemp st4
+      negOp = OperandTemp (U8, 0) negTmp
+      notI = (emptyInstr TacNot) {instrDst = negOp, instrSrc1 = leftOp}
+      cjI = (emptyInstr TacCondJump) {instrSrc1 = negOp, instrLabel = Just (fromIntegral falseLbl)}
       (rightOp, rInstrs, st6) = lowerExpr env st5 b
-      copyR = (emptyInstr TacCopy) { instrDst = result, instrSrc1 = rightOp }
-      copy0 = (emptyInstr TacCopy) { instrDst = result, instrSrc1 = OperandConstInt (U8, 0) 0 }
-  in ( result
-     , lInstrs ++ [notI, cjI] ++ rInstrs
-         ++ [copyR, jumpInstr endLbl, labelInstr falseLbl, copy0, labelInstr endLbl]
-     , st6 )
-
+      copyR = (emptyInstr TacCopy) {instrDst = result, instrSrc1 = rightOp}
+      copy0 = (emptyInstr TacCopy) {instrDst = result, instrSrc1 = OperandConstInt (U8, 0) 0}
+   in ( result,
+        lInstrs
+          ++ [notI, cjI]
+          ++ rInstrs
+          ++ [copyR, jumpInstr endLbl, labelInstr falseLbl, copy0, labelInstr endLbl],
+        st6
+      )
 --   ||: if left is true, skip to (result = 1); otherwise result = right.
 lowerExpr env st (Binary Or a b) =
-  let (resTmp,  st1) = freshTemp st
+  let (resTmp, st1) = freshTemp st
       (trueLbl, st2) = freshLabel st1
-      (endLbl,  st3) = freshLabel st2
-      result         = OperandTemp (U8, 0) resTmp
+      (endLbl, st3) = freshLabel st2
+      result = OperandTemp (U8, 0) resTmp
       (leftOp, lInstrs, st4) = lowerExpr env st3 a
-      cjI   = (emptyInstr TacCondJump) { instrSrc1 = leftOp, instrLabel = Just (fromIntegral trueLbl) }
+      cjI = (emptyInstr TacCondJump) {instrSrc1 = leftOp, instrLabel = Just (fromIntegral trueLbl)}
       (rightOp, rInstrs, st5) = lowerExpr env st4 b
-      copyR = (emptyInstr TacCopy) { instrDst = result, instrSrc1 = rightOp }
-      copy1 = (emptyInstr TacCopy) { instrDst = result, instrSrc1 = OperandConstInt (U8, 0) 1 }
-  in ( result
-     , lInstrs ++ [cjI] ++ rInstrs
-         ++ [copyR, jumpInstr endLbl, labelInstr trueLbl, copy1, labelInstr endLbl]
-     , st5 )
-
+      copyR = (emptyInstr TacCopy) {instrDst = result, instrSrc1 = rightOp}
+      copy1 = (emptyInstr TacCopy) {instrDst = result, instrSrc1 = OperandConstInt (U8, 0) 1}
+   in ( result,
+        lInstrs
+          ++ [cjI]
+          ++ rInstrs
+          ++ [copyR, jumpInstr endLbl, labelInstr trueLbl, copy1, labelInstr endLbl],
+        st5
+      )
 lowerExpr env st (Binary op a b) =
-  let (opA, instrA, st1) = lowerExpr env st a     -- lower left, using starting state
-      (opB, instrB, st2) = lowerExpr env st1 b    -- lower right
+  let (opA, instrA, st1) = lowerExpr env st a -- lower left, using starting state
+      (opB, instrB, st2) = lowerExpr env st1 b -- lower right
       -- Widen operands to a common type before the op (matching cc02's ir.c):
       -- shifts keep the left type and don't widen the count; pointer arithmetic
       -- isn't widened; everything else widens both sides, and a comparison
       -- yields u8.
-      isCmp   = op `elem` [Lt, Gt, Le, Ge, Eq, Ne]
+      isCmp = op `elem` [Lt, Gt, Le, Ge, Eq, Ne]
       isShift = op `elem` [Shl, Shr]
       tyA = operandType opA
       tyB = operandType opB
       (lhs, rhs, widenInstrs, resultTy, st3)
-        | isShift                     = (opA, opB, [], tyA, st2)
+        | isShift = (opA, opB, [], tyA, st2)
         | snd tyA == 0 && snd tyB == 0 =
-            let common        = binopCommonType tyA tyB
+            let common = binopCommonType tyA tyB
                 (wl, wli, sl) = widenIfNeeded st2 opA common
-                (wr, wri, sr) = widenIfNeeded sl  opB common
-            in (wl, wr, wli ++ wri, if isCmp then (U8, 0) else common, sr)
-        | otherwise                   = (opA, opB, [], tyA, st2)   -- pointer arithmetic
+                (wr, wri, sr) = widenIfNeeded sl opB common
+             in (wl, wr, wli ++ wri, if isCmp then (U8, 0) else common, sr)
+        | otherwise = (opA, opB, [], tyA, st2) -- pointer arithmetic
       (t, st4) = freshTemp st3
-      dst   = OperandTemp resultTy t
-      instr = (emptyInstr (binOpToTac op)) { instrDst = dst, instrSrc1 = lhs, instrSrc2 = rhs }
-  in (dst, instrA ++ instrB ++ widenInstrs ++ [instr], st4)
-
+      dst = OperandTemp resultTy t
+      instr = (emptyInstr (binOpToTac op)) {instrDst = dst, instrSrc1 = lhs, instrSrc2 = rhs}
+   in (dst, instrA ++ instrB ++ widenInstrs ++ [instr], st4)
 lowerExpr env st e@(Unary op operand) = case op of
-  Negate    -> valueUnary TacNeg
-  Bang      -> valueUnary TacNot
-  BitNot    -> valueUnary TacBnot
+  Negate -> valueUnary TacNeg
+  Bang -> valueUnary TacNot
+  BitNot -> valueUnary TacBnot
   AddressOf -> valueUnary TacAddrOf
-  Incr      -> mutateUnary TacInc
-  Decr      -> mutateUnary TacDec
+  Incr -> mutateUnary TacInc
+  Decr -> mutateUnary TacDec
   where
     valueUnary tac =
-      let (opExp, instrExp, st1) = lowerExpr env st operand      -- lower operand
-          (t,   st2)             = freshTemp st1                 -- burn a temp for the result
-          dst                    = OperandTemp (typeOf env e) t  -- burn fresh temp
-          instr = (emptyInstr tac) { instrDst = dst, instrSrc1 = opExp }
-      in (dst, instrExp ++ [instr], st2)
-    mutateUnary tac =
-      let (opOperand, instrOperand, st1) = lowerExpr env st operand
-          instr = (emptyInstr tac) { instrDst = opOperand }
-      in (opOperand, instrOperand ++ [instr], st1)
-
+      let (opExp, instrExp, st1) = lowerExpr env st operand -- lower operand
+          (t, st2) = freshTemp st1 -- burn a temp for the result
+          dst = OperandTemp (typeOf env e) t -- burn fresh temp
+          instr = (emptyInstr tac) {instrDst = dst, instrSrc1 = opExp}
+       in (dst, instrExp ++ [instr], st2)
+    mutateUnary tac = case operand of
+      -- Plain variable (non-register): increment in-place
+      Var name -> case Map.lookup name (registers env) of
+        Nothing ->
+          let dst = OperandVar (typeOf env operand) name
+              instr = (emptyInstr tac) {instrDst = dst}
+           in (dst, [instr], st)
+        -- Register: load, increment, store back
+        Just addr ->
+          let (loadTemp, st1) = freshTemp st
+              loadDst = OperandTemp (typeOf env operand) loadTemp
+              loadInstr = (emptyInstr TacLoad) {instrDst = loadDst, instrSrc1 = OperandConstInt (U16, 0) addr}
+              incInstr = (emptyInstr tac) {instrDst = loadDst}
+              storeInstr = (emptyInstr TacStore) {instrDst = OperandConstInt (U16, 0) addr, instrSrc1 = loadDst}
+           in (loadDst, [loadInstr, incInstr, storeInstr], st1)
+      -- Pointer dereference: load, increment, store back
+      Deref ptr ->
+        let (ptrOp, ptrInstrs, st1) = lowerExpr env st ptr
+            (valTemp, st2) = freshTemp st1
+            valOp = OperandTemp (typeOf env operand) valTemp
+            loadInstr = (emptyInstr TacLoad) {instrDst = valOp, instrSrc1 = ptrOp}
+            incInstr = (emptyInstr tac) {instrDst = valOp}
+            storeInstr = (emptyInstr TacStore) {instrDst = ptrOp, instrSrc1 = valOp}
+         in (valOp, ptrInstrs ++ [loadInstr, incInstr, storeInstr], st2)
+      -- Field access: load, increment, store back
+      Field base fname ->
+        let (baseOp, baseInstrs, st1) = lowerExpr env st base
+            (valTemp, st2) = freshTemp st1
+            valOp = OperandTemp (typeOf env operand) valTemp
+            loadInstr = (emptyInstr TacFieldLoad) {instrDst = valOp, instrSrc1 = baseOp, instrFieldName = Just fname}
+            incInstr = (emptyInstr tac) {instrDst = valOp}
+            storeInstr = (emptyInstr TacFieldStore) {instrDst = baseOp, instrSrc1 = valOp, instrFieldName = Just fname}
+         in (valOp, baseInstrs ++ [loadInstr, incInstr, storeInstr], st2)
+      -- Other expressions are not valid lvalues (analyzer should reject)
+      _ -> error "mutateUnary: non-lvalue operand (analyzer should have rejected)"
 lowerExpr env st e@(Call name params) =
   let (argOps, argInstrs, st1) = lowerArgs env st params
       retType = typeOf env e
       (dst, st2) = case retType of
-        (Void, 0) -> (noOperand, st1)                      -- void: no temp, state passes through unchanged
-        _         -> let (tmp, st') = freshTemp st1
-                    in  (OperandTemp retType tmp, st')     -- non-void: temp burned, new state out
-      callInstr = (emptyInstr TacCall) { instrDst = dst, instrCallName = Just name, instrCallArgs = Just argOps }
-  in (dst, argInstrs ++ [callInstr], st2)
-
+        (Void, 0) -> (noOperand, st1) -- void: no temp, state passes through unchanged
+        _ ->
+          let (tmp, st') = freshTemp st1
+           in (OperandTemp retType tmp, st') -- non-void: temp burned, new state out
+      callInstr = (emptyInstr TacCall) {instrDst = dst, instrCallName = Just name, instrCallArgs = Just argOps}
+   in (dst, argInstrs ++ [callInstr], st2)
 lowerExpr env st (Cast ty depth expr) =
   let (opExpr, instrExpr, st1) = lowerExpr env st expr
-      (t, st2)                 = freshTemp st1
+      (t, st2) = freshTemp st1
       castTy = (ty, depth)
-      dst    = OperandTemp castTy t
-      instr  = (emptyInstr TacCast) { instrDst = dst, instrSrc1 = opExpr, instrCastType = Just castTy }
-  in (dst, instrExpr ++ [instr], st2)
-
+      dst = OperandTemp castTy t
+      instr = (emptyInstr TacCast) {instrDst = dst, instrSrc1 = opExpr, instrCastType = Just castTy}
+   in (dst, instrExpr ++ [instr], st2)
 lowerExpr env st e@(Deref expr) =
-  let (opExp, instrExp, st1)  = lowerExpr env st expr         -- lower operand
-      (t,   st2)              = freshTemp st1                 -- burn a temp for the result
-      dst                     = OperandTemp (typeOf env e) t  -- burn fresh temp
-      instr = (emptyInstr TacLoad) { instrDst = dst, instrSrc1 = opExp }
-  in (dst, instrExp ++ [instr], st2)
-
+  let (opExp, instrExp, st1) = lowerExpr env st expr -- lower operand
+      (t, st2) = freshTemp st1 -- burn a temp for the result
+      dst = OperandTemp (typeOf env e) t -- burn fresh temp
+      instr = (emptyInstr TacLoad) {instrDst = dst, instrSrc1 = opExp}
+   in (dst, instrExp ++ [instr], st2)
 lowerExpr env st e@(Field base name) =
   let (opBase, instrBase, st1) = lowerExpr env st base
-      (t, st2)                 = freshTemp st1
-      dst   = OperandTemp (typeOf env e) t
-      instr = (emptyInstr TacFieldLoad) { instrDst = dst, instrSrc1 = opBase, instrFieldName = Just name }
-  in (dst, instrBase ++ [instr], st2)
-
+      (t, st2) = freshTemp st1
+      dst = OperandTemp (typeOf env e) t
+      instr = (emptyInstr TacFieldLoad) {instrDst = dst, instrSrc1 = opBase, instrFieldName = Just name}
+   in (dst, instrBase ++ [instr], st2)
 lowerExpr env st e@(StructInit _name initters) =
-  let structTy           = typeOf env e             -- (StructName name, 0)
-      (t, st1)           = freshTemp st
-      structTemp         = OperandTemp structTy t
+  let structTy = typeOf env e -- (StructName name, 0)
+      (t, st1) = freshTemp st
+      structTemp = OperandTemp structTy t
       (storeInstrs, st2) = lowerInitters env st1 structTemp initters
-  in (structTemp, storeInstrs, st2)
-
+   in (structTemp, storeInstrs, st2)
 
 -- | Lower one statement to a flat instruction stream. The @Maybe (Int, Int)@ is
 -- the enclosing loop's @(continueLabel, breakLabel)@, or 'Nothing' outside any
@@ -270,23 +291,20 @@ lowerExpr env st e@(StructInit _name initters) =
 -- *down*: a loop sets it for its body, and it reverts automatically because
 -- inner calls get the new value while outer frames keep their own.
 lowerStmt :: Env -> Maybe (Int, Int) -> LowerState -> Stmt -> ([Instr], LowerState)
-
 lowerStmt env _loop st (Return mExpr) = case mExpr of
-  Nothing -> ([bareReturn], st)                       -- `return;` — nothing to carry
-  Just e  -> let (valOp, valInstrs, st1) = lowerExpr env st e
-             in (valInstrs ++ [returnWith valOp], st1) -- `return e;` — value in src1
+  Nothing -> ([bareReturn], st) -- `return;` — nothing to carry
+  Just e ->
+    let (valOp, valInstrs, st1) = lowerExpr env st e
+     in (valInstrs ++ [returnWith valOp], st1) -- `return e;` — value in src1
   where
-    bareReturn    = (emptyInstr TacReturn) { instrSrc1 = noOperand }
-    returnWith v  = (emptyInstr TacReturn) { instrSrc1 = v }
-
+    bareReturn = (emptyInstr TacReturn) {instrSrc1 = noOperand}
+    returnWith v = (emptyInstr TacReturn) {instrSrc1 = v}
 lowerStmt env _loop st (ExprStmt e) =
   let (_op, instrs, st1) = lowerExpr env st e
-  in (instrs, st1)
-
+   in (instrs, st1)
 -- A nested block is just its statements under a fresh scope; the loop context
 -- flows straight through (a block doesn't start or end a loop).
 lowerStmt env loop st (Nested b) = lowerBlock env loop st b
-
 -- The right side is lowered as a value; the left side's *form* picks the write:
 -- a plain copy into a variable, a store through a pointer, or a field store.
 -- Compound ops (+=, -=) desugar to `lhs <op> rhs`. NOTE: that re-lowers the LHS
@@ -295,12 +313,12 @@ lowerStmt env loop st (Nested b) = lowerBlock env loop st b
 -- and acceptable for ordinary lvalues.
 lowerStmt env _loop st (Assign lhs op rhs) =
   let valueExpr = case op of
-        Equals      -> rhs
-        PlusEquals  -> Binary Add lhs rhs
+        Equals -> rhs
+        PlusEquals -> Binary Add lhs rhs
         MinusEquals -> Binary Sub lhs rhs
-        MultEquals  -> Binary Mul lhs rhs
-        DivEquals   -> Binary Div lhs rhs
-        ModEquals   -> Binary Mod lhs rhs
+        MultEquals -> Binary Mul lhs rhs
+        DivEquals -> Binary Div lhs rhs
+        ModEquals -> Binary Mod lhs rhs
       (val, valInstrs, st1) = lowerExpr env st valueExpr
       (storeInstrs, st2) = case lhs of
         -- A register write is a STORE to its fixed address (a U16 constant); any
@@ -314,10 +332,10 @@ lowerStmt env _loop st (Assign lhs op rhs) =
           -- the adjacent register.
           Just addr ->
             let (val', coerceInstrs, st1') = widenIfNeeded st1 val (typeOf env lhs)
-            in (coerceInstrs ++ [(emptyInstr TacStore) { instrDst = OperandConstInt (U16, 0) addr, instrSrc1 = val' }], st1')
+             in (coerceInstrs ++ [(emptyInstr TacStore) {instrDst = OperandConstInt (U16, 0) addr, instrSrc1 = val'}], st1')
           Nothing ->
             let dst = OperandVar (typeOf env lhs) name
-            in ([(emptyInstr TacCopy) { instrDst = dst, instrSrc1 = val }], st1)
+             in ([(emptyInstr TacCopy) {instrDst = dst, instrSrc1 = val}], st1)
         -- Coerce the value to the pointee type for the same reason as the register
         -- write above: TacStore is sized by its source operand, so `*p = 0` into a
         -- u8 target must narrow the void*-typed literal 0 or it stores two bytes.
@@ -326,106 +344,124 @@ lowerStmt env _loop st (Assign lhs op rhs) =
         Deref ptr ->
           let (ptrOp, ptrInstrs, st') = lowerExpr env st1 ptr
               (val', coerceInstrs, st'') = widenIfNeeded st' val (typeOf env lhs)
-          in (ptrInstrs ++ coerceInstrs ++ [(emptyInstr TacStore) { instrDst = ptrOp, instrSrc1 = val' }], st'')
+           in (ptrInstrs ++ coerceInstrs ++ [(emptyInstr TacStore) {instrDst = ptrOp, instrSrc1 = val'}], st'')
         Field base fname ->
-          let (baseOp, baseInstrs, st') = lowerExpr env st1 base
-          in (baseInstrs ++ [(emptyInstr TacFieldStore) { instrDst = baseOp, instrSrc1 = val, instrFieldName = Just fname }], st')
+          case base of
+            -- Nested field assignment: o.in.v = 42
+            -- Load outer base, load inner field into temp, store value into field of temp, store temp back
+            Field outerBase outerFname ->
+              let (outerBaseOp, outerBaseInstrs, st') = lowerExpr env st1 outerBase
+                  (innerTemp, st'') = freshTemp st'
+                  innerTempOp = OperandTemp (typeOf env base) innerTemp
+                  loadInnerInstr = (emptyInstr TacFieldLoad) { instrDst = innerTempOp, instrSrc1 = outerBaseOp, instrFieldName = Just outerFname }
+                  storeFieldInstr = (emptyInstr TacFieldStore) { instrDst = innerTempOp, instrSrc1 = val, instrFieldName = Just fname }
+                  storeBackInstr = (emptyInstr TacFieldStore) { instrDst = outerBaseOp, instrSrc1 = innerTempOp, instrFieldName = Just outerFname }
+               in (outerBaseInstrs ++ [loadInnerInstr, storeFieldInstr, storeBackInstr], st'')
+            -- Shallow field assignment: x.v = 42 (current logic)
+            _ ->
+              let (baseOp, baseInstrs, st') = lowerExpr env st1 base
+               in (baseInstrs ++ [(emptyInstr TacFieldStore) { instrDst = baseOp, instrSrc1 = val, instrFieldName = Just fname }], st')
         _ -> error "lowerStmt Assign: non-lvalue target (analyzer should have rejected)"
-  in (valInstrs ++ storeInstrs, st2)
-
+   in (valInstrs ++ storeInstrs, st2)
 -- if / else-if / else is a guard chain; lower it against one shared end label.
 lowerStmt env loop st (If clauses) =
-  let (endLabel, st1)   = freshLabel st
+  let (endLabel, st1) = freshLabel st
       (bodyInstrs, st2) = lowerClauses env loop st1 endLabel clauses
-  in (bodyInstrs ++ [labelInstr endLabel], st2)
-
+   in (bodyInstrs ++ [labelInstr endLabel], st2)
 lowerStmt env _loop st (While cond mBody) =
-  let (condLabel, st1)  = freshLabel st
-      (endLabel,  st2)  = freshLabel st1
+  let (condLabel, st1) = freshLabel st
+      (endLabel, st2) = freshLabel st1
       (condInstrs, st3) = condJumpUnless env st2 cond endLabel
       (bodyInstrs, st4) = case mBody of
-        Nothing   -> ([], st3)
+        Nothing -> ([], st3)
         Just body -> lowerBlock env (Just (condLabel, endLabel)) st3 body
-  in ( labelInstr condLabel : condInstrs ++ bodyInstrs ++ [jumpInstr condLabel, labelInstr endLabel]
-     , st4 )
-
+   in ( labelInstr condLabel : condInstrs ++ bodyInstrs ++ [jumpInstr condLabel, labelInstr endLabel],
+        st4
+      )
 lowerStmt env loop st (For mInit mCond mIncr mBody) =
   let (env', initInstrs, st1) = lowerForInit env loop st mInit
       (condLabel, st2) = freshLabel st1
-      (endLabel,  st3) = freshLabel st2
-      (incrLabel, st4) = freshLabel st3   -- continue lands here: run incrementer, then recheck
+      (endLabel, st3) = freshLabel st2
+      (incrLabel, st4) = freshLabel st3 -- continue lands here: run incrementer, then recheck
       (condInstrs, st5) = case mCond of
-        Nothing   -> ([], st4)
+        Nothing -> ([], st4)
         Just cond -> condJumpUnless env' st4 cond endLabel
       (bodyInstrs, st6) = case mBody of
-        Nothing   -> ([], st5)
+        Nothing -> ([], st5)
         Just body -> lowerBlock env' (Just (incrLabel, endLabel)) st5 body
       (incrInstrs, st7) = case mIncr of
-        Nothing   -> ([], st6)
+        Nothing -> ([], st6)
         Just incr -> lowerStmt env' loop st6 incr
-  in ( initInstrs
-       ++ labelInstr condLabel : condInstrs
-       ++ bodyInstrs
-       ++ labelInstr incrLabel : incrInstrs
-       ++ [jumpInstr condLabel, labelInstr endLabel]
-     , st7 )
-
+   in ( initInstrs
+          ++ labelInstr condLabel
+          : condInstrs
+          ++ bodyInstrs
+          ++ labelInstr incrLabel
+          : incrInstrs
+          ++ [jumpInstr condLabel, labelInstr endLabel],
+        st7
+      )
 -- break/continue jump to the enclosing loop's labels. The analyzer already
 -- rejected these outside a loop, so 'Nothing' is an unreachable safety no-op.
 lowerStmt _env loop st Break = case loop of
   Just (_cont, brk) -> ([jumpInstr brk], st)
-  Nothing           -> ([], st)
+  Nothing -> ([], st)
 lowerStmt _env loop st Continue = case loop of
   Just (cont, _brk) -> ([jumpInstr cont], st)
-  Nothing           -> ([], st)
-
+  Nothing -> ([], st)
 -- Declarations are handled at block level (see 'lowerBlock') so they can scope
 -- the rest of the block; reaching them here is an invariant violation, treated
 -- as a benign no-op the way the analyzer does.
-lowerStmt _env _loop st (LocVarDecl _)    = ([], st)
+lowerStmt _env _loop st (LocVarDecl _) = ([], st)
 lowerStmt _env _loop st (StructDeclStmt _) = ([], st)
 
-
 -- | Lower an if/else-if/else clause chain against a shared @end@ label. Each
 -- guarded clause jumps past its body to the next clause on a false condition;
 -- after a non-final body, an unconditional jump to @end@ skips the rest.
-lowerClauses :: Env -> Maybe (Int, Int) -> LowerState -> Int
-             -> [(Maybe Expr, Block)] -> ([Instr], LowerState)
-lowerClauses _   _    st _   []                 = ([], st)
-lowerClauses env loop st _   [(Nothing, block)] =           -- final `else`
-  lowerBlock env loop st block                              -- no guard; falls through to end
-lowerClauses env loop st end [(Just cond, block)] =         -- final guarded clause, no else
-  let (condInstrs, st1) = condJumpUnless env st cond end    -- false skips straight to end
+lowerClauses ::
+  Env ->
+  Maybe (Int, Int) ->
+  LowerState ->
+  Int ->
+  [(Maybe Expr, Block)] ->
+  ([Instr], LowerState)
+lowerClauses _ _ st _ [] = ([], st)
+lowerClauses env loop st _ [(Nothing, block)] =
+  -- final `else`
+  lowerBlock env loop st block -- no guard; falls through to end
+lowerClauses env loop st end [(Just cond, block)] =
+  -- final guarded clause, no else
+  let (condInstrs, st1) = condJumpUnless env st cond end -- false skips straight to end
       (bodyInstrs, st2) = lowerBlock env loop st1 block
-  in (condInstrs ++ bodyInstrs, st2)                        -- body falls through to end
-lowerClauses env loop st end ((Just cond, block) : rest) =  -- guarded clause, more follow
-  let (next, st1)       = freshLabel st
-      (condInstrs, st2) = condJumpUnless env st1 cond next  -- false -> next clause
+   in (condInstrs ++ bodyInstrs, st2) -- body falls through to end
+lowerClauses env loop st end ((Just cond, block) : rest) =
+  -- guarded clause, more follow
+  let (next, st1) = freshLabel st
+      (condInstrs, st2) = condJumpUnless env st1 cond next -- false -> next clause
       (bodyInstrs, st3) = lowerBlock env loop st2 block
       (restInstrs, st4) = lowerClauses env loop st3 end rest
-  in (condInstrs ++ bodyInstrs ++ [jumpInstr end, labelInstr next] ++ restInstrs, st4)
-lowerClauses env loop st _   ((Nothing, block) : _) =       -- else before end (AST forbids); take it
+   in (condInstrs ++ bodyInstrs ++ [jumpInstr end, labelInstr next] ++ restInstrs, st4)
+lowerClauses env loop st _ ((Nothing, block) : _) =
+  -- else before end (AST forbids); take it
   lowerBlock env loop st block
 
-
 -- | Lower a @for@ initializer, which may declare a variable scoped to the
 -- loop's cond/incr/body — so a declaration extends the env (and that extension
 -- is returned for the caller to use across the loop), like 'lowerBlock' does.
 lowerForInit :: Env -> Maybe (Int, Int) -> LowerState -> Maybe Stmt -> (Env, [Instr], LowerState)
-lowerForInit env _    st Nothing                = (env, [], st)
-lowerForInit env _    st (Just (LocVarDecl vd)) =
-  let env'     = bindLocalVar vd env
+lowerForInit env _ st Nothing = (env, [], st)
+lowerForInit env _ st (Just (LocVarDecl vd)) =
+  let env' = bindLocalVar vd env
       (i, st1) = lowerInit env st vd
-  in (env', i, st1)
-lowerForInit env loop st (Just s)               =
+   in (env', i, st1)
+lowerForInit env loop st (Just s) =
   let (i, st1) = lowerStmt env loop st s
-  in (env, i, st1)
-
+   in (env, i, st1)
 
 bindLocalVar :: VarDecl -> Env -> Env
-bindLocalVar vd env = env { symbols = Map.insert (declName vd) (VarSym ty) (symbols env) }
-  where ty = (varType vd, ptrDepth vd)
-
+bindLocalVar vd env = env {symbols = Map.insert (declName vd) (VarSym ty) (symbols env)}
+  where
+    ty = (varType vd, ptrDepth vd)
 
 -- | Register a statement-position struct into the env for the rest of its block.
 -- Emits no instructions — it only makes the struct's fields visible so a later
@@ -433,8 +469,7 @@ bindLocalVar vd env = env { symbols = Map.insert (declName vd) (VarSym ty) (symb
 -- 'declLocalStruct').
 bindLocalStruct :: StructDecl -> Env -> Env
 bindLocalStruct sd env =
-  env { structDefs = Map.insert (structName sd) (structFields sd) (structDefs env) }
-
+  env {structDefs = Map.insert (structName sd) (structFields sd) (structDefs env)}
 
 -- | Emit the store for a local's initializer, if it has one. An uninitialized
 -- local emits nothing (it exists by being referenced later); an initialized one
@@ -443,30 +478,29 @@ bindLocalStruct sd env =
 lowerInit :: Env -> LowerState -> VarDecl -> ([Instr], LowerState)
 lowerInit env st vd = case declInit vd of
   Nothing -> ([], st)
-  Just e  ->
+  Just e ->
     let (valOp, valInstrs, st1) = lowerExpr env st e
-        ty   = (varType vd, ptrDepth vd)
-        dst  = OperandVar ty (declName vd)
-        copy = (emptyInstr TacCopy) { instrDst = dst, instrSrc1 = valOp }
-    in (valInstrs ++ [copy], st1)
-
+        ty = (varType vd, ptrDepth vd)
+        dst = OperandVar ty (declName vd)
+        copy = (emptyInstr TacCopy) {instrDst = dst, instrSrc1 = valOp}
+     in (valInstrs ++ [copy], st1)
 
 -- | Lower a block's statements in order, threading state and extending the env
 -- for declarations so they scope the rest of the block (the "scope is the
 -- recursive tail" idiom). The extended env never escapes the block, so nested
 -- scopes are preserved. The loop context flows through untouched.
 lowerBlock :: Env -> Maybe (Int, Int) -> LowerState -> [Loc Stmt] -> ([Instr], LowerState)
-lowerBlock _   _    st []                             = ([], st)
+lowerBlock _ _ st [] = ([], st)
 lowerBlock env loop st (Loc _ (LocVarDecl vd) : rest) =
-  let env'      = bindLocalVar vd env         -- vd is in scope for the REST of this block
-      (i1, st1) = lowerInit env st vd         -- init lowered in the pre-binding env
+  let env' = bindLocalVar vd env -- vd is in scope for the REST of this block
+      (i1, st1) = lowerInit env st vd -- init lowered in the pre-binding env
       (i2, st2) = lowerBlock env' loop st1 rest
-  in (i1 ++ i2, st2)
+   in (i1 ++ i2, st2)
 lowerBlock env loop st (Loc _ (StructDeclStmt sd) : rest) =
-  let env'      = bindLocalStruct sd env      -- struct visible for the tail; emits nothing
+  let env' = bindLocalStruct sd env -- struct visible for the tail; emits nothing
       (i2, st1) = lowerBlock env' loop st rest
-  in (i2, st1)
+   in (i2, st1)
 lowerBlock env loop st (Loc _ s : rest) =
   let (i1, st1) = lowerStmt env loop st s
       (i2, st2) = lowerBlock env loop st1 rest
-  in (i1 ++ i2, st2)
\ No newline at end of file
+   in (i1 ++ i2, st2)
\ No newline at end of file
diff --git a/c02-frontend/src/C02/Lowering/Module.hs b/c02-frontend/src/C02/Lowering/Module.hs
index d6121a8..240eaa3 100644
--- a/c02-frontend/src/C02/Lowering/Module.hs
+++ b/c02-frontend/src/C02/Lowering/Module.hs
@@ -57,7 +57,7 @@ buildGlobalEnv decls = Env
       FwdFuncDecl f   -> [(funcName f, funcSym f)]
       StructDef _     -> []
     funcSym f = FuncSym (funcReturnType f, funcReturnPtrDepth f)
-                        [ (bt, d) | (bt, d, _) <- params f ]
+                        [ (bt, d) | (bt, d, _) <- params f ] (validInterrupt f)
 
 
 -- | Lower one function to a single-block CFG. Parameters are added to the
@@ -71,7 +71,7 @@ lowerFunction genv f = T.Cfg
   , T.blocks      = [ T.Block { T.blockId = 0, T.instructions = allInstrs } ]
   , T.nextTemp    = nextTemp finalSt
   , T.nextLabel   = nextLabel finalSt
-  , T.isInterrupt = isInterrupt f
+  , T.isInterrupt = validInterrupt f
   }
   where
     fenv      = genv { symbols = foldr addParam (symbols genv) (params f) }
diff --git a/c02-frontend/src/C02/Parser/AST.hs b/c02-frontend/src/C02/Parser/AST.hs
index 86ffa05..412e7d5 100644
--- a/c02-frontend/src/C02/Parser/AST.hs
+++ b/c02-frontend/src/C02/Parser/AST.hs
@@ -23,6 +23,7 @@ module C02.Parser.AST
   , locPos
   , locOffset
   , unLoc
+  , validInterrupt
   ) where
 
 -- | A source position: the file a node came from plus the byte offset of its
@@ -155,3 +156,10 @@ data FuncDecl = FuncDecl
   , params             :: [NamedType] -- Type, ptr depth, name
   , body               :: Maybe Stmt -- Nested variant
   } deriving (Show, Eq)
+
+
+validInterrupt :: FuncDecl -> Bool
+validInterrupt (FuncDecl name rt rtDepth i p _) = (name == "irq" || name == "nmi") -- Must be named irq or nmi
+                                               && (rt == Void && rtDepth == 0)     -- Must return bare void
+                                               && i == True && p == []             -- Must be marked interrupt and have no parameters
+
diff --git a/docs/Deviations/FINDINGS_codegen.md b/docs/Deviations/FINDINGS_codegen.md
new file mode 100644
index 0000000..bff51ef
--- /dev/null
+++ b/docs/Deviations/FINDINGS_codegen.md
@@ -0,0 +1,394 @@
+# Audit Findings — `c02-as` (C code generator)
+
+**Status:** pinned to `main` @ `6d619f6` (2026-07-17), from a close read of
+`c02-as/src/generator.c` + `ir.h`, with runtime verification in py65 via
+`bin/c02c`. Format follows [`DEVIATIONS_hs_impl.md`](../DEVIATIONS_hs_impl.md);
+companions: [frontend](FINDINGS_frontend.md), [linker](FINDINGS_linker.md),
+[IR format](FINDINGS_ir_format.md).
+
+Two frontend-owned miscompiles that *surface* here are documented in the
+frontend doc and only cross-referenced below: `++`/`--` without store-back
+([FE-19](FINDINGS_frontend.md#fe-19)) and nested field assignment into a temp
+copy ([FE-20](FINDINGS_frontend.md#fe-20)) — in both, the generator faithfully
+executes wrong IR.
+
+`SPEC.md` §Scope excludes codegen, so most entries cite the spec only where a
+*language-level* promise (a §Appendix B semantic, §4.2 interrupt behavior, an
+accepted construct) is broken; the rest are
+**none — undocumented architecture**.
+
+**Verification level**: **Executed** = the exact program shown was compiled at
+the pinned commit and run in py65 (expected vs. actual observed at
+`PORTB`/$6000); **Source** = code-path analysis only.
+
+Severity: **T** over-strict rejection · **P0** silent miscompile ·
+**P1** loud failure/crash on a reasonable program · **P2** latent gap ·
+**G** quirk.
+
+## Quick Reference
+
+| ID | Sev | Verified | Status | Summary | Spec section |
+|---|---|---|---|---|---|
+| [CG-1](#cg-1) | P0 | Executed | ✅ Fixed upstream | Struct-by-value returns truncated to 1 byte | none — undocumented architecture |
+| [CG-2](#cg-2) | P0 | Executed | ✅ Fixed upstream | Struct-by-value parameters copy 1 byte through a 2-byte ABI slot | none — undocumented architecture |
+| [CG-3](#cg-3) | P0 | Executed | — | Pointer comparisons: 1 result byte written, 2 read back — control flow flips on ZP residue | [§6.3](../SPEC.md#63-binary-operators) |
+| [CG-4](#cg-4) | P1 | Executed | — | `TAC_ADDR_OF` of a non-variable lvalue reads the operand union as a pointer → SIGSEGV | [§6.2](../SPEC.md#62-unary-prefix-operators) |
+| [CG-5](#cg-5) | P0 | Executed | — | Zero-extension where sign-extension is needed: `ptr + (i8)-1`, i8 args into i16 params, i8 returns | [Appendix B](../SPEC.md#appendix-b-confirmed-runtime-semantics) |
+| [CG-6](#cg-6) | P0 | Executed | ✅ Fixed upstream | Any `is_interrupt` function reached by `JSR` executes RTI against a call frame | [§4.2](../SPEC.md#42-interrupt-functions) |
+| [CG-7](#cg-7) | P0 | Executed | — | String data emitted with `strlen`: embedded `\0` truncates; dedup coalesces by prefix | [§1.4](../SPEC.md#14-string-literals) |
+| [CG-8](#cg-8) | P2 | Source | ✅ Fixed | 32KB bounds check misses the footer: last 10 bytes ($FFF6–$FFFF) silently overwritten | none — undocumented architecture |
+| [CG-9](#cg-9) | P2 | Source | ✅ Fixed | `allocate_globals` never checks RAM_TOP — globals silently run past $3FFF | none — undocumented architecture |
+| [CG-10](#cg-10) | P2 | Source | — | Interrupt handlers don't save the ABI zone, helper slots, or RET | none — undocumented architecture |
+| [CG-11](#cg-11) | P2 | Source | ✅ Fixed upstream | Struct field offsets >255 wrap in `LDY #imm` on the pointer path | none — undocumented architecture |
+| [CG-12](#cg-12) | P2 | Source | — | Every referenced global gets a dead ZP slot per function — wasted ZP, earlier exhaustion | none — undocumented architecture |
+| [CG-13](#cg-13) | P2 | Source | — | Variable shift counts read only the low byte | none — undocumented architecture |
+
+## Entries
+
+### CG-1: Struct-by-value returns truncated to 1 byte
+
+```c
+struct Pair { u8 a; u8 b; }
+fn make() -> Pair { return Pair{ .a = 7, .b = 42 }; }
+fn main() -> void { Pair q = make(); PORTB = q.b; }
+// PORTB == 0, expected 42 (Executed)
+```
+
+Two independent width errors, both from `codegen_type_size()` returning its
+**default 1** for `TYPE_STRUCT` (it only knows scalars and pointers):
+
+- `TAC_RETURN` (`generator.c:941`) copies
+  `codegen_type_size(cfg->return_type)` = **1** byte into RET;
+- the `TAC_CALL` return-copy (`:982`) copies the same 1 byte back out.
+
+Fields past offset 0 of a returned struct are never transferred (`q.b` reads
+whatever the destination temp held). Even with `full_type_size` substituted,
+RET is a fixed 2-byte slot at $02/$03 — a ≥3-byte struct would overrun into
+the ZP variable zone at $04 — so struct returns need a real ABI (RAM
+scratch/hidden pointer), or the frontend/analyzer must reject them loudly.
+Today they're accepted everywhere and silently wrong.
+
+**Spec:** none — the ABI is undocumented architecture; the *language* accepts
+struct return types (§3.1/§4.1 place no restriction).
+
+**Verified:** Executed.
+
+**Resolved:** Made return by value for struct types prohibited. This is more efficient
+in memory anyways compared to copying structs around. Added two tests: `bad_struct_by_value_return`
+and `struct_by_pointer_return` demonstrating the error case and success cases.
+
+### CG-2: Struct-by-value parameters copy 1 byte through a 2-byte slot
+
+```c
+struct Pair { u8 a; u8 b; }
+fn second(u8 dummy, Pair p) -> u8 { return p.b; }
+fn main() -> void {
+  Pair q = Pair{ .a = 7, .b = 42 };
+  PORTB = second(0, q);          // PORTB == 7, expected 42 (Executed)
+}
+```
+
+The call site copies `ABI_SLOT_SIZE` = 2 bytes of each arg into the fixed ABI
+zone (`:972-978`) — already truncating any struct > 2 bytes — and the
+prologue (`emit_function_prologue`, `:738`) then copies only
+`codegen_type_size(param->type)` = **1** byte from the slot into the param's
+ZP storage. `p.b` reads uninitialized ZP; the single-param variant of this
+repro *passes by accident* because the callee's param slot happens to alias
+the caller's argument ZP slot — one extra parameter breaks the coincidence,
+which is exactly the kind of layout-dependent "works until it doesn't" P0.
+Same fix space as CG-1: fixed 2-byte slots can never carry structs; pass big
+values via RAM or reject struct params.
+
+**Spec:** none — undocumented architecture (ABI).
+
+**Verified:** Executed (both the failing layout and the accidental-pass one).
+
+**Resolved:** Made pass by value for struct types prohibited. This is more efficient
+in memory anyways compared to copying structs around. Added two tests: `bad_struct_by_value_param`
+and `struct_by_pointer_param` demonstrating the error case and success cases.
+
+### CG-3: Pointer comparisons — one result byte written, two read back
+
+```c
+u8 pad = 1;   // moves g so &g's low byte is nonzero — this line flips the result
+u8 g = 1;
+fn check(u8 *p) -> u8 {
+  if (p == null) { return 111; }
+  return 222;
+}
+fn main() -> void { u8 *q = &g; PORTB = check(q); }
+// PORTB == 111 (the p==null branch!) — remove `pad` and it's 222 (Executed)
+```
+
+Every comparison emitter ends `STA dst_zp` — exactly **one** boolean byte —
+but the frontend types a comparison's destination temp at the *operand* type
+when either operand is a pointer (`Lower.hs` widens/retypes only when both
+operand depths are 0; §6.3 even blesses "result = wider operand type"). The
+dst temp is therefore a 2-byte ZP slot whose high byte is never written, and
+the very next consumer (`TAC_NOT` inside the `if`-lowering, or
+`TAC_COND_JUMP`) sizes its read from that same type and `ORA`s the stale high
+byte. The branch outcome depends on whatever previously occupied that ZP
+address — above, the caller's `q` low byte. In py65's zeroed RAM many
+programs pass; on real hardware (random ZP at power-on) this is
+nondeterministic control flow on *any* pointer comparison (`p == null`,
+`p != q`, `while (p < end)` …).
+
+**Fix:** either the comparison emitters store `dst`'s full width (zero the
+high byte), or the frontend types comparison results `(U8, 0)` uniformly —
+the latter contradicts §6.3's "wider operand" wording, which was written for
+scalars; the spec should say what a pointer comparison's type is.
+
+**Spec:** §6.3 (result-type rule is ambiguous for pointers; the machine
+behavior is undocumented architecture).
+
+**Verified:** Executed — one unrelated global flips 222 → 111.
+
+### CG-4: `TAC_ADDR_OF` of a non-variable lvalue — union misread → SIGSEGV
+
+```c
+struct Point { u8 x; u8 y; }
+u8 g = 9;                       // any global makes lookup_global iterate
+fn main() -> void {
+  Point p = Point{ .x = 3, .y = 4 };
+  u8 *q = &p.y;                 // c02-as: Segmentation fault (rc=139, Executed)
+  PORTB = *q;
+}
+```
+
+`TAC_ADDR_OF` (`:905`) does `lookup_global(e, instruction->src1.name)`
+unconditionally. `&var` puts an `OPERAND_VAR` there and works; but `&p.y` and
+`&*p` lower the operand as a value first ([the FE-19/FE-20 pattern]), so
+`src1` is an **OPERAND_TEMP** — and `.name` aliases `.temp_id` in the operand
+union. `strcmp` then dereferences a pointer forged from a small integer:
+segfault whenever at least one global exists (`lookup_global` iterates), and
+when no globals exist it "succeeds" by taking the **address of the temp's ZP
+slot** — a pointer to a copy, silently wrong (P0-shaped fallback behind the
+P1). Direct parallel to `cc02`'s
+[P1-1](../DEVIATIONS_c_impl.md#p1-1-address-of-a-struct-field-segfaults-the-compiler),
+reproduced in a new implementation. The analyzer accepts `&p.y` per §7.3
+(`Field` is an lvalue), so this is reachable from ordinary source.
+
+**Spec:** §6.2/§7.3 (language accepts it); crash behavior undocumented
+architecture.
+
+**Verified:** Executed — `c02-as` killed by SIGSEGV on the `.o`.
+
+### CG-5: Zero-extension where sign-extension is required
+
+```c
+u8 a = 10;  u8 b = 20;
+u8 *p = &b;
+u8 *q = p + (i8)-1;   // q == p + 255, not p - 1 → *q reads 0, expected 10 (Executed)
+```
+```c
+fn wide(i16 w) -> i16 { return w; }
+i8 n = -5;
+PORT16 = (u16)wide(n);  // 251 (0x00FB), expected 65531 (0xFFFB) (Executed)
+```
+
+`emit_load_byte` (and every `GLOBAL_AWARE_ALU_HELPER`) substitutes
+`LDA #0` for any byte index past the operand's width — unconditional
+**zero**-extension. That's correct for the unsigned widening of Appendix B,
+and harmless for scalar binops because the frontend inserts explicit
+`TAC_CAST`s (which *do* sign-extend, `:829-841`) before mixed-width scalar
+ops. It is wrong on the three paths that skip the cast:
+
+1. **Pointer arithmetic** — lowering deliberately doesn't widen the integer
+   operand, so `TAC_ADD/TAC_SUB` on a pointer reads byte 1 of an `i8` offset
+   as `$00`: a negative offset adds `+256+n` instead of `n`.
+2. **Call arguments** — args are copied to ABI slots at 2 bytes with no cast;
+   a negative `i8`/narrow arg into a wider signed param arrives
+   zero-extended. (Admitted in the `generator.c:25` header comment — "a
+   future IR pass should insert TAC_CAST nodes here" — but recorded in no
+   deviations doc until now.)
+3. **Return values** — `TAC_RETURN` loads `codegen_type_size(return_type)`
+   bytes from the returned operand; `return n;` with `n : i8` from an
+   `-> i16` function zero-extends the same way.
+
+**Spec:** Appendix B pins unsigned widening as zero-extension; the *signed*
+widening these paths perform is bit-pattern-wrong by §3.2 rule 8's model
+(same-signedness widening must preserve value). Severity P0: analyzer accepts
+all three shapes, output is silently wrong.
+
+**Verified:** Executed (paths 1 and 2; path 3 Source, same mechanism).
+
+### CG-6: Any `is_interrupt` function reached by `JSR` executes RTI against a call frame
+
+```c
+fn foo() interrupt -> void { PORTB = 42; }
+fn main() -> void { foo(); PORTB = 7; }
+// Runs foo's body, then never halts — PC ends at $0000; PORTB stays 42 (Executed)
+```
+
+`emit_function_from_cfg` gives every flagged CFG the PHA/PHX/PHY prologue and
+PLY/PLX/PLA + **RTI** epilogue. RTI pops *status* then PC; a JSR pushed only
+PC−1 — so the return address low byte is consumed as the status register and
+execution resumes at a garbage address. Reachable two ways, both
+analyzer-accepted: an invalid interrupt (wrong name — the frontend never
+clears the flag, [FE-14](FINDINGS_frontend.md#fe-14), where §4.2 requires
+warn-and-clear), and a *valid* `nmi`/`irq` handler called directly (§4.2 /
+cc02 P2-3 says direct calls are currently accepted). The vector table itself
+is handled correctly (`emit_vectors` only wires flagged `nmi`/`irq` — a
+genuine improvement over cc02's name-only wiring); the crash is exclusively
+the call path.
+
+**Spec:** §4.2.
+
+**Verified:** Executed — program never reaches the halt loop.
+
+**Resolved (upstream, not here):** `emit_function_from_cfg`'s RTI epilogue is
+unchanged — this entry's C code is still exactly as described, and codegen
+still has no way to tell "reached by `JSR`" from "reached by a real
+interrupt." Both of the two reachability paths this entry named are instead
+closed off in the frontend, so no accepted program can trigger it anymore:
+the invalid-name case is fixed at
+[FE-14](FINDINGS_frontend.md#fe-14) (the flag is now guaranteed cleared
+before `c02-as` ever sees it), and the direct-call case is now a compile-time
+`ERR_INTERRUPT_CALL` rather than the "currently accepted" behavior this entry
+and cc02's P2-3 both describe — `SPEC.md` §4.2 was amended to match. Treat
+this as latent-but-unreachable, not gone: any future path that can hand
+`c02-as` a `.o` with a stray `is_interrupt=true` on a non-vectored function
+(a hand-built object, a different frontend, a bug in `validInterrupt` itself)
+still hits this exact crash, since codegen enforces none of it independently.
+
+### CG-7: String data emitted with `strlen` — embedded NUL truncates
+
+```c
+u8 *s = "ab\0cd";
+PORTB = *(s + 3);   // reads 67 ('C') — the "C02S" symbol-table magic that
+                    // happens to follow the truncated string in ROM (Executed)
+```
+
+§1.4 defines the `\0` escape, and the wire format carries strings
+length-prefixed with the NUL intact — but `emit_data_section` writes
+`strlen(s)+1` bytes, so everything after the first embedded NUL is dropped,
+and the ROM neighbor (here the symbol table) leaks into reads past it. The
+same `strcmp`-based dedup coalesces any two literals equal up to the first
+NUL ("ab\0cd" and "ab\0zz" share one address). The C-side loss of the length
+is an IR-contract issue at root — see
+[IR-2](FINDINGS_ir_format.md#ir-2) — but the observable miscompile is here.
+(The `""` → NULL wire convention *is* handled — `u8 *s = ""; *s` yields 0,
+Executed.)
+
+**Spec:** §1.4.
+
+**Verified:** Executed.
+
+### CG-8: The 32KB bounds check misses the footer
+
+`EMIT`/`PATCH_BYTE` guard every write against `ROM_SIZE` (that half of the
+audit passes: all code, data, symbol-table, and fixup writes are covered —
+fixup patch positions are only reachable un-overflowed because
+`resolve_*_fixups` early-return on `e->overflow`, and the data/symtab phases
+re-check between stages). What nothing guards is the **footer**: code+data may
+legally grow through `$FFF6–$FFFF` (10 bytes: symtab pointer, boundary
+pointer, NMI/Reset/IRQ vectors) without tripping `ROM_SIZE`, and
+`emit_vectors` + the boundary-pointer store then overwrite whatever
+instructions landed there — silently, since only the symbol table performs a
+fit check against `SYMTABLE_START_PTR`. A program within ~10 bytes of exactly
+32KB emits corrupted code with a success exit. The fix is one comparison:
+treat `SYMTABLE_START_PTR` (or `0xFFFA−ROM_START` without symbols) as the
+effective ceiling for `code_pos`/data.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source (requires a ≈32,758-byte image to demonstrate; the
+arithmetic and write sites are all in `generate_rom`/`emit_vectors`).
+
+**Resolved:** Changed `EMIT` and `PATCH_BYTE` to guard writes against `SYMTABLE_START_PTR`
+instead of `ROM_SIZE` to stop footer from being overwritten. Added `codegen/bad_rom_overflow`
+test to exercise the guards, all other tests still pass. Emitting the symbol table pointer
+itself no longer uses the `PATCH_BYTE` macro since the editted guard will cause that to always
+fail.
+
+### CG-9: No RAM-exhaustion check for globals
+
+`allocate_globals` advances `e->ram_pos` from `$0200` with no comparison
+against `RAM_TOP` (`$3FFF`): a large enough global set (or the compiler slots
+appended by `emit_compiler_extern_inits`) walks into `$4000+` — unmapped/IO
+space on the target board — and ultimately wraps `uint16_t`. `__heap_start`
+is then also wrong (it's defined as first-free-RAM). All silent. ~15.5KB of
+globals is unusual but reachable (a few large structs); the check is one line.
+
+**Spec:** none — undocumented architecture (`docs/memmap.md` documents the
+map but no stage enforces it).
+
+**Verified:** Source.
+
+**Resolved:** `allocate_globals` and `emit_compiler_extern_inits`
+now checks `e->ram_pos > RAM_TOP` after sizing each global and sets `e->overflow`;
+`generate_rom` bails out via the existing `OVERFLOW_ERROR_CHECK` machinery immediately
+after the call, before any code or data is emitted. This closes the finding's main case —
+user-declared globals walking past `$3FFF` — cleanly: pinned by
+`test/codegen/bad_ram_overflow.golden` (13 nested structs, doubling in size,
+the top one alone 16,384 bytes against a 15,871-byte budget → rejected) and
+`test/codegen/struct_under_ram_budget.golden` (one level shallower, 8,192
+bytes → builds clean, proving the check isn't just always-on).
+
+### CG-10: Interrupt handlers preserve their own ZP map — and nothing else
+
+`emit_zp_save` in a handler covers the handler's *own* var/temp slots, and
+the prologue saves A/X/Y — correct as far as it goes. Not saved: the **ABI
+zone** (`$EF–$FE`), the **arithmetic helper slots** (`$E0–$EC`), and **RET**
+(`$02/$03`). An interrupt arriving between a caller's ABI-slot stores and its
+`JSR` — or mid-`__mul8`/`__div16`, or between a callee's RTS and the caller's
+RET read — has its state clobbered if the handler itself calls any function
+with arguments, uses `*`//`/`/`%`, or calls anything non-void. That is most
+non-trivial handlers. Runtime symptom: sporadic wrong argument/result values
+in the interrupted code, unreproducible in step-through. Handlers must either
+save `$E0–$FE` + `$02/$03` (≈33 extra pushes — stack budget!) or the docs
+must ban calls/mul/div in handlers; today neither is done nor written down.
+
+**Spec:** none — undocumented architecture (§4.2 covers only
+declaration-site rules).
+
+**Verified:** Source (py65 harness has no IRQ injection; the window is plain
+from the emit order).
+
+### CG-11: Field offsets past 255 wrap on the pointer path
+
+`TAC_FIELD_LOAD/STORE` through a `Struct*` emit `LDY #(field->offset + b)`
+with a `uint8_t` cast — a struct whose layout exceeds 256 bytes (nested
+by-value structs make this easy: `struct Big { … }` at 130 bytes, containment
+twice) silently wraps Y and reads/writes the wrong field. By-value bases are
+safe in practice only because ZP slots cap locals well below 256, but a
+*global* big struct accessed via pointer compiles and misbehaves. Cheap
+detection at layout-read time (`total_size > 256` → error) would cover it.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source.
+
+**Resolved:** Fixed upstream in the analyzer stage. Added check for total
+struct size to `computeStructLayouts`, added new diagnostic for oversized
+structs. Added new test `bad_oversized_struct` and editted codegen tests,
+`bad_ram_overflow` to use bare globals instead of massive structs and
+`struct_under_ram_budget` to be at the new limit (255 bytes).
+
+### CG-12: Globals get dead ZP slots in every function that touches them
+
+`zp_map_build` registers **every** `OPERAND_VAR` in the instruction stream,
+including names that `lookup_global` will resolve to RAM — those ZP slots are
+then never used for the global's storage (loads/stores go absolute), but they
+count against the `$04–$DF` budget, get saved/restored by every
+callee's `emit_zp_save` (cycles + hardware-stack bytes per call), and hasten
+the loud "ZP space exhausted" failure for functions that reference many
+globals. (The slots *are* legitimately used as pointer scratch on the
+`TAC_LOAD/STORE/FIELD_*` indirect paths — a fix must keep those.) Not wrong
+output; a real capacity/perf trap.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source.
+
+### CG-13: Variable shift counts read only the low byte
+
+`TAC_SHL/TAC_SHR` with a non-constant count do `emit_load_byte(src2, 0)` into
+X: a `u16` count of 256 shifts **zero** times (result = operand) instead of
+producing 0. Constant counts unroll fully and are fine (a pathological
+constant just overflows the ROM loudly). Narrow edge, silent when hit.
+
+**Spec:** none — undocumented architecture (shift-by-≥-width semantics are
+unspecified in `SPEC.md` generally).
+
+**Verified:** Source.
diff --git a/docs/Deviations/FINDINGS_frontend.md b/docs/Deviations/FINDINGS_frontend.md
new file mode 100644
index 0000000..ea31a76
--- /dev/null
+++ b/docs/Deviations/FINDINGS_frontend.md
@@ -0,0 +1,574 @@
+# Audit Findings — `c02-frontend` (Haskell) vs. `SPEC.md`
+
+**Status:** pinned to `main` @ `6d619f6` (2026-07-17), against `docs/SPEC.md` at
+the same checkout. Companion to
+[`DEVIATIONS_hs_impl.md`](../DEVIATIONS_hs_impl.md) (which already records
+HS-1, untyped-literal signedness — not repeated here). Everything below is
+**new**: found by auditing `C02.Parser.*`, `C02.Analyzer.*`, and
+`C02.Lowering.*` against the spec, and verified as marked.
+
+Where a finding concerns `include` resolution or the lowering contract, the
+spec reference is **none — undocumented architecture**: `SPEC.md` defines
+language semantics only; it contains no `include` construct and says nothing
+about the IR emission pipeline.
+
+**Verification level** per entry:
+- **Executed** — reproduced with the exact snippet shown, compiled with
+  `bin/c02-frontend` / run through `bin/c02c` + py65 at the pinned commit.
+- **Source** — derived from reading the sources; re-verify before relying on
+  it as an oracle.
+
+Severity legend (same as `DEVIATIONS_hs_impl.md`):
+- **T** — over-strictness: a program `SPEC.md` requires to be accepted is rejected.
+- **P0** — silent miscompile: accepted by analysis, wrong machine code, no diagnostic.
+- **P1** — loud failure: a stage crashes or fails unsafely on a reasonable program.
+- **P2** — robustness: real gap, latent or needing an unusual program.
+- **G** — grammar/lexer quirk.
+
+## Quick Reference
+
+| ID | Sev | Verified | Status | Summary | Spec section |
+|---|---|---|---|---|---|
+| [FE-1](#fe-1) | T | Executed | — | Struct types defined in an included header are unusable in the includer (per-file prescan) | none — undocumented architecture |
+| [FE-2](#fe-2) | P1 | Executed | ✅ Fixed | Root file is never in the include visited-set: self-include / root↔header cycles duplicate the root's declarations | none — undocumented architecture |
+| [FE-3](#fe-3) | P2 | Executed | — | No path canonicalization: the same header via two spellings is included twice | none — undocumented architecture |
+| [FE-4](#fe-4) | G | Executed | — | include-not-found diagnostic loses the include site's position | none — undocumented architecture |
+| [FE-5](#fe-5) | P2 | Source | — | Lazy `readFile` lets late I/O errors escape the resolver's `try` and crash the driver | none — undocumented architecture |
+| [FE-6](#fe-6) | G | Source | — | Included declarations are hoisted above the includer's own, erasing include position | none — undocumented architecture |
+| [FE-7](#fe-7) | T | Executed | — | No `asm { }` statement exists in the grammar | [§5.7](../SPEC.md#57-inline-assembly-asm) |
+| [FE-8](#fe-8) | G | Executed | — | Char literals: an undocumented extension, not a lexeme (`'a' + 1` fails), Haskell escape rules | [§1.3](../SPEC.md#13-integer-literals) |
+| [FE-9](#fe-9) | G | Executed | — | Adjacent operators fail to lex: `a*-b`, `a<-1`, `a&&&b` are parse errors | [§1.6](../SPEC.md#16-operators--punctuation) |
+| [FE-10](#fe-10) | G | Executed | — | Integer literals overflowing the host word silently wrap (`2^64+1` lexes as `1`) | [§1.3](../SPEC.md#13-integer-literals) |
+| [FE-11](#fe-11) | T | Executed | — | Compound assignment doesn't type-check as its desugaring: `p += 1` rejected on a pointer | [§5.3](../SPEC.md#53-assignment) |
+| [FE-12](#fe-12) | P2 | Executed | — | S-1/S-17 laxity reproduced: any `(void*)`-shaped actual is compatible with *everything* | [§3.2](../SPEC.md#32-type-compatibility) |
+| [FE-13](#fe-13) | P2 | Executed | — | `&&`/`||` operands are entirely unchecked (struct `&&` struct accepted) | [§6.3](../SPEC.md#63-binary-operators) |
+| [FE-14](#fe-14) | P0 | Executed | ✅ Fixed | `interrupt` validation missing: no warning, flag not cleared → calling the function crashes at runtime | [§4.2](../SPEC.md#42-interrupt-functions) |
+| [FE-15](#fe-15) | G | Executed | — | `for`-increment clause accepts a variable declaration | [§5.5](../SPEC.md#55-for-loop-clauses) |
+| [FE-16](#fe-16) | P2 | Source | — | Statement-position structs get no redeclaration check at all | [§7.2](../SPEC.md#72-scope-stack--shadowing) |
+| [FE-17](#fe-17) | P1 | Executed | — | One name-keyed layout table across all scopes: a local `struct S` clobbers the top-level `S`'s layout for the whole module | none — undocumented architecture |
+| [FE-18](#fe-18) | P0 | Executed | — | Non-literal global initializers silently lower to "uninitialized" | [§4.5](../SPEC.md#45-global-variables) |
+| [FE-19](#fe-19) | P0 | Executed | ✅ Fixed | `++`/`--` on a deref, field, or register mutates a loaded temp and never stores back | [§6.2](../SPEC.md#62-unary-prefix-operators) |
+| [FE-20](#fe-20) | P0 | Executed | ✅ Fixed | Nested field assignment (`a.b.c = v`) stores into a temporary copy of `a.b` | [§6.4](../SPEC.md#64-postfix--field-access) |
+| [FE-21](#fe-21) | P2 | Source | — | The IR emission contract: what is promised to `c02-ld`/`c02-as` implicitly, with nothing checking it | none — undocumented architecture |
+| [FE-22](#fe-22) | T | Executed | ✅ Fixed | `__heap_start`/`__memory_top` are not injected — and `libc02`'s header declares the wrong type | [§4.6](../SPEC.md#46-forward-declarations-decl) |
+
+## Entries
+
+### FE-1: Struct types defined in an included header are unusable in the includer
+
+```c
+// inc/inner.h
+struct Inner { u8 v; }
+
+// main.c02
+include "inc/inner.h";
+fn take(Inner *p) -> void { }   // PARSE ERROR: "unexpected 'I', expecting ')'"
+fn main() -> void {
+  Inner x;                       // "`Inner` is not a struct type"
+  struct O { Inner i; }          // parse error inside the field list
+}
+```
+
+The struct-name prescan (`prescanStructNames`, SPEC §6.6) that drives every
+type-vs-identifier disambiguation — declarations, casts, `for`-inits, params,
+field types — runs **per file, before include resolution**. Include resolution
+(`C02.Analyzer.Includes`) happens *after* the whole root file is parsed, so a
+struct declared only in a header is not in the includer's prescan set and every
+use of it as a type either hard-fails the parse (param/field position) or
+misparses (`Inner x;` → not-a-struct; `Inner * p;` → multiplication → undeclared
+identifiers).
+
+Consequence: headers can share **functions, globals, and registers** (via
+`decl` and definitions) but **not struct types**, which defeats half the point
+of the header-file feature (added in #12). The only workaround is repeating the
+`struct` definition in every file that names the type — which then trips the
+linker's struct dedup (fine if layouts are identical, see
+[LD-2](FINDINGS_linker.md#ld-2) for the local-struct hazard).
+
+Fix direction: either prescan after splicing (resolve includes at the token or
+text level before parse), or seed each included file's parse with the
+accumulated struct-name set and re-parse the root with the full set.
+
+**Spec:** none — `SPEC.md` has no `include` construct; §6.6 defines the prescan
+as "whole-file", which this technically satisfies, but the multi-file design
+intent is clearly violated.
+
+**Verified:** Executed — both snippets above, exact diagnostics quoted.
+
+### FE-2: Root file is never in the visited set — self-include and root↔header cycles duplicate the root
+
+```c
+// selfinc.c02
+include "selfinc.c02";
+u8 g = 1;
+fn main() -> void { }
+// → "redeclaration of 'g'", "redeclaration of 'main'"
+```
+
+`resolveIncludes` seeds the visited map empty; only files *read by the
+resolver* are inserted. The root file's own path is never added, so any include
+chain that reaches the root (directly, or via `a.c02 → b.h → a.c02`) re-reads
+and re-splices the root's declarations. The cycle *does* terminate (the second
+lap finds the intermediate paths visited), but the program then fails analysis
+with spurious `redeclaration` errors for every top-level name in the root. The
+mutual-cycle case (`cyc_a.c02 ↔ cyc_b.h`) reproduces identically.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Executed — both the direct self-include and the two-file cycle.
+
+**Resolved:** threaded includee's file path through to `resolveInclude`, each
+include path and self is canonicalized and then compared for a match. Upon a match
+the newly added `selfIncludeBundle` is emitted and compilation is stopped. Added
+one new test exercising this failure case: `bad_self_include.c02` which attempts
+to include itself and faithfully generates the new error bundle.
+
+### FE-3: No path canonicalization — one file, two spellings, two inclusions
+
+```c
+include "inc/decls.h";
+include "./inc/decls.h";   // same file → "redeclaration of 'P' in this scope"
+```
+
+The visited-set key is the raw candidate path string (`dir </> name`), never
+`canonicalizePath`/`normalise`d. `inc/decls.h` and `./inc/decls.h` (or the same
+file reached via two different `-I` roots, `..` segments, or symlinks) are
+distinct keys, so the pragma-once dedup fails and the declarations duplicate.
+The same non-normalization also leaks into diagnostics (`././inc/decls.h:1:1`).
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Executed.
+
+### FE-4: include-not-found diagnostic loses the include site
+
+```
+nope.h:1:1:
+  |
+1 | <empty line>
+  | ^
+```
+
+`notFoundBundle` positions the error at offset 0 of a fabricated file named
+after the *missing* header, with empty source text. The `Loc` of the `include`
+statement is available in `resolveInclude` but is dropped before
+`resolveCandidates`; the user never learns *which file, which line* did the
+including — painful once headers include headers.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Executed (rendering above; the search-path list does follow it).
+
+### FE-5: Lazy `readFile` lets late I/O errors escape the resolver
+
+`resolveCandidates` does `try (readFile path)`, but `readFile` is lazy: only
+the *open* fails inside the `try`. A read/decode error surfacing while
+`parseProgram` forces the string — the classic case being a byte sequence
+invalid in the locale encoding (e.g. raw `0xFF` in a UTF-8 locale) — is thrown
+outside the `ExceptT` channel and crashes `c02-frontend` with an uncaught
+`IOException` instead of a diagnostic. A strict read (`readFile'` /
+`Data.Text.IO`) or an encoding-fixed read closes both holes.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source — from the `try (readFile path)` shape in
+`Includes.hs:100`; not executed.
+
+### FE-6: Include position within the file is erased
+
+`Program` separates the include list from the declaration list at parse time,
+and `flatten` splices **all** included declarations ahead of **all** of the
+includer's own — an `include` written mid-file or at the bottom behaves as if
+written at the top. Observable consequences are limited today only because
+FE-1 blocks the interesting case (the §4.4 by-value-containment ordering rule
+is judged on the *post-splice* order, but a by-value field of a header struct
+can't parse in the first place). If FE-1 is fixed, this silently changes
+which §4.4 orderings are legal versus what the source text says.
+
+**Spec:** none — undocumented architecture (§4.4's "earlier in the source
+file" was written for a single file).
+
+**Verified:** Source.
+
+### FE-7: No `asm { }` statement
+
+```c
+fn main() -> void {
+  asm { NOP }    // PARSE ERROR: "unexpected 'a', expecting '}'"
+}
+```
+
+SPEC §5.7 defines the `asm` statement normatively (§2 grammar includes
+`asm_stmt`; §1.1 reserves the keyword). This grammar has no production for it —
+`asm` is reserved in the lexer (so it can't even be an identifier) but
+`statementParser` has no branch. `c02-as` deliberately dropped its emitter
+(noted in `generator.c`), so this looks like a chosen removal — but the spec
+was never amended, `__enable_interrupts()` (§4.2, defined as `asm { CLI }`)
+has no stated replacement, and there is no way to express SEI/CLI from source.
+Until `SPEC.md` is amended this is a T deviation, and interrupt-driven
+programs per §4.2 are not writable.
+
+**Spec:** §5.7, §2, §4.2.
+
+**Verified:** Executed.
+
+### FE-8: Char literals — undocumented extension with two lexer quirks
+
+SPEC §1.3 states flatly there are no character literals; this frontend added
+them (`charLiteralParser`, commit `3484cad`). The extension itself needs a spec
+amendment; on top of that:
+
+1. **Not a lexeme.** `charLiteralParser` never consumes trailing whitespace, so
+   any token after a char literal must be *adjacent*:
+
+   ```c
+   u8 c = 'a'+1;    // OK
+   u8 c = 'a' + 1;  // PARSE ERROR: "unexpected space"
+   ```
+
+2. **Haskell escape semantics.** It delegates to megaparsec's `L.charLiteral`,
+   which implements *Haskell* escapes — so `'\65'` (decimal), `'\x41'`, and
+   `'\SOH'`-style names are accepted (`'\65'` compiles to 65, Executed), while
+   `'\q'` is a parse error. String literals follow §1.4 (unknown escape drops
+   the backslash: `"\q"` is `"q"`). The two literal forms disagree about what
+   an escape is.
+
+**Spec:** §1.3 (extension), §1.4 (escape inconsistency).
+
+**Verified:** Executed — all four snippets.
+
+### FE-9: Adjacent operators fail to lex
+
+```c
+i8 c = a*-b;     // PARSE ERROR at '*'
+u8 d = a & ~b;   // OK — but a&~b is a PARSE ERROR
+if (x<-1) { }    // PARSE ERROR
+```
+
+`operator` enforces maximal munch scannerlessly: after matching `*` it demands
+the next char not be in the operator alphabet, so `*-`, `<-`, `&~`, `&&&`
+all fail. A real tokenizer (§1.6, and `cc02`'s) lexes greedily per *token* —
+`*-` is `*` then `-` since `*-` is not a token. Every binary-operator-followed-
+by-unary-operator pairing without whitespace is a spurious parse error.
+(`x=-1` is unaffected: assignment `=` goes through `symbol`, which has no
+guard.)
+
+**Spec:** §1.6 (token set; nothing there makes whitespace significant).
+
+**Verified:** Executed (`a*-b`).
+
+### FE-10: Host-word overflow in integer literals wraps silently
+
+```c
+u8 x = 18446744073709551617;   // ACCEPTED; x == 1 at runtime (2^64 + 1)
+```
+
+SPEC §1.3: a literal overflowing the host word is a **lexer error**. Here
+`L.decimal` accumulates into `Int` and wraps modulo 2^64; the wrapped value
+then passes the §3.4 range check. Confirmed end-to-end: the ROM writes 1.
+
+**Spec:** §1.3.
+
+**Verified:** Executed.
+
+### FE-11: Compound assignment is not type-checked as its desugaring
+
+```c
+u8 x = 5;
+u8 *p = &x;
+p += 1;      // REJECT: "type mismatch in assignment: expected u8*, found u8"
+p = p + 1;   // ACCEPT (§6.3 pointer arithmetic)
+```
+
+§5.3 says `lhs op= rhs` desugars to `lhs = lhs OP rhs`, whose RHS type is the
+*binop result*. `analyzeStmt (Assign lhs _ rhs)` ignores the operator and
+checks `rhs` directly against `lhs`'s type, so any compound assignment whose
+bare RHS isn't already compatible with the LHS is rejected — pointer `+=`
+integer being the everyday casualty. (The *lowering* desugars correctly; only
+the analyzer's check is wrong, so this is pure over-strictness.)
+
+**Spec:** §5.3 + §6.3.
+
+**Verified:** Executed.
+
+### FE-12: The S-1/S-17 laxity was reproduced deliberately — and is undocumented
+
+```c
+Point p = null;   // ACCEPTED (by-value struct from a "pointer")
+u8 q = null;      // ACCEPTED
+void *v = null;
+u8 r = v;         // ACCEPTED (named void* value into a scalar)
+```
+
+`isTypeCompatible` rule 1 is implemented as "a `(Void, 1)` **actual** is
+compatible with anything" — the code comment says this relaxation from §3.2's
+pointer-only rule is deliberate, to match `cc02` (S-1/S-17). But `SPEC.md`
+presents S-1/S-17 as *deviations to be fixed by this rewrite*, and
+`DEVIATIONS_hs_impl.md` doesn't record that they were kept. Downstream,
+`Point p = null;` lowers to a 2-byte copy of constant 0 into the struct
+(partial zero-fill), and `u8 r = v;` truncates a pointer to one byte —
+accepted silently.
+
+Either amend §3.2 rule 1 to the relaxed reading, or restrict the rule to
+pointer-typed `expected` (the type-level inability to distinguish the literal
+`0` from a `void*` value is real, but the *destination* check costs nothing).
+
+**Spec:** §3.2 rule 1 (and the S-1/S-17 write-ups it links).
+
+**Verified:** Executed — all three accept.
+
+### FE-13: `&&` / `||` skip operand checking entirely
+
+```c
+struct Point { u8 x; }
+Point p;
+u8 q = p && p;   // ACCEPTED
+```
+
+`checkBinary` returns `(U8, 0)` for `And`/`Or` before any compatibility check,
+so struct, void-typed, and mixed-signedness operands all pass — every other
+operator rejects them (§3.2's mixed-signedness rule; §6.3). Lowering then
+emits truthiness tests over a struct operand (`TAC_NOT`/`TAC_COND_JUMP` on a
+1-byte read of the struct), i.e. it "works" by testing the first field byte.
+`cc02` runs `&&`/`||` operands through the same compatibility gate as other
+binops; this is laxer than both spec and reference.
+
+**Spec:** §3.2 (signedness note), §6.3.
+
+**Verified:** Executed (accepts); lowering behavior Source.
+
+### FE-14: `interrupt` validation is missing — and the consequence is a runtime crash, not a warning
+
+```c
+fn foo() interrupt -> void { PORTB = 42; }
+fn main() -> void { foo(); PORTB = 7; }
+// Compiles with NO output. At runtime: foo's body runs, then RTI against a
+// JSR frame → PC ends at $0000; PORTB never becomes 7. (Executed in py65.)
+```
+
+§4.2: an `interrupt` function not named exactly `nmi`/`irq` (with `void`
+return, zero params) must produce `WARN_INVALID_INTERRUPT` and compile as an
+*ordinary* function with the flag cleared. This frontend performs **no
+interrupt validation anywhere** (nothing in `Analyze.hs` touches
+`isInterrupt`), and the flag rides through the IR to `c02-as`, which emits the
+PHA/PHX/PHY prologue and PLY/PLX/PLA+RTI epilogue for any flagged function.
+`c02-as` does correctly refuse to put a non-`nmi`/`irq` name in the vector
+table — so the function is *only* reachable by a normal call, which the
+analyzer permits (§4.2/P2-3), and every such call unbalances the hardware
+stack and jumps to garbage. A one-word typo (`fn Nmi() interrupt`) is a silent
+runtime crash instead of the spec's warning.
+
+**Spec:** §4.2.
+
+**Verified:** Executed — compile is silent, run never reaches the halt loop.
+
+**Resolved:** `Analyze.hs`'s `analyzeFunc` now checks `isInterrupt f && not
+(validInterrupt f)` and emits `WARN_INVALID_INTERRUPT`; `validInterrupt`
+(`AST.hs`) is the single source of truth for the three §4.2 conditions
+(name, `void` return, zero params), consumed identically by the call-site
+check, this warning, and both of lowering's `isInterrupt` reads — so an
+invalid tag is now guaranteed cleared before `c02-as` ever sees it, closing
+the FE-14/[CG-6](FINDINGS_codegen.md#cg-6) path from this side. The warning
+is genuinely non-fatal: `Diagnostic.hs` gained a `Severity` (`Warning`/
+`Error`) and `Main.hs` now only fails the build on `Error`-severity
+diagnostics, printing everything regardless — the first diagnostic in this
+frontend that isn't fatal. This also went one step further than the
+original finding: direct calls to a *valid* `nmi`/`irq` (§4.2/P2-3, "currently
+accepted") are now rejected outright (`ERR_INTERRUPT_CALL`), a deliberate
+spec amendment — `SPEC.md` §4.2 no longer says "currently accepted." Pinned
+by `test/analyzer/warn_invalid_interrupt.golden` (the warning, exit 0) and
+`test/analyzer/bad_interrupt_call.golden` (the new error).
+
+### FE-15: `for`-increment clause accepts a declaration
+
+```c
+for (u8 i = 0; i < 3; u8 j = 1) { }   // ACCEPTED; spec grammar: for_incr ::= expr (assign_op expr)?
+```
+
+`forClause` (shared by init and incr) includes `varDeclParser`; §5.5 permits a
+declaration only in `for_init`. The declaration in incr position is then
+re-declared-and-discarded once per iteration by the analyzer's
+`analyzeStmt (LocVarDecl …)` no-op path and lowered as a per-iteration copy —
+accepted, defined-ish behavior, but not the spec's language.
+
+**Spec:** §5.5, §2 grammar.
+
+**Verified:** Executed (accepts and compiles).
+
+### FE-16: Statement-position structs get no redeclaration check
+
+`declLocalStruct` does no same-scope duplicate check: `struct S { u8 a; }`
+twice in one block silently takes the second definition. §7.2 puts structs in
+the shared namespace (and even `cc02` catches same-scope struct redeclaration
+— S-8 notes only the *shadowing* half is missing there). Combined with FE-17
+this means the colliding definitions also fight over one layout slot.
+
+**Spec:** §7.2.
+
+**Verified:** Source.
+
+### FE-17: One name-keyed layout table across all scopes
+
+```c
+struct S { u8 a; u8 b; }
+fn main() -> void { S s; s.a = 1; s.b = 42; PORTB = s.b; }
+fn other() -> void { struct S { u16 pad; u16 waste; } }
+// → codegen: unknown field 'a' on struct 'S'   (exit 3; valid program)
+```
+
+`computeStructLayouts` folds **every** struct site — top-level and
+function-local — into a single `Map String StructLayout` in source order, and
+`lowerModule` serializes that map as *the* module struct table. Codegen
+resolves every field access by name against that table. A local struct that
+shares a top-level struct's name therefore replaces its layout for the entire
+module: with different field names the program dies loudly at codegen (above);
+with the *same* field names at different offsets it compiles silently against
+the wrong layout (self-consistent within one module, but the table also leaks
+into the linked object — see [LD-2](FINDINGS_linker.md#ld-2)). The analyzer,
+meanwhile, resolves the same accesses scope-correctly, so the two stages
+disagree about what `S` means.
+
+**Spec:** none — undocumented architecture (the scoped-name → flat-table
+lowering contract exists nowhere on paper).
+
+**Verified:** Executed (the loud case).
+
+### FE-18: Non-literal global initializers silently lower to "uninitialized"
+
+```c
+u8 g = 2 + 3;
+fn main() -> void { PORTB = g; }   // PORTB == 0 at runtime, not 5 (Executed)
+```
+
+`toGlobal` captures only `IntLit`, `Unary Negate IntLit`, and `StrLit`; every
+other accepted initializer shape — arithmetic, casts (`(u8)300`), `&global`,
+struct initializers — becomes `IRInitNone` with **no diagnostic**. This is
+exactly `cc02`'s P0-5, reproduced; the code comment calls it "a limitation,
+not silently wrong data", but the analyzer accepted the program and the data
+is silently wrong. Either reject non-literal global initializers loudly
+(T-style strictness would at least be visible) or fold/emit them.
+
+**Spec:** §4.5 (which documents P0-5 as a `cc02` deviation this rewrite was
+meant to fix).
+
+**Verified:** Executed.
+
+### FE-19: `++`/`--` on a deref, field, or register never stores back
+
+```c
+u8 x = 41; u8 *p = &x;
+++*p;            // x still 41 (Executed: PORTB reads 41)
+++point.x;       // field still 10 (Executed)
+++PORTB;         // register unchanged (Executed)
+++x;             // plain local: works
+```
+
+`Lower.mutateUnary` lowers the operand as a *value* and emits
+`TAC_INC/TAC_DEC` with that operand as `dst`. For a plain variable the operand
+is the variable itself, so in-place mutation works. For `Deref`, `Field`, or a
+register name, `lowerExpr` produces a **fresh temp holding the loaded value**
+(`TAC_LOAD`/`TAC_FIELD_LOAD`), the increment hits the temp, and no store-back
+is ever emitted. Three of the four lvalue shapes §6.2 requires `++`/`--` to
+support are silent no-ops on memory.
+
+**Spec:** §6.2/§7.3 (`++`/`--` on any lvalue).
+
+**Verified:** Executed — all three broken shapes and the working one.
+
+**Resolved:** changed `lowerExpr` to match on operand type for mutating in place.
+Added 4 emulator tests that test `inc` / `dec` for the various cases.
+
+### FE-20: Nested field assignment stores into a temporary copy
+
+```c
+struct Inner { u8 v; }  struct Outer { Inner in; }
+Outer o = Outer{ .in = Inner{ .v = 1 } };
+o.in.v = 42;
+PORTB = o.in.v;   // reads 1, not 42 (Executed)
+```
+
+`lowerStmt (Assign (Field base f) …)` lowers `base` as a *value*. When `base`
+is itself a field access (`o.in`), that value is a `TAC_FIELD_LOAD` into a
+temp — a byte-copy of the inner struct — and the `TAC_FIELD_STORE` then writes
+into the copy. Any assignment whose target has ≥ 2 `.` levels (on by-value
+structs) is silently lost. Pointer bases (`ptr.field = v` with one auto-deref
+level) are unaffected since the "value" is the pointer.
+
+**Spec:** §6.4 (chained field access), §5.3.
+
+**Verified:** Executed.
+
+**Resolved:** Added pattern matching for field nested assignments which recursively
+lowers each nested assignmnet loading the necessary value and sotring it back in place.
+Added `nested_field_assignment` to emulator tests.
+
+### FE-21: The IR emission contract is implicit and unchecked
+
+What `c02-frontend` promises the consumers (`c02-ld`, `c02-as`), none of it
+written down or validated on either side — this is the inventory, all Source:
+
+- **`nextTemp`/`nextLabel` are load-bearing.** `c02-as` allocates
+  `next_label`-sized arrays and indexes them with instruction label ids
+  unchecked; an id ≥ `next_label` is an out-of-bounds heap write inside the
+  assembler (`Module.hs` even notes "codegen trusts them, so they must be
+  right").
+- **Exactly one block, id 0.** The wire format supports many blocks;
+  the frontend always emits one and no consumer validates block structure.
+- **`TAC_AND`/`TAC_OR`/`TAC_BREAK`/`TAC_CONTINUE` are never emitted** —
+  `&&`/`||` become short-circuit control flow, break/continue become jumps
+  (matching `bin/cc02`); `c02-as` has no cases for these four ops and fails
+  loudly ("unhandled TAC op") if they ever appear.
+- **Operand types are the sizing authority.** Codegen sizes every load/store
+  from the serialized operand type; the frontend inserts explicit `TAC_CAST`s
+  for binop widening but *not* for call arguments or return values (see
+  [CG-5](FINDINGS_codegen.md#cg-5) for the runtime consequence).
+- **Struct identity is by name only**, offsets pre-baked (see FE-17).
+- **Only `__heap_start`/`__memory_top` may survive as extern variables** into
+  `c02-as`; anything else is a codegen-time error, and nothing before codegen
+  checks it (see [LD-7](FINDINGS_linker.md#ld-7)).
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source (each point traced in `Lower.hs`/`Module.hs`/
+`Serialize.hs` and the matching consumer code).
+
+### FE-22: Compiler implicit globals are not injected — and the stdlib header's type disagrees with the spec
+
+```c
+fn main() -> void {
+  PORT16 = __heap_start;   // "undeclared identifier '__heap_start'" (Executed)
+}
+```
+
+§4.6 "Compiler Implicit Globals": `__heap_start` and `__memory_top` (both
+`u16`) "are injected automatically — no `decl` needed, available in every
+translation unit." This frontend injects nothing; the name resolves only if
+the program writes the `decl` itself or picks it up from `libc02`'s
+`stddef.c02h`. With an explicit `decl u16 __heap_start;` the whole pipeline
+works (Executed — reads back the post-allocation RAM address via the
+`c02-as` whitelist, [IR-7](FINDINGS_ir_format.md#ir-7)). Compounding it,
+`bin/include/stddef.c02h` declares `decl u16 *__heap_start;` — a `u16*`,
+where the spec says `u16` — so the *type* a stdlib-linked program sees also
+deviates, and a `u16 h = __heap_start;` against the stdlib header is a type
+mismatch the spec says should compile.
+
+**Spec:** §4.6.
+
+**Verified:** Executed (missing injection; the working `decl u16` control) /
+Source (header type read from `libc02/include/stddef.c02h`).
+
+**Resolved:** The compiler externs can be included through the
+standard library using header `stddef.c02h` to access those values. Codegen
+alread injects the values but only when they are forward decl-ed. See below snippet:
+
+```c
+include "stddef.c02h"
+
+fn main() -> void {
+  PORT16 = __heap_start;
+}
+```
+
+**Resolved (Clarification):** The spec should change to have these values represented as
+u16 pointers as that is their useful form. The original wording was provisional
+and defined before headers were apart of the language.
diff --git a/docs/Deviations/FINDINGS_ir_format.md b/docs/Deviations/FINDINGS_ir_format.md
new file mode 100644
index 0000000..11ef2b4
--- /dev/null
+++ b/docs/Deviations/FINDINGS_ir_format.md
@@ -0,0 +1,254 @@
+# Audit Findings — the IR/TAC object format as a cross-stage contract
+
+**Status:** pinned to `main` @ `6d619f6` (2026-07-17). Cross-cutting companion
+to the per-stage docs ([frontend](FINDINGS_frontend.md),
+[linker](FINDINGS_linker.md), [codegen](FINDINGS_codegen.md)); format follows
+[`DEVIATIONS_hs_impl.md`](../DEVIATIONS_hs_impl.md).
+
+The subject here is the `.o` wire format and its three hand-synchronized
+implementations — writer `c02-frontend/src/C02/Lowering/Serialize.hs`,
+reader+writer `c02-ld/bin/serializer.ml` + `tac.ml`, reader
+`c02-as/src/ir-serial.c` + `ir.h` — asking one question per entry: **what is
+actually guaranteed between stages, what is merely assumed, and where does the
+contract break silently if one side changes?**
+
+Every entry's spec reference is **none — undocumented architecture**:
+`SPEC.md` §Scope restricts itself to language surface and static semantics;
+the object format, its numbering, and its invariants are defined nowhere
+except the three code bases themselves (each carrying "must match X
+byte-for-byte" comments). That absence is itself the meta-finding.
+
+**Verification level**: **Executed** = demonstrated end-to-end at the pinned
+commit; **Source** = traced through two or three of the implementations.
+
+Severity: **P0** silent wrong output · **P1** loud failure ·
+**P2** latent/robustness · **G** quirk.
+
+## Quick Reference
+
+| ID | Sev | Verified | Summary |
+|---|---|---|---|
+| [IR-1](#ir-1) | P2 | Source | Positional enum numbering ×3 implementations; one whole-file version number is the only guard |
+| [IR-2](#ir-2) | P0 | Executed | Length-prefixed strings decay to C strings: embedded NUL, `""`≡absent, non-ASCII truncation |
+| [IR-3](#ir-3) | P2 | Source | "Native endian, native width" is really "x86-64 LP64" — unchecked by any header field |
+| [IR-4](#ir-4) | P2 | Source | Counts and ids are trusted, not validated: `next_label` is an OOB write waiting in `c02-as` |
+| [IR-5](#ir-5) | P2 | Source | Semantic invariants riding on top of the syntax: never-emitted ops, `is_ptr` redundancy, single-block CFGs |
+| [IR-6](#ir-6) | P2 | Source | Struct identity is a bare name with pre-baked layout; a missing table entry silently sizes as 1 byte |
+| [IR-7](#ir-7) | P2 | Source | Extern resolution is a codegen-stage whitelist, not a format or linker concept |
+
+## Entries
+
+### IR-1: Three hand-synchronized copies of positional numbering, one version number
+
+The tags for `tac_op` (37 values), type kind (6), operand kind (5), and init
+kind (3) exist as: a C `enum` (`ir.h`), a Haskell pattern-match table
+(`TAC.hs` — its comment: "This MUST match the order in c02-as/src/ir.h"), and
+an OCaml array (`tac.ml`). All three are positional. The **only** wire-level
+guard is the whole-file pair `magic + ir_version` (currently 3, hardcoded in
+all three places).
+
+Silent-break scenario: an op inserted mid-enum on one side (say a future
+`TAC_ASM` slotted where cc02 had it) renumbers everything after it; every
+`.o` still passes magic/version, and each instruction decodes as a *different
+valid op* — the OCaml side fails only if a tag lands out of range, the C side
+only when the generator's `default:` happens to be hit. Nothing detects
+value-level skew; the failure mode is miscompiled output or a confusing
+far-downstream error, not "format mismatch". Mitigations worth having: bump
+`ir_version` as a ritual for *any* numbering change (currently a convention
+in comments only), and/or a shared generated numbering source, and/or a
+round-trip test (`c02-frontend` → `c02-ld` → `c02-as --dump-ir`) diffing op
+names — the pieces all exist (`--dump-ir` decodes a `.o`), no test wires them
+together.
+
+**Verified:** Source (three-way tag-table diff performed during audit —
+currently in sync).
+
+### IR-2: Length-prefixed on the wire, NUL-terminated in the consumers
+
+The format stores every string as `[u32 len][bytes]` — fully binary-safe. The
+consumers are not:
+
+- **Embedded NUL** (reachable from source: `"ab\0cd"`, §1.4's `\0` escape):
+  `ir-serial.c`'s `read_str` preserves the bytes but returns a bare `char*`;
+  `emit_data_section` then measures with `strlen` and dedups with `strcmp` —
+  data after the first NUL is dropped from ROM and distinct literals coalesce.
+  **Executed**: `*(s+3)` of `"ab\0cd"` reads the `C` of the adjacent "C02S"
+  symbol-table magic ([CG-7](FINDINGS_codegen.md#cg-7)). The length crosses
+  the wire intact and is thrown away at the last hop.
+- **`len == 0` means NULL/absent** in both readers (`read_str` → `NULL`,
+  OCaml `str` → `None`) — so an *empty string literal* is indistinguishable
+  from *no string*. Exactly one consumer site defends against the resulting
+  NULL (`emit_data_section`'s coalesce, with a comment); `u8 *s = "";` works
+  today (Executed) because that's the only path an empty literal reaches, but
+  any new consumer of `str_val`/`name` inherits a latent NULL deref. The
+  OCaml side turns the same length-0 record into `""` via
+  `Option.value ~default` for most fields but `failwith` for others (VAR
+  names, function names) — three different absent-string semantics across the
+  two readers.
+- **Non-ASCII**: the Haskell writer emits `string8` (low byte of each `Char`)
+  with `length` counted in *characters* — any source string outside Latin-1
+  silently mangles (`'€'` → byte `0xAC`), and even Latin-1 survives only
+  byte-per-char by accident. Neither reader can detect it.
+
+The contract should say: strings are byte sequences with explicit length,
+NULs legal (then fix `emit_data_section` to use the length), or: strings are
+NUL-free ASCII (then the *frontend* must reject `\0` escapes and non-ASCII
+loudly). Today each implementation assumes a different one of these.
+
+**Verified:** Executed (NUL truncation, `""` path) / Source (non-ASCII,
+NULL-propagation inventory).
+
+### IR-3: "Native endian, native width" actually means x86-64 LP64
+
+All three implementations note the format is native-endian/native-width for
+same-machine reuse. But the *widths* aren't native-symmetric:
+
+- The Haskell writer commits to **little-endian** explicitly (`word32LE`,
+  `int64LE`) — on a big-endian host it would emit LE while the C reader
+  `fread`s native, a silent value-scramble that magic (`0x43303249` read
+  reversed = fails) would luckily catch, but only via an "Invalid object
+  file" with no hint why.
+- The C reader reads the 8-byte fields into `unsigned long`/`long`
+  (`read_u64`/`read_i64`) — **LP64-only**. On any LLP64 or 32-bit target
+  (`long` = 4 bytes) `fread(v, 8, 1, f)` overflows the destination: stack
+  corruption, not a format error.
+- The OCaml reader narrows `Int64.to_int` (63-bit) silently; irrelevant for
+  real 6502 addresses, but a garbage `.o` wraps instead of failing.
+
+No header field records endianness or word size, so none of this is
+*checkable* — the comments are the enforcement mechanism. One `u8`
+endianness/width byte after the version, validated by both readers, converts
+all of these from silent/UB to loud.
+
+**Verified:** Source.
+
+### IR-4: Counts and ids cross the wire unvalidated
+
+The readers trust every count and id, and the *consumers* assume invariants
+the format never states:
+
+- **`cfg.next_label`** — `c02-as` allocates `next_label * sizeof(uint16_t)`
+  (`emit_function_from_cfg`) and indexes it with each instruction's raw
+  `label` field, unchecked. A writer bug (or hand-edited `.o`) with
+  `label >= next_label` is an out-of-bounds heap **write** (in
+  `TAC_LABEL`) / read (jumps) inside the assembler. The frontend comment
+  "codegen trusts them, so they must be right" is the entire contract.
+- **`next_temp`** is similarly trusted but happens to be harmless today (ZP
+  slots come from a fixed-size map with its own bounds check).
+- **Sequence counts** (`instr_count`, `call_arg_count`, section counts)
+  multiply directly into arena allocations; garbage counts on truncated files
+  fail cleanly (`fread` short-read → `goto fail`) *before* most damage, but a
+  huge count with enough trailing bytes just exhausts memory
+  (`arena_alloc` → `exit(1)`).
+- **Tag ranges**: OCaml validates every tag (`failwith "bad tac_op"`, "bad
+  operand kind", "bad type kind"). C validates **none** — `op->kind` and
+  `ins->op` are cast from raw `u32`; an unknown operand kind falls through
+  `read_operand`'s switch and **returns success with an uninitialized union**
+  (no `default`), deferring to whatever the generator does with garbage. The
+  two readers disagree about whether the reader is a validation boundary.
+
+Given the linker also re-*writes* the format, `c02-ld` is the natural
+choke-point to make these loud (it already fails on bad tags); `c02-as` needs
+at minimum the `label < next_label` check, which is one comparison per
+control-flow instruction.
+
+**Verified:** Source.
+
+### IR-5: Semantic invariants that ride on top of the syntax
+
+Things every consumer assumes about a *well-formed* module that the format
+neither expresses nor checks — each one a silent seam if the writer changes:
+
+- **Four ops are dead on the wire.** `TAC_AND`, `TAC_OR`, `TAC_BREAK`,
+  `TAC_CONTINUE` exist in all three enums; the frontend never emits them
+  (`&&`/`||` lower to short-circuit control flow matching `bin/cc02`;
+  break/continue become jumps), and the generator has **no cases** for them —
+  emitting one produces "codegen: unhandled TAC op" at the last stage rather
+  than a format-level error at the first. A frontend contributor who "just
+  uses TacAnd" gets a working `.o` that fails only under `c02-as`.
+- **`is_ptr` duplicates `ptr_depth`** — and the sides disagree about which is
+  authoritative. The OCaml reader discards `is_ptr` (recomputes from depth);
+  the C side stores both and **sizes by `is_ptr`** (`codegen_type_size`
+  checks `type.is_ptr` first). A writer emitting `is_ptr=0, ptr_depth=1`
+  (trivial bug — the Haskell writer derives `is_ptr` from depth today) gives
+  OCaml a pointer and C a 1-byte scalar: the same `.o` means two different
+  programs to the two consumers. Either drop `is_ptr` from the format
+  (version bump) or have readers reject disagreement.
+- **CFGs have exactly one block, id 0.** The format supports arbitrary
+  blocks; `successors` is explicitly not serialized ("rebuild from
+  terminators after load" says `tac.ml`) and *nobody rebuilds it* —
+  the generator walks blocks linearly and resolves labels flat, which is
+  only correct because block boundaries carry no meaning in today's
+  single-block modules. Multi-block emission (the frontend's own "CFG
+  carving" is a stated next step) will work by accident or break subtly
+  depending on emission order, with no format-level statement of which.
+- **Instruction shape is "fat"**: every field present for every op, absent =
+  empty form (0-length string, zeroed type, `OPERAND_NONE`). This one *is*
+  consistently implemented in all three — worth writing down as the rule new
+  fields must follow (append-only, always-present), because the first
+  conditionally-present field will desync readers that don't branch
+  identically.
+
+**Verified:** Source (each point traced in at least two implementations).
+
+### IR-6: Struct identity is a bare name with pre-baked layout
+
+The format carries struct layouts (name, fields, offsets, total size) *and*
+struct-typed operands that reference them **by name only**. Consequences:
+
+- Offsets/sizes are computed once, by the frontend, and consumed verbatim —
+  `c02-as` never recomputes (by design: "codegen never recomputes a layout",
+  `TAC.hs`). So the layout table is load-bearing for every field access and
+  every struct-sized copy, but nothing ties an *operand's* struct name to a
+  *table entry's* existence.
+- If the name lookup misses, `full_type_size` in `c02-as` silently returns
+  **1** (its scalar default) — a struct-typed temp gets a 1-byte ZP slot and
+  copies collapse to a byte, with no diagnostic. Today the frontend always
+  emits an entry for every name it uses; the case is reachable the moment the
+  emission set and the use set are computed by different code (exactly what
+  [FE-17](FINDINGS_frontend.md#fe-17)'s name-collision handling will touch).
+  `lookup_struct_field` *does* fail loudly — so field access is guarded, but
+  sizing is not: the two lookups have different failure semantics on the same
+  missing entry.
+- Because identity is the bare name, scoping is unexpressable: function-local
+  structs serialize under their source name and collide in the linker's flat
+  dedup ([LD-2](FINDINGS_linker.md#ld-2)), and the same-name-different-layout
+  case inside one module is resolved by silent map-overwrite before
+  serialization even happens (FE-17). The format would need scoped/mangled
+  names (or per-CFG tables) to represent what the language allows.
+
+**Verified:** Source (fallback path `generator.c:60-68`; collision behavior
+Executed under FE-17/LD-2).
+
+### IR-7: Extern resolution is a codegen-stage whitelist, not a format concept
+
+The `externs` section is the format's entire cross-TU story, and its
+consumption is asymmetric in ways no document states:
+
+- `c02-ld` resolves externs against definitions (loudly checking signatures)
+  and passes *unresolved* ones through — for **any** link, there being no
+  format distinction between a relocatable and a final object
+  ([LD-7](FINDINGS_linker.md#ld-7)).
+- `c02-as` then consumes externs via `emit_compiler_extern_inits`: extern
+  **variables** are checked against a hardcoded whitelist
+  (`__heap_start`, `__memory_top` — the §4.6 "compiler implicit globals") and
+  anything else is a loud error; extern **functions** are skipped entirely
+  and surface only if a call site's JSR fixup fails to resolve — a declared,
+  never-called extern function vanishes silently (legitimate, but nowhere
+  stated).
+- So the answer to "which stage guarantees all symbols resolve?" is: *no
+  single stage* — variables at codegen unconditionally, functions at codegen
+  only-if-called, and the linker never. The compiler-implicit globals
+  themselves (§4.6 says "injected automatically — no `decl` needed") are in
+  fact **not injected** by this frontend: they work only if the program
+  writes `decl u16 __heap_start;` itself or links `libc02` (whose header
+  does — with the wrong type; see
+  [FE-22](FINDINGS_frontend.md#fe-22), Executed), a frontend/spec gap that
+  happens to be *observable* purely through this extern pathway.
+
+Worth one paragraph in a real format spec: the externs section's lifecycle,
+who may leave it non-empty, and the whitelist. Today that knowledge lives in
+one C function and this document.
+
+**Verified:** Source (whitelist `generator.c:1868-1890`; linker pass-through
+Executed in the `unresolved_extern_partial` suite case).
diff --git a/docs/Deviations/FINDINGS_linker.md b/docs/Deviations/FINDINGS_linker.md
new file mode 100644
index 0000000..c4e63ec
--- /dev/null
+++ b/docs/Deviations/FINDINGS_linker.md
@@ -0,0 +1,246 @@
+# Audit Findings — `c02-ld` (OCaml)
+
+**Status:** pinned to `main` @ `6d619f6` (2026-07-17). Companion to
+[`FINDINGS_frontend.md`](FINDINGS_frontend.md) /
+[`FINDINGS_codegen.md`](FINDINGS_codegen.md) /
+[`FINDINGS_ir_format.md`](FINDINGS_ir_format.md); format follows
+[`DEVIATIONS_hs_impl.md`](../DEVIATIONS_hs_impl.md).
+
+`SPEC.md` defines language semantics only — it never mentions a linker beyond
+one sentence in §7.4 (entry-point existence is "enforced by the linker/driver").
+Nearly every entry here is therefore **none — undocumented architecture**;
+where a finding touches §4.6 (`decl`) or §7.4 it is cited.
+
+**Verification level**: **Executed** = reproduced with `bin/c02-frontend` +
+`bin/c02-ld` at the pinned commit; **Source** = read from
+`c02-ld/bin/*.ml`, not executed.
+
+Severity: **T** over-strict rejection · **P0** silent wrong output ·
+**P1** loud failure on a reasonable program · **P2** latent gap · **G** quirk.
+
+## Quick Reference
+
+| ID | Sev | Verified | Summary | Spec section |
+|---|---|---|---|---|
+| [LD-1](#ld-1) | T | Executed | Extern dedup compares parameter *names*: identical `decl`s with different param names conflict | [§4.6](../SPEC.md#46-forward-declarations-decl) |
+| [LD-2](#ld-2) | T | Executed | Function-local structs leak into the module struct table and collide cross-module | none — undocumented architecture |
+| [LD-3](#ld-3) | G | Source | Cross-kind conflict diagnostics name the wrong kind | none — undocumented architecture |
+| [LD-4](#ld-4) | P2 | Source | Registers cannot be forward-declared across modules | [§4.6](../SPEC.md#46-forward-declarations-decl) / [§4.3](../SPEC.md#43-registers-reg) |
+| [LD-5](#ld-5) | P2 | Source | `List.init` over a mutating cursor depends on left-to-right application order | none — undocumented architecture |
+| [LD-6](#ld-6) | P2 | Source | The linker validates only the symbol *table*, never instruction operands | none — undocumented architecture |
+| [LD-7](#ld-7) | — | Source | "Full link" is not a linker concept: finality lives in `c02-as`, `-c` only in the driver | [§7.4](../SPEC.md#74-main) |
+| [LD-8](#ld-8) | — | Source | Test-suite coverage gaps: the 19 cases vs. what the seams actually need | none — undocumented architecture |
+
+## Entries
+
+### LD-1: Extern-vs-extern dedup compares parameter names
+
+```c
+// m1.c02                          // m2.c02
+decl fn send(u8 a) -> void;        decl fn send(u8 b) -> void;
+fn use1() -> void { send(1); }     fn use2() -> void { send(2); }
+```
+```
+$ c02-ld m1.o m2.o -o out.o
+Fatal error: exception Failure("Conflicting externs")     # rc=2
+```
+
+`combine` resolves two externs with `if e1 = e2 then a else failwith …` —
+OCaml structural equality over the whole record, whose `extern_params` are
+`named_type` triples **including the parameter name**. Two `decl`s of the same
+function that differ only in a param name are spuriously rejected whenever the
+definition isn't in the same link (the moment a definition is present, the
+extern-vs-def path correctly strips names via `param_types`). Param names in a
+`decl` are documentation; §4.6's cross-TU intent clearly wants signature
+equality. Renaming a parameter in a header that not all TUs re-pull, or two
+authors writing the same prototype independently, breaks the link. With
+identical spellings the same link succeeds (Executed control).
+
+**Fix:** compare `(extern_is_func, extern_name, extern_type,
+param_types extern_params)` — the same projection the def path already uses.
+
+**Spec:** §4.6.
+
+**Verified:** Executed — both the reject and the same-name control.
+
+### LD-2: Function-local structs leak into the module struct table and collide cross-module
+
+```c
+// s1.c02                         // s2.c02
+fn f() -> void {                  fn g() -> void {
+  struct Local { u8 a; }            struct Local { u16 b; }
+}                                 }
+```
+```
+$ c02-ld s1.o s2.o -o out.o
+Fatal error: exception Failure("Struct: Local redeclaration")   # rc=2
+```
+
+The frontend's module struct table contains every struct laid out anywhere in
+the TU, including statement-position structs (SPEC §4.4 explicitly allows
+those; see [FE-17](FINDINGS_frontend.md#fe-17)). `dedup_structs` treats the
+table as a flat global namespace: same name + different shape = hard conflict.
+Two modules whose *private, function-scoped* structs happen to share a name
+therefore cannot be linked — a scoping violation the language definition never
+implies. Same-name-same-shape locals silently dedup to one entry, which is
+also wrong in principle (they're distinct types) but benign given layout
+equality.
+
+The right fix is upstream (don't serialize function-local layouts under bare
+names — mangle or scope them); the linker seam is where it detonates.
+
+**Spec:** none — undocumented architecture (struct table semantics are
+specified nowhere).
+
+**Verified:** Executed.
+
+### LD-3: Cross-kind conflict diagnostics name the wrong kind
+
+`combine`'s extern-vs-def arm ends in catch-alls:
+a **function** extern resolved against a `Reg` or `Global` reports
+"declared as function, defined as variable" (even when the def is a register);
+a **variable** extern resolved against a `Func` or `Reg` reports
+"declared as variable but defined as a register" (even when the def is a
+function). The rejects themselves are correct — only the diagnostic text lies,
+and none of these messages name the symbol or the offending files. Worth
+fixing alongside LD-1 since it's the same match.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source (`link.ml:39-52`); the func-vs-var and var-vs-reg test
+cases pass because only the exit code is asserted.
+
+### LD-4: Registers cannot be forward-declared across modules
+
+There is no `decl reg` form (§4.6 offers only `decl fn` and `decl type name`),
+and a plain `decl u8 PORTB;` against another module's
+`reg u8 PORTB @ 0x6000;` hits `combine`'s variable-extern arm, which accepts
+only `Global` — a `Reg` def is a hard failure. Consequence: every TU that
+touches a hardware register must repeat the full `reg … @ addr;` line
+(tolerable — identical regs dedup), but the address is then duplicated source
+truth in N files, and one edited copy becomes an intentional-looking
+"Conflicting registers" error. Undocumented as a design decision; §4.6's
+"intended for cross-translation-unit references" reads as if `decl` covered
+all shared names.
+
+**Spec:** §4.6 / §4.3 (silent on the interaction).
+
+**Verified:** Source.
+
+### LD-5: `List.init` over a mutating cursor depends on application order
+
+`serializer.ml` reads every sequence as
+`List.init count (fun _ -> read_x cursor)` — the element reader *mutates the
+cursor*, so decoding is only correct if `List.init` applies `f 0, f 1, …` in
+ascending order. The file's own header RULE ("never put two cursor reads in
+the same tuple — OCaml leaves evaluation order unspecified") names exactly
+this hazard and then relies on `List.init`'s ordering, which the stdlib
+documentation only pinned down in recent releases (current 5.x applies in
+order; older manuals left it unspecified, and the historic implementation
+switched strategies at a length threshold). It works on the toolchain's OCaml
+(5.5), and probably everywhere — but it's the one place the wire decode
+depends on library behavior rather than written sequencing. Cheap to make
+explicit (a `let rec` loop or `List.init` → `Array.init`+`to_list` with a
+comment).
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source.
+
+### LD-6: The linker validates the symbol table, never the instructions
+
+`link` reconciles the *declared* namespace (externs/globals/regs/cfgs) and
+dedups structs — it never walks a single instruction. Consequences it
+therefore cannot catch, all deferred (at best) to `c02-as`:
+
+- an `OPERAND_VAR` naming a symbol that exists in no module (can't come from
+  this frontend, but the linker is the merge point where a hand-built or stale
+  `.o` would be caught — it isn't);
+- a `TAC_CALL` to a name that is neither a CFG nor an extern (caught later,
+  loudly, by `resolve_func_fixups` — but only if codegen runs);
+- struct-typed operands whose struct name is missing from the merged table
+  (codegen's `full_type_size` then silently sizes the type as **1 byte** —
+  see [IR-6](FINDINGS_ir_format.md#ir-6));
+- label ids ≥ the CFG's `next_label` (an out-of-bounds write inside `c02-as`,
+  [FE-21](FINDINGS_frontend.md#fe-21)).
+
+A linker is the natural place for these whole-program checks; today it is
+purely a namespace merger.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source.
+
+### LD-7: "Full link" is not a linker concept
+
+`c02_ld.ml` always emits a relocatable object and never requires `main` —
+deliberately (the comment cites §7.4; entry-point existence is enforced by
+`c02-as`'s `emit_call_main`, the only stage that produces an executable).
+`-c` exists only in the **driver** (`c02c`), where it merely stops the
+pipeline after `c02-ld`. Two undocumented consequences:
+
+1. §7.4's sentence "existence … is a whole-program property, enforced by the
+   linker/driver" is now *false for the linker half* — the enforcement point
+   is the generator. (The per-memory note: analyzer checks signature only,
+   generator checks existence, linker checks neither.)
+2. Unresolved externs pass a *final* link exactly as they pass a partial one.
+   The safety net is `c02-as`: unresolved extern **functions** fail loudly
+   only if actually called (`resolve_func_fixups`), and unresolved extern
+   **variables** fail loudly because `emit_compiler_extern_inits` whitelists
+   only `__heap_start`/`__memory_top` and rejects everything else. That
+   whitelist is the entire cross-stage contract for extern variables, and it
+   lives in the codegen stage, not the link stage.
+
+Not a bug today — but the division of responsibility exists only in code
+comments and this document, and `SPEC.md` §7.4 should be amended to match.
+
+**Spec:** §7.4 (stale wording).
+
+**Verified:** Source (behavior consistent with the `library_no_main` /
+`unresolved_extern_partial` test cases, which exercise the partial path only).
+
+### LD-8: Test-suite coverage vs. the actual seams
+
+The 19 cases in `test/linker/tests/` pin one instance of each *kind* of
+merge/reject; the seams found above sit precisely in the combinations they
+skip. Gaps worth closing, in rough value order:
+
+1. **Diamond include** — the single most common real topology: the same
+   `decl` (via a shared header) in *two* modules plus the definition in a
+   third. Exercises the extern≡extern fold *and* extern-vs-def in one link,
+   and would have caught LD-1 the day a header's param name drifted. No case
+   has more than two modules.
+2. **Extern dedup with differing param names** (LD-1) — the reject that
+   shouldn't be.
+3. **Local structs across modules** (LD-2) — both the same-shape (should
+   link; arguably shouldn't share an entry) and different-shape (currently a
+   reject of a valid program) variants.
+4. **Both-tentative merge**: `u8 g;` in two modules with *no* initializer
+   anywhere (`IRInitNone`+`IRInitNone`) — the one `combine` global arm no
+   case reaches (`global_tentative_merge` covers None+Init only).
+5. **Full (non-`-c`) link with an unresolved extern** — asserting the
+   *generator's* loud failure, since that's where LD-7 says the net is; and
+   the extern-function-declared-but-never-called variant, which links and
+   generates silently by design (worth pinning as intended).
+6. **Struct/symbol namespace independence**: a struct named `foo` in one
+   module, a function `foo` in another — legal today (separate namespaces in
+   the linker, though *not* per-TU in the frontend, §7.2); untested either
+   way, and a behavior change here would be silent.
+7. **`decl` variable vs. `reg` definition** (LD-4) — pin the current reject
+   as intended or fix it; today it's neither tested nor documented.
+8. **Same `.o` linked twice** — currently a loud `Redefined function`, which
+   is fine, but untested; and **registers at the same address under different
+   names** (aliasing, currently allowed silently — probably fine for
+   hardware, worth pinning).
+9. **`is_interrupt` across the linker** — no case links an interrupt handler
+   from a secondary module and runs it; the flag round-trips (Source) but
+   nothing pins it.
+
+None of these require new machinery — every one fits the existing
+`spec`-directive format.
+
+**Spec:** none — undocumented architecture.
+
+**Verified:** Source (suite read; gaps 1–4 cross-checked against the
+`combine`/`dedup_structs` code paths they would exercise; LD-1/LD-2 gap
+instances Executed above).
diff --git a/docs/Deviations/FIX_PRIORITY.md b/docs/Deviations/FIX_PRIORITY.md
new file mode 100644
index 0000000..b465d77
--- /dev/null
+++ b/docs/Deviations/FIX_PRIORITY.md
@@ -0,0 +1,180 @@
+# Fix Priority — the P0/P1 subset of the toolchain audit
+
+**Status:** pinned to `main` @ `6d619f6` (2026-07-17). Condensed from the four
+full audit docs — [frontend](FINDINGS_frontend.md) /
+[linker](FINDINGS_linker.md) / [codegen](FINDINGS_codegen.md) /
+[IR format](FINDINGS_ir_format.md) — which together carry 50 entries across
+every severity. This doc keeps only the **P0** (silent miscompile) and **P1**
+(loud crash/failure on a reasonable program) entries: 11 P0 + 3 P1 = 14 source
+findings, grouped into **9 root causes** below since several findings are the
+same bug observed from two ends of the pipeline.
+
+Nothing here is new analysis — every entry links back to its full write-up
+(exact repro, expected vs. actual, code path). This doc only reorders and
+groups for triage. Ordered by blast radius: how much ordinary code the bug
+can hit, not how hard the fix is.
+
+## 1. Struct-by-value has no real ABI
+
+**[CG-1](FINDINGS_codegen.md#cg-1)**, **[CG-2](FINDINGS_codegen.md#cg-2)** — both P0, Executed.
+
+`codegen_type_size()` returns a hardcoded **1** for any struct type — it only
+knows scalars and pointers. Struct **returns** copy 1 byte into the 2-byte RET
+slot; struct **parameters** copy 1 byte out of the 2-byte ABI slot. Any struct
+with more than one meaningful byte, passed or returned by value, silently
+loses everything past the first field. CG-2's single-param repro *passes by
+accident* (ZP slot aliasing) — this can already be live in code that "works"
+today for the wrong reason.
+
+**Fix direction:** structs by value need real storage (RAM scratch or a
+hidden out-pointer) — the 2-byte RET/ABI slots can never carry them. Until
+that lands, the analyzer should reject struct-by-value params/returns loudly
+rather than accept and truncate.
+
+## 2. Zero-extension where sign-extension is required
+
+**[CG-5](FINDINGS_codegen.md#cg-5)** — P0, Executed (2 of 3 paths) / Source (1 of 3).
+
+`emit_load_byte` always zero-extends past an operand's width. Correct for
+unsigned widening, and masked for ordinary scalar binops (the frontend inserts
+sign-correct `TAC_CAST`s there) — but three paths skip the cast entirely:
+pointer arithmetic with a signed offset, call arguments into a wider signed
+parameter, and return values narrower than the declared return type. A
+negative `i8` offset, argument, or return value is silently reinterpreted as
+a large positive number. This is ordinary signed arithmetic across a function
+boundary — not an edge case.
+
+**Fix direction:** the header comment in `generator.c:25` already names the
+fix — insert `TAC_CAST` at these three sites, matching what scalar binops
+already get.
+
+## 3. Pointer comparisons read a byte codegen never wrote
+
+**[CG-3](FINDINGS_codegen.md#cg-3)** — P0, Executed.
+
+Comparison emitters write one boolean byte (`STA dst_zp`); the frontend types
+the destination as the *pointer's* width (2 bytes) whenever either operand is
+a pointer. The next consumer (`TAC_NOT`, `TAC_COND_JUMP`) reads both bytes and
+`ORA`s in whatever stale value occupied the never-written high byte. Branch
+outcome for `p == null`, `p != q`, `while (p < end)` depends on ZP residue —
+one unrelated global flipped a real test from 222 to 111. On real hardware
+(random ZP at power-on) this is nondeterministic control flow on *any*
+pointer comparison.
+
+**Fix direction:** either comparison emitters zero the full destination width,
+or the frontend types comparison results `(U8, 0)` uniformly regardless of
+operand type.
+
+## 4. Lvalues get loaded into a temp instead of stored through
+
+**[FE-19](FINDINGS_frontend.md#fe-19)**, **[FE-20](FINDINGS_frontend.md#fe-20)** — both P0, Executed.
+**[CG-4](FINDINGS_codegen.md#cg-4)** — P1, Executed — same root pattern, different consequence.
+
+`Lower.hs` lowers a deref/field/register operand as a *value* before
+mutating or storing into it. `++*p`, `++point.x`, `++PORTB` increment a
+loaded temp and never write back (FE-19); `o.in.v = 42` on a chained
+by-value field stores into a temp copy of `o.in` (FE-20) — both silent no-ops
+on the actual memory. The same pattern reaches `c02-as`: `&p.y` lowers its
+base as a temp, so `TAC_ADDR_OF`'s `src1` is an `OPERAND_TEMP` whose
+`.name` field aliases `.temp_id` in the operand union — `strcmp` dereferences
+a forged pointer and segfaults the compiler outright (CG-4) whenever a global
+exists to trigger the lookup path; with no globals it "succeeds" by returning
+the address of the temp, silently wrong instead of crashing.
+
+**Fix direction:** all three are the same missing case in `Lower.hs` —
+`Deref`/`Field`/register operands need to lower to an **address**, not a
+loaded value, whenever they're a mutation target (`++`/`--`, assignment LHS,
+or the operand of `&`).
+
+## 5. `interrupt` is unimplemented at both ends
+
+**[FE-14](FINDINGS_frontend.md#fe-14)** — P0, Executed. **[CG-6](FINDINGS_codegen.md#cg-6)** — P0, Executed.
+
+§4.2 requires the analyzer to warn and clear the flag on any `interrupt`
+function not named exactly `nmi`/`irq`; nothing in `Analyze.hs` touches
+`isInterrupt` at all, so the flag rides through unconditionally. On the
+codegen side, every flagged function gets an RTI epilogue — correct only for
+real hardware interrupt entry. A normal `JSR` call to *any* interrupt-flagged
+function (a typo'd name, or a valid `nmi`/`irq` handler called directly, both
+analyzer-accepted) executes RTI against a call frame: it pops the JSR return
+address as if it were a status register and jumps to a garbage PC. One typo
+turns into a runtime crash with a silent, warning-free compile.
+
+**Fix direction:** frontend needs the §4.2 validation (warn + clear the flag
+off-vector); codegen's RTI epilogue is fine once nothing miscategorized can
+reach it via `JSR`.
+
+## 6. Non-literal global initializers vanish
+
+**[FE-18](FINDINGS_frontend.md#fe-18)** — P0, Executed.
+
+`toGlobal` only recognizes a bare int literal, a negated int literal, or a
+string literal as a global initializer. Anything else the analyzer accepts —
+`u8 g = 2 + 3;`, a cast, `&other_global`, a struct initializer — silently
+becomes "uninitialized" with **no diagnostic**. This is `cc02`'s documented
+P0-5, reproduced rather than fixed by the rewrite.
+
+**Fix direction:** either constant-fold accepted initializer shapes at lower
+time, or reject non-literal global initializers loudly (a T-severity
+deviation is strictly better than a silent one).
+
+## 7. String literals decay through `strlen`/`strcmp`
+
+**[CG-7](FINDINGS_codegen.md#cg-7)** — P0, Executed. Root cause is
+**[IR-2](FINDINGS_ir_format.md#ir-2)** (Source): the wire format carries
+strings length-prefixed and binary-safe; `emit_data_section` throws the
+length away and re-measures with `strlen`.
+
+`"ab\0cd"` (a valid §1.4 literal) truncates in ROM at the embedded NUL;
+reading past it returns whatever byte follows in the image (observed: the `C`
+of the adjacent symbol-table magic). `strcmp`-based dedup also coalesces any
+two literals that agree up to their first NUL. The `""` case is fine — the
+one place a NULL/empty-length string is explicitly handled.
+
+**Fix direction:** `emit_data_section` (and the dedup comparison) need to use
+the length the wire format already carries instead of C-string primitives.
+
+## 8. Include cycles duplicate the root file
+
+**[FE-2](FINDINGS_frontend.md#fe-2)** — P1, Executed.
+
+The include resolver's visited-set starts empty and only files *read by the
+resolver* are ever inserted — the root file's own path is never added. Any
+include chain that loops back to the root (direct self-include, or a
+root↔header mutual cycle) re-splices the root's own declarations on top of
+themselves, and the program fails with spurious `redeclaration` errors for
+every top-level name. Termination is fine; the diagnostics are just wrong,
+on a program whose only mistake was an include cycle.
+
+**Fix direction:** seed the visited set with the root file's own path before
+resolution starts.
+
+## 9. One struct-layout table, keyed by bare name, across every scope
+
+**[FE-17](FINDINGS_frontend.md#fe-17)** — P1, Executed.
+
+`computeStructLayouts` folds every struct definition in a module — top-level
+*and* function-local — into a single name-keyed map; the analyzer resolves
+field accesses scope-correctly, but codegen's module struct table only has
+room for one `S`. A function-local `struct S` with different fields than the
+top-level `S` clobbers the layout for the whole module: with different field
+names this is a loud, confusing codegen-stage error ("unknown field 'a' on
+struct 'S'") on an otherwise-valid program; with the same field names at
+different offsets it's silently wrong instead. (The same flat table also
+leaks into the linker — [LD-2](FINDINGS_linker.md#ld-2).)
+
+**Fix direction:** struct identity needs to be scope-qualified (mangled name
+or per-function table), not a bare source name, before it's serialized.
+
+---
+
+## What's deliberately not here
+
+The other 36 entries (6 T, 7 G, 21 P2, 2 architecture-note) are real and worth
+reading in the full docs, but none of them produce wrong output on ordinary
+code without an unusual trigger (a ~32KB-exact ROM, a >255-byte struct behind
+a pointer, an interrupt-driven concurrent access, a non-Latin-1 string
+literal, etc.) — that's what makes them P2 rather than P0. **[LD-8](FINDINGS_linker.md#ld-8)**
+is worth a second look separately: it's a prioritized list of test-suite gaps,
+not a bug, and the top item (diamond-include topology) would have caught
+LD-1 automatically.
diff --git a/docs/SPEC.md b/docs/SPEC.md
index 43d5815..0ee6e89 100644
--- a/docs/SPEC.md
+++ b/docs/SPEC.md
@@ -406,10 +406,14 @@ fn irq() interrupt -> void { ... }
 - `irq()` is maskable (`__enable_interrupts()`, a compiler builtin
   implemented as `asm { CLI }`, must be called before it fires); `nmi()` is
   non-maskable.
-- Calling `nmi()`/`irq()` directly like an ordinary function
-  (`irq();`) is **currently accepted** by the analyzer with no check that
-  the callee is an interrupt handler — see
-  [P2-3](DEVIATIONS_c_impl.md#p2-3-interrupt-handlers-can-be-called-directly).
+- Calling `nmi()`/`irq()` directly like an ordinary function (`irq();`) is
+  an **error** (`ERR_INTERRUPT_CALL`). An interrupt handler's epilogue
+  assumes the hardware stack frame a real IRQ/NMI entry leaves behind; a
+  direct `JSR` into one doesn't leave that frame, so the call is rejected
+  outright rather than allowed to corrupt control flow at runtime. `cc02`
+  accepts this construct with no check — see
+  [P2-3](DEVIATIONS_c_impl.md#p2-3-interrupt-handlers-can-be-called-directly)
+  — this rewrite deliberately does not reproduce that gap.
 
 ### 4.3 Registers (`reg`)
 
@@ -493,12 +497,11 @@ decl u8 counter;
 > `decl fn irq() interrupt -> void;` parses, but the `interrupt` qualifier
 > is silently discarded — the AST has no field to store it.
 
-#### Compiler Implicit Globals
+#### Compiler Globals
 
-`__heap_start` and `__memory_top` (both `u16`) are injected automatically —
-no `decl` needed, available in every translation unit. See the main repo's
-`README.md` for their exact values (a codegen/runtime detail, out of scope
-here).
+`__heap_start` and `__memory_top` (both `u16 *`) are defined in `stddef.c02h`.
+See the main repo's `README.md` for their exact values (a codegen/runtime detail,
+out of scope here).
 
 ---
 
@@ -969,6 +972,7 @@ unlike the parser — §8.3).
 |---|---|
 | `ERR_UNDECLARED_IDENTIFIER` | Identifier (value use or call target) not found in any visible scope. |
 | `ERR_NOT_A_FUNCTION` | Call target resolves to a non-function symbol. |
+| `ERR_INTERRUPT_CALL` | Call target is a valid `interrupt` function (§4.2) — direct calls are rejected. |
 | `ERR_UNKNOWN_STRUCT` | A struct-typed name doesn't resolve to a registered struct (declared type, cast target, struct-init target). |
 | `ERR_REDECLARATION` | Same name inserted twice into one scope frame (§7.2). |
 | `ERR_SHADOWED_DECLARATION` | A local var/param reuses a name visible in an enclosing scope (§7.2). |
diff --git a/scripts/test.py b/scripts/test.py
index 4adfb72..4a0ad68 100755
--- a/scripts/test.py
+++ b/scripts/test.py
@@ -6,16 +6,26 @@
 #   test/<stage>/*.c02           inputs, one program per file
 #   test/<stage>/golden/*.golden expected stdout, one <name>.golden per input
 #
+# Most stages compile a single source file directly; "codegen" runs the full
+# c02c pipeline (frontend -> linker -> c02-as) instead, since codegen has no
+# standalone entry point of its own.
+#
 # Each case is compiled through the c02c driver and matched against a committed
-# golden. Cases come in two flavours, distinguished by filename:
+# golden. Cases come in three flavours, distinguished by filename:
 #
-#   * positive (any name)  - must parse: exit 0, AST printed to stdout.
+#   * positive (any name)   - must parse: exit 0, AST printed to stdout.
 #                            The golden holds that stdout. A nonzero exit is a
 #                            *crash* (an uncaught exception), reported as its own
 #                            category - never a plain mismatch, never blessable.
 #   * negative (bad_*.c02)  - must fail to parse: nonzero exit, diagnostic on
 #                            stderr. The golden holds that stderr. If a bad_ case
 #                            parses cleanly (exit 0) that is an XPASS failure.
+#   * warning (warn_*.c02)  - must still succeed: exit 0 (like positive), but
+#                            expected to print a non-fatal diagnostic (a
+#                            WARN_*) to stderr. The golden holds that stderr,
+#                            not stdout - this is the only way to pin a
+#                            warning's text down, since a plain positive case
+#                            never looks at stderr at all.
 #
 # Usage:
 #   scripts/test.py                 run every stage
@@ -26,6 +36,7 @@
 import argparse
 import difflib
 import os
+import re
 import subprocess
 import sys
 import tempfile
@@ -46,13 +57,23 @@
 #                print the AST to stdout (instead of emitting a binary .o) so the
 #                golden stays text-diffable, while negatives (bad_*) still run
 #                analysis and print diagnostics to stderr.
+#   * codegen  - the *full* pipeline (frontend -> linker -> c02-as) via the
+#                `c02c` driver, since codegen never runs standalone on source.
+#                `--no-stdlib` keeps goldens independent of libc02's own
+#                global/RAM footprint. There's no AST/IR dump to diff on
+#                success (codegen's only output is a binary ROM, written to a
+#                throwaway path), so positive goldens here just pin "nothing
+#                printed"; negatives still pin the diagnostic on stderr.
+_CODEGEN_OUT = os.path.join(tempfile.gettempdir(), "c02_codegen_test.rom")
 STAGES = {
     "parser":   lambda src: [FRONTEND, "--parse-only", "--dump-ast", src],
     "analyzer": lambda src: [FRONTEND, "--dump-ast", src],
+    "codegen":  lambda src: [DRIVER, "--no-stdlib", "-o", _CODEGEN_OUT, src],
 }
 
 # --- terminal styling -------------------------------------------------------
 _USE_COLOR = sys.stdout.isatty() and os.environ.get("NO_COLOR") is None
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
 
 
 def _c(code, text):
@@ -92,12 +113,20 @@ def run_case(src_path, argv_for):
         capture_output=True,
         text=True,
     )
-    return proc.stdout, proc.stderr, proc.returncode
+    # c02-as colors its failure messages unconditionally (no TTY check), so a
+    # captured pipe still carries the escape codes. Strip them here, once, so
+    # every stage's goldens stay plain, diffable text - never baked into a
+    # committed golden file.
+    stdout = _ANSI_RE.sub("", proc.stdout)
+    stderr = _ANSI_RE.sub("", proc.stderr)
+    return stdout, stderr, proc.returncode
 
 
 def check_case(name, src_path, golden_path, argv_for, bless):
     stdout, stderr, code = run_case(src_path, argv_for)
-    negative = os.path.basename(name).startswith("bad_")
+    basename = os.path.basename(name)
+    negative = basename.startswith("bad_")
+    warning = basename.startswith("warn_")
 
     if negative:
         # A negative must fail to parse. Parsing cleanly is an XPASS - the case
@@ -105,6 +134,13 @@ def check_case(name, src_path, golden_path, argv_for, bless):
         if code == 0:
             return Result(name, XPASS, "expected a parse error, but the input parsed cleanly")
         observed = stderr
+    elif warning:
+        # A warning case must still succeed - same crash handling as positive -
+        # but the thing being pinned down is the diagnostic text on stderr.
+        if code != 0:
+            why = f"exit {code}" + (f"\n{stderr.rstrip()}" if stderr else "")
+            return Result(name, CRASH, why)
+        observed = stderr
     else:
         # A positive must parse. A nonzero exit is an uncaught exception: its own
         # category so it can't masquerade as a mismatch, and never blessable.
diff --git a/test/analyzer/bad_interrupt_call.c02 b/test/analyzer/bad_interrupt_call.c02
new file mode 100644
index 0000000..170203b
--- /dev/null
+++ b/test/analyzer/bad_interrupt_call.c02
@@ -0,0 +1,7 @@
+fn irq() interrupt -> void {
+
+}
+
+fn main() -> void {
+  irq();
+}
diff --git a/test/analyzer/bad_oversized_struct.c02 b/test/analyzer/bad_oversized_struct.c02
new file mode 100644
index 0000000..dd2eda5
--- /dev/null
+++ b/test/analyzer/bad_oversized_struct.c02
@@ -0,0 +1,10 @@
+struct S0 { u16 a; u16 b; }
+struct S1 { S0 a; S0 b; }
+struct S2 { S1 a; S1 b; }
+struct S3 { S2 a; S2 b; }
+struct S4 { S3 a; S3 b; }
+struct S5 { S4 a; S4 b; }
+struct S6 { S5 a; S5 b; }
+S6 g;
+// sizeof S6: 256 bytes, 1 over limit
+fn main() -> void { }
diff --git a/test/analyzer/bad_self_include.c02 b/test/analyzer/bad_self_include.c02
new file mode 100644
index 0000000..dda0901
--- /dev/null
+++ b/test/analyzer/bad_self_include.c02
@@ -0,0 +1,3 @@
+include "bad_self_include.c02";
+
+fn main() -> void {}
\ No newline at end of file
diff --git a/test/analyzer/bad_struct_by_value_param.c02 b/test/analyzer/bad_struct_by_value_param.c02
new file mode 100644
index 0000000..a208cd5
--- /dev/null
+++ b/test/analyzer/bad_struct_by_value_param.c02
@@ -0,0 +1,16 @@
+reg u8 PORTB @ 0x6000;
+struct Pair { u8 a; u8 b; }
+
+decl fn fwd(u8 dummy, Pair p) -> void;            // Should error at Pair p in parameter list
+fn second(u8 dummy, Pair p) -> u8 { return p.b; } // Should error at Pair p in parameter list
+
+fn third(u8 dummy, Pair *p) -> void {             // Ok: not a pass by value
+  p.a = 10;
+}
+
+fn main() -> void {
+  Pair q = Pair{ .a = 7, .b = 42 };
+  PORTB = second(0, q);                           // Should error at second(0, q)
+                                                  //                           ^
+  third(0, q);                                    // SHould error at call, type mismatch
+}
\ No newline at end of file
diff --git a/test/analyzer/bad_struct_by_value_return.c02 b/test/analyzer/bad_struct_by_value_return.c02
new file mode 100644
index 0000000..4830bd0
--- /dev/null
+++ b/test/analyzer/bad_struct_by_value_return.c02
@@ -0,0 +1,4 @@
+struct Pair { u8 a; u8 b; }
+fn first(Pair *p) -> Pair { return *p; } // should error on return type in signature
+
+fn main() -> void {}
\ No newline at end of file
diff --git a/test/analyzer/golden/bad_interrupt_call.golden b/test/analyzer/golden/bad_interrupt_call.golden
new file mode 100644
index 0000000..eae40ad
--- /dev/null
+++ b/test/analyzer/golden/bad_interrupt_call.golden
@@ -0,0 +1,7 @@
+test/analyzer/bad_interrupt_call.c02:6:3:
+  |
+6 |   irq();
+  |   ^
+'irq' attempting to call an interrupt function explicitly
+
+Semantic analysis failed with 1 errors.
diff --git a/test/analyzer/golden/bad_oversized_struct.golden b/test/analyzer/golden/bad_oversized_struct.golden
new file mode 100644
index 0000000..c1cc844
--- /dev/null
+++ b/test/analyzer/golden/bad_oversized_struct.golden
@@ -0,0 +1,7 @@
+test/analyzer/bad_oversized_struct.c02:7:1:
+  |
+7 | struct S6 { S5 a; S5 b; }
+  | ^
+'S6': struct size is over 255 bytes: 256 bytes
+
+Semantic analysis failed with 1 errors.
diff --git a/test/analyzer/golden/bad_self_include.golden b/test/analyzer/golden/bad_self_include.golden
new file mode 100644
index 0000000..3f57780
--- /dev/null
+++ b/test/analyzer/golden/bad_self_include.golden
@@ -0,0 +1,5 @@
+bad_self_include.c02:1:1:
+  |
+1 | <empty line>
+  | ^
+cannot include yourself 'bad_self_include.c02'.
diff --git a/test/analyzer/golden/bad_struct_by_value_param.golden b/test/analyzer/golden/bad_struct_by_value_param.golden
new file mode 100644
index 0000000..3be1fb6
--- /dev/null
+++ b/test/analyzer/golden/bad_struct_by_value_param.golden
@@ -0,0 +1,19 @@
+test/analyzer/bad_struct_by_value_param.c02:4:1:
+  |
+4 | decl fn fwd(u8 dummy, Pair p) -> void;            // Should error at Pair p in parameter list
+  | ^
+'Pair': Passing struct by value is prohibited
+
+test/analyzer/bad_struct_by_value_param.c02:5:1:
+  |
+5 | fn second(u8 dummy, Pair p) -> u8 { return p.b; } // Should error at Pair p in parameter list
+  | ^
+'Pair': Passing struct by value is prohibited
+
+test/analyzer/bad_struct_by_value_param.c02:15:3:
+   |
+15 |   third(0, q);                                    // SHould error at call, type mismatch
+   |   ^
+type mismatch in function call: expected Pair*, found Pair
+
+Semantic analysis failed with 3 errors.
diff --git a/test/analyzer/golden/bad_struct_by_value_return.golden b/test/analyzer/golden/bad_struct_by_value_return.golden
new file mode 100644
index 0000000..7e8c462
--- /dev/null
+++ b/test/analyzer/golden/bad_struct_by_value_return.golden
@@ -0,0 +1,7 @@
+test/analyzer/bad_struct_by_value_return.c02:2:1:
+  |
+2 | fn first(Pair *p) -> Pair { return *p; } // should error on return type in signature
+  | ^
+'Pair': Returning struct by value is prohibited
+
+Semantic analysis failed with 1 errors.
diff --git a/test/analyzer/golden/struct_by_pointer_param.golden b/test/analyzer/golden/struct_by_pointer_param.golden
new file mode 100644
index 0000000..2e80939
--- /dev/null
+++ b/test/analyzer/golden/struct_by_pointer_param.golden
@@ -0,0 +1 @@
+Program [] [RegisterDecl (RegDecl {regType = U8, regPtrDepth = 0, regName = "PORTB", declAddress = 24576}),StructDef (StructDecl {structName = "Pair", structFields = [(U8,0,"a"),(U8,0,"b")]}),FwdFuncDecl (FuncDecl {funcName = "first", funcReturnType = Void, funcReturnPtrDepth = 0, isInterrupt = False, params = [(U8,0,"dummy"),(StructName "Pair",1,"p")], body = Nothing}),FunctionDecl (FuncDecl {funcName = "second", funcReturnType = U8, funcReturnPtrDepth = 0, isInterrupt = False, params = [(U8,0,"dummy"),(StructName "Pair",1,"p")], body = Just (Nested [Return (Just (Binary Add (Field (Var "p") "a") (Field (Var "p") "b")))])}),FunctionDecl (FuncDecl {funcName = "main", funcReturnType = Void, funcReturnPtrDepth = 0, isInterrupt = False, params = [], body = Just (Nested [LocVarDecl (VarDecl {varType = StructName "Pair", ptrDepth = 0, declName = "q", declInit = Just (StructInit "Pair" [("a",IntLit 7),("b",IntLit 42)])}),Assign (Var "PORTB") Equals (Call "second" [IntLit 0,Unary AddressOf (Var "q")])])})]
diff --git a/test/analyzer/golden/struct_return_by_pointer.golden b/test/analyzer/golden/struct_return_by_pointer.golden
new file mode 100644
index 0000000..d3796da
--- /dev/null
+++ b/test/analyzer/golden/struct_return_by_pointer.golden
@@ -0,0 +1 @@
+Program [] [StructDef (StructDecl {structName = "Pair", structFields = [(U8,0,"a"),(U8,0,"b")]}),FunctionDecl (FuncDecl {funcName = "first", funcReturnType = StructName "Pair", funcReturnPtrDepth = 1, isInterrupt = False, params = [(StructName "Pair",1,"p")], body = Just (Nested [Return (Just (IntLit 0))])}),FunctionDecl (FuncDecl {funcName = "main", funcReturnType = Void, funcReturnPtrDepth = 0, isInterrupt = False, params = [], body = Just (Nested [])})]
diff --git a/test/analyzer/golden/warn_invalid_interrupt.golden b/test/analyzer/golden/warn_invalid_interrupt.golden
new file mode 100644
index 0000000..b025e98
--- /dev/null
+++ b/test/analyzer/golden/warn_invalid_interrupt.golden
@@ -0,0 +1,7 @@
+test/analyzer/warn_invalid_interrupt.c02:1:1:
+  |
+1 | fn tick() interrupt -> void {
+  | ^
+'tick' function tagged interrupt but does not have valid signature. dropping interrupt qualifier.
+
+1 warnings.
diff --git a/test/analyzer/struct_by_pointer_param.c02 b/test/analyzer/struct_by_pointer_param.c02
new file mode 100644
index 0000000..f7ea43e
--- /dev/null
+++ b/test/analyzer/struct_by_pointer_param.c02
@@ -0,0 +1,13 @@
+reg u8 PORTB @ 0x6000;
+
+struct Pair { u8 a; u8 b; }
+
+decl fn first(u8 dummy, Pair *p) -> void;
+fn second(u8 dummy, Pair *p) -> u8 {             // Ok: not a pass by value
+  return p.a + p.b;
+}
+
+fn main() -> void {
+  Pair q = Pair{ .a = 7, .b = 42 };
+  PORTB = second(0, &q);
+}
\ No newline at end of file
diff --git a/test/analyzer/struct_return_by_pointer.c02 b/test/analyzer/struct_return_by_pointer.c02
new file mode 100644
index 0000000..9de19bc
--- /dev/null
+++ b/test/analyzer/struct_return_by_pointer.c02
@@ -0,0 +1,4 @@
+struct Pair { u8 a; u8 b; }
+fn first(Pair *p) -> Pair * { return null; }
+
+fn main() -> void { }
\ No newline at end of file
diff --git a/test/analyzer/warn_invalid_interrupt.c02 b/test/analyzer/warn_invalid_interrupt.c02
new file mode 100644
index 0000000..0211d84
--- /dev/null
+++ b/test/analyzer/warn_invalid_interrupt.c02
@@ -0,0 +1,7 @@
+fn tick() interrupt -> void {
+
+}
+
+fn main() -> void {
+  return;
+}
diff --git a/test/codegen/bad_ram_overflow.c02 b/test/codegen/bad_ram_overflow.c02
new file mode 100644
index 0000000..94a8f92
--- /dev/null
+++ b/test/codegen/bad_ram_overflow.c02
@@ -0,0 +1,7939 @@
+u16 var_0 = 0;
+u16 var_1 = 0;
+u16 var_2 = 0;
+u16 var_3 = 0;
+u16 var_4 = 0;
+u16 var_5 = 0;
+u16 var_6 = 0;
+u16 var_7 = 0;
+u16 var_8 = 0;
+u16 var_9 = 0;
+u16 var_10 = 0;
+u16 var_11 = 0;
+u16 var_12 = 0;
+u16 var_13 = 0;
+u16 var_14 = 0;
+u16 var_15 = 0;
+u16 var_16 = 0;
+u16 var_17 = 0;
+u16 var_18 = 0;
+u16 var_19 = 0;
+u16 var_20 = 0;
+u16 var_21 = 0;
+u16 var_22 = 0;
+u16 var_23 = 0;
+u16 var_24 = 0;
+u16 var_25 = 0;
+u16 var_26 = 0;
+u16 var_27 = 0;
+u16 var_28 = 0;
+u16 var_29 = 0;
+u16 var_30 = 0;
+u16 var_31 = 0;
+u16 var_32 = 0;
+u16 var_33 = 0;
+u16 var_34 = 0;
+u16 var_35 = 0;
+u16 var_36 = 0;
+u16 var_37 = 0;
+u16 var_38 = 0;
+u16 var_39 = 0;
+u16 var_40 = 0;
+u16 var_41 = 0;
+u16 var_42 = 0;
+u16 var_43 = 0;
+u16 var_44 = 0;
+u16 var_45 = 0;
+u16 var_46 = 0;
+u16 var_47 = 0;
+u16 var_48 = 0;
+u16 var_49 = 0;
+u16 var_50 = 0;
+u16 var_51 = 0;
+u16 var_52 = 0;
+u16 var_53 = 0;
+u16 var_54 = 0;
+u16 var_55 = 0;
+u16 var_56 = 0;
+u16 var_57 = 0;
+u16 var_58 = 0;
+u16 var_59 = 0;
+u16 var_60 = 0;
+u16 var_61 = 0;
+u16 var_62 = 0;
+u16 var_63 = 0;
+u16 var_64 = 0;
+u16 var_65 = 0;
+u16 var_66 = 0;
+u16 var_67 = 0;
+u16 var_68 = 0;
+u16 var_69 = 0;
+u16 var_70 = 0;
+u16 var_71 = 0;
+u16 var_72 = 0;
+u16 var_73 = 0;
+u16 var_74 = 0;
+u16 var_75 = 0;
+u16 var_76 = 0;
+u16 var_77 = 0;
+u16 var_78 = 0;
+u16 var_79 = 0;
+u16 var_80 = 0;
+u16 var_81 = 0;
+u16 var_82 = 0;
+u16 var_83 = 0;
+u16 var_84 = 0;
+u16 var_85 = 0;
+u16 var_86 = 0;
+u16 var_87 = 0;
+u16 var_88 = 0;
+u16 var_89 = 0;
+u16 var_90 = 0;
+u16 var_91 = 0;
+u16 var_92 = 0;
+u16 var_93 = 0;
+u16 var_94 = 0;
+u16 var_95 = 0;
+u16 var_96 = 0;
+u16 var_97 = 0;
+u16 var_98 = 0;
+u16 var_99 = 0;
+u16 var_100 = 0;
+u16 var_101 = 0;
+u16 var_102 = 0;
+u16 var_103 = 0;
+u16 var_104 = 0;
+u16 var_105 = 0;
+u16 var_106 = 0;
+u16 var_107 = 0;
+u16 var_108 = 0;
+u16 var_109 = 0;
+u16 var_110 = 0;
+u16 var_111 = 0;
+u16 var_112 = 0;
+u16 var_113 = 0;
+u16 var_114 = 0;
+u16 var_115 = 0;
+u16 var_116 = 0;
+u16 var_117 = 0;
+u16 var_118 = 0;
+u16 var_119 = 0;
+u16 var_120 = 0;
+u16 var_121 = 0;
+u16 var_122 = 0;
+u16 var_123 = 0;
+u16 var_124 = 0;
+u16 var_125 = 0;
+u16 var_126 = 0;
+u16 var_127 = 0;
+u16 var_128 = 0;
+u16 var_129 = 0;
+u16 var_130 = 0;
+u16 var_131 = 0;
+u16 var_132 = 0;
+u16 var_133 = 0;
+u16 var_134 = 0;
+u16 var_135 = 0;
+u16 var_136 = 0;
+u16 var_137 = 0;
+u16 var_138 = 0;
+u16 var_139 = 0;
+u16 var_140 = 0;
+u16 var_141 = 0;
+u16 var_142 = 0;
+u16 var_143 = 0;
+u16 var_144 = 0;
+u16 var_145 = 0;
+u16 var_146 = 0;
+u16 var_147 = 0;
+u16 var_148 = 0;
+u16 var_149 = 0;
+u16 var_150 = 0;
+u16 var_151 = 0;
+u16 var_152 = 0;
+u16 var_153 = 0;
+u16 var_154 = 0;
+u16 var_155 = 0;
+u16 var_156 = 0;
+u16 var_157 = 0;
+u16 var_158 = 0;
+u16 var_159 = 0;
+u16 var_160 = 0;
+u16 var_161 = 0;
+u16 var_162 = 0;
+u16 var_163 = 0;
+u16 var_164 = 0;
+u16 var_165 = 0;
+u16 var_166 = 0;
+u16 var_167 = 0;
+u16 var_168 = 0;
+u16 var_169 = 0;
+u16 var_170 = 0;
+u16 var_171 = 0;
+u16 var_172 = 0;
+u16 var_173 = 0;
+u16 var_174 = 0;
+u16 var_175 = 0;
+u16 var_176 = 0;
+u16 var_177 = 0;
+u16 var_178 = 0;
+u16 var_179 = 0;
+u16 var_180 = 0;
+u16 var_181 = 0;
+u16 var_182 = 0;
+u16 var_183 = 0;
+u16 var_184 = 0;
+u16 var_185 = 0;
+u16 var_186 = 0;
+u16 var_187 = 0;
+u16 var_188 = 0;
+u16 var_189 = 0;
+u16 var_190 = 0;
+u16 var_191 = 0;
+u16 var_192 = 0;
+u16 var_193 = 0;
+u16 var_194 = 0;
+u16 var_195 = 0;
+u16 var_196 = 0;
+u16 var_197 = 0;
+u16 var_198 = 0;
+u16 var_199 = 0;
+u16 var_200 = 0;
+u16 var_201 = 0;
+u16 var_202 = 0;
+u16 var_203 = 0;
+u16 var_204 = 0;
+u16 var_205 = 0;
+u16 var_206 = 0;
+u16 var_207 = 0;
+u16 var_208 = 0;
+u16 var_209 = 0;
+u16 var_210 = 0;
+u16 var_211 = 0;
+u16 var_212 = 0;
+u16 var_213 = 0;
+u16 var_214 = 0;
+u16 var_215 = 0;
+u16 var_216 = 0;
+u16 var_217 = 0;
+u16 var_218 = 0;
+u16 var_219 = 0;
+u16 var_220 = 0;
+u16 var_221 = 0;
+u16 var_222 = 0;
+u16 var_223 = 0;
+u16 var_224 = 0;
+u16 var_225 = 0;
+u16 var_226 = 0;
+u16 var_227 = 0;
+u16 var_228 = 0;
+u16 var_229 = 0;
+u16 var_230 = 0;
+u16 var_231 = 0;
+u16 var_232 = 0;
+u16 var_233 = 0;
+u16 var_234 = 0;
+u16 var_235 = 0;
+u16 var_236 = 0;
+u16 var_237 = 0;
+u16 var_238 = 0;
+u16 var_239 = 0;
+u16 var_240 = 0;
+u16 var_241 = 0;
+u16 var_242 = 0;
+u16 var_243 = 0;
+u16 var_244 = 0;
+u16 var_245 = 0;
+u16 var_246 = 0;
+u16 var_247 = 0;
+u16 var_248 = 0;
+u16 var_249 = 0;
+u16 var_250 = 0;
+u16 var_251 = 0;
+u16 var_252 = 0;
+u16 var_253 = 0;
+u16 var_254 = 0;
+u16 var_255 = 0;
+u16 var_256 = 0;
+u16 var_257 = 0;
+u16 var_258 = 0;
+u16 var_259 = 0;
+u16 var_260 = 0;
+u16 var_261 = 0;
+u16 var_262 = 0;
+u16 var_263 = 0;
+u16 var_264 = 0;
+u16 var_265 = 0;
+u16 var_266 = 0;
+u16 var_267 = 0;
+u16 var_268 = 0;
+u16 var_269 = 0;
+u16 var_270 = 0;
+u16 var_271 = 0;
+u16 var_272 = 0;
+u16 var_273 = 0;
+u16 var_274 = 0;
+u16 var_275 = 0;
+u16 var_276 = 0;
+u16 var_277 = 0;
+u16 var_278 = 0;
+u16 var_279 = 0;
+u16 var_280 = 0;
+u16 var_281 = 0;
+u16 var_282 = 0;
+u16 var_283 = 0;
+u16 var_284 = 0;
+u16 var_285 = 0;
+u16 var_286 = 0;
+u16 var_287 = 0;
+u16 var_288 = 0;
+u16 var_289 = 0;
+u16 var_290 = 0;
+u16 var_291 = 0;
+u16 var_292 = 0;
+u16 var_293 = 0;
+u16 var_294 = 0;
+u16 var_295 = 0;
+u16 var_296 = 0;
+u16 var_297 = 0;
+u16 var_298 = 0;
+u16 var_299 = 0;
+u16 var_300 = 0;
+u16 var_301 = 0;
+u16 var_302 = 0;
+u16 var_303 = 0;
+u16 var_304 = 0;
+u16 var_305 = 0;
+u16 var_306 = 0;
+u16 var_307 = 0;
+u16 var_308 = 0;
+u16 var_309 = 0;
+u16 var_310 = 0;
+u16 var_311 = 0;
+u16 var_312 = 0;
+u16 var_313 = 0;
+u16 var_314 = 0;
+u16 var_315 = 0;
+u16 var_316 = 0;
+u16 var_317 = 0;
+u16 var_318 = 0;
+u16 var_319 = 0;
+u16 var_320 = 0;
+u16 var_321 = 0;
+u16 var_322 = 0;
+u16 var_323 = 0;
+u16 var_324 = 0;
+u16 var_325 = 0;
+u16 var_326 = 0;
+u16 var_327 = 0;
+u16 var_328 = 0;
+u16 var_329 = 0;
+u16 var_330 = 0;
+u16 var_331 = 0;
+u16 var_332 = 0;
+u16 var_333 = 0;
+u16 var_334 = 0;
+u16 var_335 = 0;
+u16 var_336 = 0;
+u16 var_337 = 0;
+u16 var_338 = 0;
+u16 var_339 = 0;
+u16 var_340 = 0;
+u16 var_341 = 0;
+u16 var_342 = 0;
+u16 var_343 = 0;
+u16 var_344 = 0;
+u16 var_345 = 0;
+u16 var_346 = 0;
+u16 var_347 = 0;
+u16 var_348 = 0;
+u16 var_349 = 0;
+u16 var_350 = 0;
+u16 var_351 = 0;
+u16 var_352 = 0;
+u16 var_353 = 0;
+u16 var_354 = 0;
+u16 var_355 = 0;
+u16 var_356 = 0;
+u16 var_357 = 0;
+u16 var_358 = 0;
+u16 var_359 = 0;
+u16 var_360 = 0;
+u16 var_361 = 0;
+u16 var_362 = 0;
+u16 var_363 = 0;
+u16 var_364 = 0;
+u16 var_365 = 0;
+u16 var_366 = 0;
+u16 var_367 = 0;
+u16 var_368 = 0;
+u16 var_369 = 0;
+u16 var_370 = 0;
+u16 var_371 = 0;
+u16 var_372 = 0;
+u16 var_373 = 0;
+u16 var_374 = 0;
+u16 var_375 = 0;
+u16 var_376 = 0;
+u16 var_377 = 0;
+u16 var_378 = 0;
+u16 var_379 = 0;
+u16 var_380 = 0;
+u16 var_381 = 0;
+u16 var_382 = 0;
+u16 var_383 = 0;
+u16 var_384 = 0;
+u16 var_385 = 0;
+u16 var_386 = 0;
+u16 var_387 = 0;
+u16 var_388 = 0;
+u16 var_389 = 0;
+u16 var_390 = 0;
+u16 var_391 = 0;
+u16 var_392 = 0;
+u16 var_393 = 0;
+u16 var_394 = 0;
+u16 var_395 = 0;
+u16 var_396 = 0;
+u16 var_397 = 0;
+u16 var_398 = 0;
+u16 var_399 = 0;
+u16 var_400 = 0;
+u16 var_401 = 0;
+u16 var_402 = 0;
+u16 var_403 = 0;
+u16 var_404 = 0;
+u16 var_405 = 0;
+u16 var_406 = 0;
+u16 var_407 = 0;
+u16 var_408 = 0;
+u16 var_409 = 0;
+u16 var_410 = 0;
+u16 var_411 = 0;
+u16 var_412 = 0;
+u16 var_413 = 0;
+u16 var_414 = 0;
+u16 var_415 = 0;
+u16 var_416 = 0;
+u16 var_417 = 0;
+u16 var_418 = 0;
+u16 var_419 = 0;
+u16 var_420 = 0;
+u16 var_421 = 0;
+u16 var_422 = 0;
+u16 var_423 = 0;
+u16 var_424 = 0;
+u16 var_425 = 0;
+u16 var_426 = 0;
+u16 var_427 = 0;
+u16 var_428 = 0;
+u16 var_429 = 0;
+u16 var_430 = 0;
+u16 var_431 = 0;
+u16 var_432 = 0;
+u16 var_433 = 0;
+u16 var_434 = 0;
+u16 var_435 = 0;
+u16 var_436 = 0;
+u16 var_437 = 0;
+u16 var_438 = 0;
+u16 var_439 = 0;
+u16 var_440 = 0;
+u16 var_441 = 0;
+u16 var_442 = 0;
+u16 var_443 = 0;
+u16 var_444 = 0;
+u16 var_445 = 0;
+u16 var_446 = 0;
+u16 var_447 = 0;
+u16 var_448 = 0;
+u16 var_449 = 0;
+u16 var_450 = 0;
+u16 var_451 = 0;
+u16 var_452 = 0;
+u16 var_453 = 0;
+u16 var_454 = 0;
+u16 var_455 = 0;
+u16 var_456 = 0;
+u16 var_457 = 0;
+u16 var_458 = 0;
+u16 var_459 = 0;
+u16 var_460 = 0;
+u16 var_461 = 0;
+u16 var_462 = 0;
+u16 var_463 = 0;
+u16 var_464 = 0;
+u16 var_465 = 0;
+u16 var_466 = 0;
+u16 var_467 = 0;
+u16 var_468 = 0;
+u16 var_469 = 0;
+u16 var_470 = 0;
+u16 var_471 = 0;
+u16 var_472 = 0;
+u16 var_473 = 0;
+u16 var_474 = 0;
+u16 var_475 = 0;
+u16 var_476 = 0;
+u16 var_477 = 0;
+u16 var_478 = 0;
+u16 var_479 = 0;
+u16 var_480 = 0;
+u16 var_481 = 0;
+u16 var_482 = 0;
+u16 var_483 = 0;
+u16 var_484 = 0;
+u16 var_485 = 0;
+u16 var_486 = 0;
+u16 var_487 = 0;
+u16 var_488 = 0;
+u16 var_489 = 0;
+u16 var_490 = 0;
+u16 var_491 = 0;
+u16 var_492 = 0;
+u16 var_493 = 0;
+u16 var_494 = 0;
+u16 var_495 = 0;
+u16 var_496 = 0;
+u16 var_497 = 0;
+u16 var_498 = 0;
+u16 var_499 = 0;
+u16 var_500 = 0;
+u16 var_501 = 0;
+u16 var_502 = 0;
+u16 var_503 = 0;
+u16 var_504 = 0;
+u16 var_505 = 0;
+u16 var_506 = 0;
+u16 var_507 = 0;
+u16 var_508 = 0;
+u16 var_509 = 0;
+u16 var_510 = 0;
+u16 var_511 = 0;
+u16 var_512 = 0;
+u16 var_513 = 0;
+u16 var_514 = 0;
+u16 var_515 = 0;
+u16 var_516 = 0;
+u16 var_517 = 0;
+u16 var_518 = 0;
+u16 var_519 = 0;
+u16 var_520 = 0;
+u16 var_521 = 0;
+u16 var_522 = 0;
+u16 var_523 = 0;
+u16 var_524 = 0;
+u16 var_525 = 0;
+u16 var_526 = 0;
+u16 var_527 = 0;
+u16 var_528 = 0;
+u16 var_529 = 0;
+u16 var_530 = 0;
+u16 var_531 = 0;
+u16 var_532 = 0;
+u16 var_533 = 0;
+u16 var_534 = 0;
+u16 var_535 = 0;
+u16 var_536 = 0;
+u16 var_537 = 0;
+u16 var_538 = 0;
+u16 var_539 = 0;
+u16 var_540 = 0;
+u16 var_541 = 0;
+u16 var_542 = 0;
+u16 var_543 = 0;
+u16 var_544 = 0;
+u16 var_545 = 0;
+u16 var_546 = 0;
+u16 var_547 = 0;
+u16 var_548 = 0;
+u16 var_549 = 0;
+u16 var_550 = 0;
+u16 var_551 = 0;
+u16 var_552 = 0;
+u16 var_553 = 0;
+u16 var_554 = 0;
+u16 var_555 = 0;
+u16 var_556 = 0;
+u16 var_557 = 0;
+u16 var_558 = 0;
+u16 var_559 = 0;
+u16 var_560 = 0;
+u16 var_561 = 0;
+u16 var_562 = 0;
+u16 var_563 = 0;
+u16 var_564 = 0;
+u16 var_565 = 0;
+u16 var_566 = 0;
+u16 var_567 = 0;
+u16 var_568 = 0;
+u16 var_569 = 0;
+u16 var_570 = 0;
+u16 var_571 = 0;
+u16 var_572 = 0;
+u16 var_573 = 0;
+u16 var_574 = 0;
+u16 var_575 = 0;
+u16 var_576 = 0;
+u16 var_577 = 0;
+u16 var_578 = 0;
+u16 var_579 = 0;
+u16 var_580 = 0;
+u16 var_581 = 0;
+u16 var_582 = 0;
+u16 var_583 = 0;
+u16 var_584 = 0;
+u16 var_585 = 0;
+u16 var_586 = 0;
+u16 var_587 = 0;
+u16 var_588 = 0;
+u16 var_589 = 0;
+u16 var_590 = 0;
+u16 var_591 = 0;
+u16 var_592 = 0;
+u16 var_593 = 0;
+u16 var_594 = 0;
+u16 var_595 = 0;
+u16 var_596 = 0;
+u16 var_597 = 0;
+u16 var_598 = 0;
+u16 var_599 = 0;
+u16 var_600 = 0;
+u16 var_601 = 0;
+u16 var_602 = 0;
+u16 var_603 = 0;
+u16 var_604 = 0;
+u16 var_605 = 0;
+u16 var_606 = 0;
+u16 var_607 = 0;
+u16 var_608 = 0;
+u16 var_609 = 0;
+u16 var_610 = 0;
+u16 var_611 = 0;
+u16 var_612 = 0;
+u16 var_613 = 0;
+u16 var_614 = 0;
+u16 var_615 = 0;
+u16 var_616 = 0;
+u16 var_617 = 0;
+u16 var_618 = 0;
+u16 var_619 = 0;
+u16 var_620 = 0;
+u16 var_621 = 0;
+u16 var_622 = 0;
+u16 var_623 = 0;
+u16 var_624 = 0;
+u16 var_625 = 0;
+u16 var_626 = 0;
+u16 var_627 = 0;
+u16 var_628 = 0;
+u16 var_629 = 0;
+u16 var_630 = 0;
+u16 var_631 = 0;
+u16 var_632 = 0;
+u16 var_633 = 0;
+u16 var_634 = 0;
+u16 var_635 = 0;
+u16 var_636 = 0;
+u16 var_637 = 0;
+u16 var_638 = 0;
+u16 var_639 = 0;
+u16 var_640 = 0;
+u16 var_641 = 0;
+u16 var_642 = 0;
+u16 var_643 = 0;
+u16 var_644 = 0;
+u16 var_645 = 0;
+u16 var_646 = 0;
+u16 var_647 = 0;
+u16 var_648 = 0;
+u16 var_649 = 0;
+u16 var_650 = 0;
+u16 var_651 = 0;
+u16 var_652 = 0;
+u16 var_653 = 0;
+u16 var_654 = 0;
+u16 var_655 = 0;
+u16 var_656 = 0;
+u16 var_657 = 0;
+u16 var_658 = 0;
+u16 var_659 = 0;
+u16 var_660 = 0;
+u16 var_661 = 0;
+u16 var_662 = 0;
+u16 var_663 = 0;
+u16 var_664 = 0;
+u16 var_665 = 0;
+u16 var_666 = 0;
+u16 var_667 = 0;
+u16 var_668 = 0;
+u16 var_669 = 0;
+u16 var_670 = 0;
+u16 var_671 = 0;
+u16 var_672 = 0;
+u16 var_673 = 0;
+u16 var_674 = 0;
+u16 var_675 = 0;
+u16 var_676 = 0;
+u16 var_677 = 0;
+u16 var_678 = 0;
+u16 var_679 = 0;
+u16 var_680 = 0;
+u16 var_681 = 0;
+u16 var_682 = 0;
+u16 var_683 = 0;
+u16 var_684 = 0;
+u16 var_685 = 0;
+u16 var_686 = 0;
+u16 var_687 = 0;
+u16 var_688 = 0;
+u16 var_689 = 0;
+u16 var_690 = 0;
+u16 var_691 = 0;
+u16 var_692 = 0;
+u16 var_693 = 0;
+u16 var_694 = 0;
+u16 var_695 = 0;
+u16 var_696 = 0;
+u16 var_697 = 0;
+u16 var_698 = 0;
+u16 var_699 = 0;
+u16 var_700 = 0;
+u16 var_701 = 0;
+u16 var_702 = 0;
+u16 var_703 = 0;
+u16 var_704 = 0;
+u16 var_705 = 0;
+u16 var_706 = 0;
+u16 var_707 = 0;
+u16 var_708 = 0;
+u16 var_709 = 0;
+u16 var_710 = 0;
+u16 var_711 = 0;
+u16 var_712 = 0;
+u16 var_713 = 0;
+u16 var_714 = 0;
+u16 var_715 = 0;
+u16 var_716 = 0;
+u16 var_717 = 0;
+u16 var_718 = 0;
+u16 var_719 = 0;
+u16 var_720 = 0;
+u16 var_721 = 0;
+u16 var_722 = 0;
+u16 var_723 = 0;
+u16 var_724 = 0;
+u16 var_725 = 0;
+u16 var_726 = 0;
+u16 var_727 = 0;
+u16 var_728 = 0;
+u16 var_729 = 0;
+u16 var_730 = 0;
+u16 var_731 = 0;
+u16 var_732 = 0;
+u16 var_733 = 0;
+u16 var_734 = 0;
+u16 var_735 = 0;
+u16 var_736 = 0;
+u16 var_737 = 0;
+u16 var_738 = 0;
+u16 var_739 = 0;
+u16 var_740 = 0;
+u16 var_741 = 0;
+u16 var_742 = 0;
+u16 var_743 = 0;
+u16 var_744 = 0;
+u16 var_745 = 0;
+u16 var_746 = 0;
+u16 var_747 = 0;
+u16 var_748 = 0;
+u16 var_749 = 0;
+u16 var_750 = 0;
+u16 var_751 = 0;
+u16 var_752 = 0;
+u16 var_753 = 0;
+u16 var_754 = 0;
+u16 var_755 = 0;
+u16 var_756 = 0;
+u16 var_757 = 0;
+u16 var_758 = 0;
+u16 var_759 = 0;
+u16 var_760 = 0;
+u16 var_761 = 0;
+u16 var_762 = 0;
+u16 var_763 = 0;
+u16 var_764 = 0;
+u16 var_765 = 0;
+u16 var_766 = 0;
+u16 var_767 = 0;
+u16 var_768 = 0;
+u16 var_769 = 0;
+u16 var_770 = 0;
+u16 var_771 = 0;
+u16 var_772 = 0;
+u16 var_773 = 0;
+u16 var_774 = 0;
+u16 var_775 = 0;
+u16 var_776 = 0;
+u16 var_777 = 0;
+u16 var_778 = 0;
+u16 var_779 = 0;
+u16 var_780 = 0;
+u16 var_781 = 0;
+u16 var_782 = 0;
+u16 var_783 = 0;
+u16 var_784 = 0;
+u16 var_785 = 0;
+u16 var_786 = 0;
+u16 var_787 = 0;
+u16 var_788 = 0;
+u16 var_789 = 0;
+u16 var_790 = 0;
+u16 var_791 = 0;
+u16 var_792 = 0;
+u16 var_793 = 0;
+u16 var_794 = 0;
+u16 var_795 = 0;
+u16 var_796 = 0;
+u16 var_797 = 0;
+u16 var_798 = 0;
+u16 var_799 = 0;
+u16 var_800 = 0;
+u16 var_801 = 0;
+u16 var_802 = 0;
+u16 var_803 = 0;
+u16 var_804 = 0;
+u16 var_805 = 0;
+u16 var_806 = 0;
+u16 var_807 = 0;
+u16 var_808 = 0;
+u16 var_809 = 0;
+u16 var_810 = 0;
+u16 var_811 = 0;
+u16 var_812 = 0;
+u16 var_813 = 0;
+u16 var_814 = 0;
+u16 var_815 = 0;
+u16 var_816 = 0;
+u16 var_817 = 0;
+u16 var_818 = 0;
+u16 var_819 = 0;
+u16 var_820 = 0;
+u16 var_821 = 0;
+u16 var_822 = 0;
+u16 var_823 = 0;
+u16 var_824 = 0;
+u16 var_825 = 0;
+u16 var_826 = 0;
+u16 var_827 = 0;
+u16 var_828 = 0;
+u16 var_829 = 0;
+u16 var_830 = 0;
+u16 var_831 = 0;
+u16 var_832 = 0;
+u16 var_833 = 0;
+u16 var_834 = 0;
+u16 var_835 = 0;
+u16 var_836 = 0;
+u16 var_837 = 0;
+u16 var_838 = 0;
+u16 var_839 = 0;
+u16 var_840 = 0;
+u16 var_841 = 0;
+u16 var_842 = 0;
+u16 var_843 = 0;
+u16 var_844 = 0;
+u16 var_845 = 0;
+u16 var_846 = 0;
+u16 var_847 = 0;
+u16 var_848 = 0;
+u16 var_849 = 0;
+u16 var_850 = 0;
+u16 var_851 = 0;
+u16 var_852 = 0;
+u16 var_853 = 0;
+u16 var_854 = 0;
+u16 var_855 = 0;
+u16 var_856 = 0;
+u16 var_857 = 0;
+u16 var_858 = 0;
+u16 var_859 = 0;
+u16 var_860 = 0;
+u16 var_861 = 0;
+u16 var_862 = 0;
+u16 var_863 = 0;
+u16 var_864 = 0;
+u16 var_865 = 0;
+u16 var_866 = 0;
+u16 var_867 = 0;
+u16 var_868 = 0;
+u16 var_869 = 0;
+u16 var_870 = 0;
+u16 var_871 = 0;
+u16 var_872 = 0;
+u16 var_873 = 0;
+u16 var_874 = 0;
+u16 var_875 = 0;
+u16 var_876 = 0;
+u16 var_877 = 0;
+u16 var_878 = 0;
+u16 var_879 = 0;
+u16 var_880 = 0;
+u16 var_881 = 0;
+u16 var_882 = 0;
+u16 var_883 = 0;
+u16 var_884 = 0;
+u16 var_885 = 0;
+u16 var_886 = 0;
+u16 var_887 = 0;
+u16 var_888 = 0;
+u16 var_889 = 0;
+u16 var_890 = 0;
+u16 var_891 = 0;
+u16 var_892 = 0;
+u16 var_893 = 0;
+u16 var_894 = 0;
+u16 var_895 = 0;
+u16 var_896 = 0;
+u16 var_897 = 0;
+u16 var_898 = 0;
+u16 var_899 = 0;
+u16 var_900 = 0;
+u16 var_901 = 0;
+u16 var_902 = 0;
+u16 var_903 = 0;
+u16 var_904 = 0;
+u16 var_905 = 0;
+u16 var_906 = 0;
+u16 var_907 = 0;
+u16 var_908 = 0;
+u16 var_909 = 0;
+u16 var_910 = 0;
+u16 var_911 = 0;
+u16 var_912 = 0;
+u16 var_913 = 0;
+u16 var_914 = 0;
+u16 var_915 = 0;
+u16 var_916 = 0;
+u16 var_917 = 0;
+u16 var_918 = 0;
+u16 var_919 = 0;
+u16 var_920 = 0;
+u16 var_921 = 0;
+u16 var_922 = 0;
+u16 var_923 = 0;
+u16 var_924 = 0;
+u16 var_925 = 0;
+u16 var_926 = 0;
+u16 var_927 = 0;
+u16 var_928 = 0;
+u16 var_929 = 0;
+u16 var_930 = 0;
+u16 var_931 = 0;
+u16 var_932 = 0;
+u16 var_933 = 0;
+u16 var_934 = 0;
+u16 var_935 = 0;
+u16 var_936 = 0;
+u16 var_937 = 0;
+u16 var_938 = 0;
+u16 var_939 = 0;
+u16 var_940 = 0;
+u16 var_941 = 0;
+u16 var_942 = 0;
+u16 var_943 = 0;
+u16 var_944 = 0;
+u16 var_945 = 0;
+u16 var_946 = 0;
+u16 var_947 = 0;
+u16 var_948 = 0;
+u16 var_949 = 0;
+u16 var_950 = 0;
+u16 var_951 = 0;
+u16 var_952 = 0;
+u16 var_953 = 0;
+u16 var_954 = 0;
+u16 var_955 = 0;
+u16 var_956 = 0;
+u16 var_957 = 0;
+u16 var_958 = 0;
+u16 var_959 = 0;
+u16 var_960 = 0;
+u16 var_961 = 0;
+u16 var_962 = 0;
+u16 var_963 = 0;
+u16 var_964 = 0;
+u16 var_965 = 0;
+u16 var_966 = 0;
+u16 var_967 = 0;
+u16 var_968 = 0;
+u16 var_969 = 0;
+u16 var_970 = 0;
+u16 var_971 = 0;
+u16 var_972 = 0;
+u16 var_973 = 0;
+u16 var_974 = 0;
+u16 var_975 = 0;
+u16 var_976 = 0;
+u16 var_977 = 0;
+u16 var_978 = 0;
+u16 var_979 = 0;
+u16 var_980 = 0;
+u16 var_981 = 0;
+u16 var_982 = 0;
+u16 var_983 = 0;
+u16 var_984 = 0;
+u16 var_985 = 0;
+u16 var_986 = 0;
+u16 var_987 = 0;
+u16 var_988 = 0;
+u16 var_989 = 0;
+u16 var_990 = 0;
+u16 var_991 = 0;
+u16 var_992 = 0;
+u16 var_993 = 0;
+u16 var_994 = 0;
+u16 var_995 = 0;
+u16 var_996 = 0;
+u16 var_997 = 0;
+u16 var_998 = 0;
+u16 var_999 = 0;
+u16 var_1000 = 0;
+u16 var_1001 = 0;
+u16 var_1002 = 0;
+u16 var_1003 = 0;
+u16 var_1004 = 0;
+u16 var_1005 = 0;
+u16 var_1006 = 0;
+u16 var_1007 = 0;
+u16 var_1008 = 0;
+u16 var_1009 = 0;
+u16 var_1010 = 0;
+u16 var_1011 = 0;
+u16 var_1012 = 0;
+u16 var_1013 = 0;
+u16 var_1014 = 0;
+u16 var_1015 = 0;
+u16 var_1016 = 0;
+u16 var_1017 = 0;
+u16 var_1018 = 0;
+u16 var_1019 = 0;
+u16 var_1020 = 0;
+u16 var_1021 = 0;
+u16 var_1022 = 0;
+u16 var_1023 = 0;
+u16 var_1024 = 0;
+u16 var_1025 = 0;
+u16 var_1026 = 0;
+u16 var_1027 = 0;
+u16 var_1028 = 0;
+u16 var_1029 = 0;
+u16 var_1030 = 0;
+u16 var_1031 = 0;
+u16 var_1032 = 0;
+u16 var_1033 = 0;
+u16 var_1034 = 0;
+u16 var_1035 = 0;
+u16 var_1036 = 0;
+u16 var_1037 = 0;
+u16 var_1038 = 0;
+u16 var_1039 = 0;
+u16 var_1040 = 0;
+u16 var_1041 = 0;
+u16 var_1042 = 0;
+u16 var_1043 = 0;
+u16 var_1044 = 0;
+u16 var_1045 = 0;
+u16 var_1046 = 0;
+u16 var_1047 = 0;
+u16 var_1048 = 0;
+u16 var_1049 = 0;
+u16 var_1050 = 0;
+u16 var_1051 = 0;
+u16 var_1052 = 0;
+u16 var_1053 = 0;
+u16 var_1054 = 0;
+u16 var_1055 = 0;
+u16 var_1056 = 0;
+u16 var_1057 = 0;
+u16 var_1058 = 0;
+u16 var_1059 = 0;
+u16 var_1060 = 0;
+u16 var_1061 = 0;
+u16 var_1062 = 0;
+u16 var_1063 = 0;
+u16 var_1064 = 0;
+u16 var_1065 = 0;
+u16 var_1066 = 0;
+u16 var_1067 = 0;
+u16 var_1068 = 0;
+u16 var_1069 = 0;
+u16 var_1070 = 0;
+u16 var_1071 = 0;
+u16 var_1072 = 0;
+u16 var_1073 = 0;
+u16 var_1074 = 0;
+u16 var_1075 = 0;
+u16 var_1076 = 0;
+u16 var_1077 = 0;
+u16 var_1078 = 0;
+u16 var_1079 = 0;
+u16 var_1080 = 0;
+u16 var_1081 = 0;
+u16 var_1082 = 0;
+u16 var_1083 = 0;
+u16 var_1084 = 0;
+u16 var_1085 = 0;
+u16 var_1086 = 0;
+u16 var_1087 = 0;
+u16 var_1088 = 0;
+u16 var_1089 = 0;
+u16 var_1090 = 0;
+u16 var_1091 = 0;
+u16 var_1092 = 0;
+u16 var_1093 = 0;
+u16 var_1094 = 0;
+u16 var_1095 = 0;
+u16 var_1096 = 0;
+u16 var_1097 = 0;
+u16 var_1098 = 0;
+u16 var_1099 = 0;
+u16 var_1100 = 0;
+u16 var_1101 = 0;
+u16 var_1102 = 0;
+u16 var_1103 = 0;
+u16 var_1104 = 0;
+u16 var_1105 = 0;
+u16 var_1106 = 0;
+u16 var_1107 = 0;
+u16 var_1108 = 0;
+u16 var_1109 = 0;
+u16 var_1110 = 0;
+u16 var_1111 = 0;
+u16 var_1112 = 0;
+u16 var_1113 = 0;
+u16 var_1114 = 0;
+u16 var_1115 = 0;
+u16 var_1116 = 0;
+u16 var_1117 = 0;
+u16 var_1118 = 0;
+u16 var_1119 = 0;
+u16 var_1120 = 0;
+u16 var_1121 = 0;
+u16 var_1122 = 0;
+u16 var_1123 = 0;
+u16 var_1124 = 0;
+u16 var_1125 = 0;
+u16 var_1126 = 0;
+u16 var_1127 = 0;
+u16 var_1128 = 0;
+u16 var_1129 = 0;
+u16 var_1130 = 0;
+u16 var_1131 = 0;
+u16 var_1132 = 0;
+u16 var_1133 = 0;
+u16 var_1134 = 0;
+u16 var_1135 = 0;
+u16 var_1136 = 0;
+u16 var_1137 = 0;
+u16 var_1138 = 0;
+u16 var_1139 = 0;
+u16 var_1140 = 0;
+u16 var_1141 = 0;
+u16 var_1142 = 0;
+u16 var_1143 = 0;
+u16 var_1144 = 0;
+u16 var_1145 = 0;
+u16 var_1146 = 0;
+u16 var_1147 = 0;
+u16 var_1148 = 0;
+u16 var_1149 = 0;
+u16 var_1150 = 0;
+u16 var_1151 = 0;
+u16 var_1152 = 0;
+u16 var_1153 = 0;
+u16 var_1154 = 0;
+u16 var_1155 = 0;
+u16 var_1156 = 0;
+u16 var_1157 = 0;
+u16 var_1158 = 0;
+u16 var_1159 = 0;
+u16 var_1160 = 0;
+u16 var_1161 = 0;
+u16 var_1162 = 0;
+u16 var_1163 = 0;
+u16 var_1164 = 0;
+u16 var_1165 = 0;
+u16 var_1166 = 0;
+u16 var_1167 = 0;
+u16 var_1168 = 0;
+u16 var_1169 = 0;
+u16 var_1170 = 0;
+u16 var_1171 = 0;
+u16 var_1172 = 0;
+u16 var_1173 = 0;
+u16 var_1174 = 0;
+u16 var_1175 = 0;
+u16 var_1176 = 0;
+u16 var_1177 = 0;
+u16 var_1178 = 0;
+u16 var_1179 = 0;
+u16 var_1180 = 0;
+u16 var_1181 = 0;
+u16 var_1182 = 0;
+u16 var_1183 = 0;
+u16 var_1184 = 0;
+u16 var_1185 = 0;
+u16 var_1186 = 0;
+u16 var_1187 = 0;
+u16 var_1188 = 0;
+u16 var_1189 = 0;
+u16 var_1190 = 0;
+u16 var_1191 = 0;
+u16 var_1192 = 0;
+u16 var_1193 = 0;
+u16 var_1194 = 0;
+u16 var_1195 = 0;
+u16 var_1196 = 0;
+u16 var_1197 = 0;
+u16 var_1198 = 0;
+u16 var_1199 = 0;
+u16 var_1200 = 0;
+u16 var_1201 = 0;
+u16 var_1202 = 0;
+u16 var_1203 = 0;
+u16 var_1204 = 0;
+u16 var_1205 = 0;
+u16 var_1206 = 0;
+u16 var_1207 = 0;
+u16 var_1208 = 0;
+u16 var_1209 = 0;
+u16 var_1210 = 0;
+u16 var_1211 = 0;
+u16 var_1212 = 0;
+u16 var_1213 = 0;
+u16 var_1214 = 0;
+u16 var_1215 = 0;
+u16 var_1216 = 0;
+u16 var_1217 = 0;
+u16 var_1218 = 0;
+u16 var_1219 = 0;
+u16 var_1220 = 0;
+u16 var_1221 = 0;
+u16 var_1222 = 0;
+u16 var_1223 = 0;
+u16 var_1224 = 0;
+u16 var_1225 = 0;
+u16 var_1226 = 0;
+u16 var_1227 = 0;
+u16 var_1228 = 0;
+u16 var_1229 = 0;
+u16 var_1230 = 0;
+u16 var_1231 = 0;
+u16 var_1232 = 0;
+u16 var_1233 = 0;
+u16 var_1234 = 0;
+u16 var_1235 = 0;
+u16 var_1236 = 0;
+u16 var_1237 = 0;
+u16 var_1238 = 0;
+u16 var_1239 = 0;
+u16 var_1240 = 0;
+u16 var_1241 = 0;
+u16 var_1242 = 0;
+u16 var_1243 = 0;
+u16 var_1244 = 0;
+u16 var_1245 = 0;
+u16 var_1246 = 0;
+u16 var_1247 = 0;
+u16 var_1248 = 0;
+u16 var_1249 = 0;
+u16 var_1250 = 0;
+u16 var_1251 = 0;
+u16 var_1252 = 0;
+u16 var_1253 = 0;
+u16 var_1254 = 0;
+u16 var_1255 = 0;
+u16 var_1256 = 0;
+u16 var_1257 = 0;
+u16 var_1258 = 0;
+u16 var_1259 = 0;
+u16 var_1260 = 0;
+u16 var_1261 = 0;
+u16 var_1262 = 0;
+u16 var_1263 = 0;
+u16 var_1264 = 0;
+u16 var_1265 = 0;
+u16 var_1266 = 0;
+u16 var_1267 = 0;
+u16 var_1268 = 0;
+u16 var_1269 = 0;
+u16 var_1270 = 0;
+u16 var_1271 = 0;
+u16 var_1272 = 0;
+u16 var_1273 = 0;
+u16 var_1274 = 0;
+u16 var_1275 = 0;
+u16 var_1276 = 0;
+u16 var_1277 = 0;
+u16 var_1278 = 0;
+u16 var_1279 = 0;
+u16 var_1280 = 0;
+u16 var_1281 = 0;
+u16 var_1282 = 0;
+u16 var_1283 = 0;
+u16 var_1284 = 0;
+u16 var_1285 = 0;
+u16 var_1286 = 0;
+u16 var_1287 = 0;
+u16 var_1288 = 0;
+u16 var_1289 = 0;
+u16 var_1290 = 0;
+u16 var_1291 = 0;
+u16 var_1292 = 0;
+u16 var_1293 = 0;
+u16 var_1294 = 0;
+u16 var_1295 = 0;
+u16 var_1296 = 0;
+u16 var_1297 = 0;
+u16 var_1298 = 0;
+u16 var_1299 = 0;
+u16 var_1300 = 0;
+u16 var_1301 = 0;
+u16 var_1302 = 0;
+u16 var_1303 = 0;
+u16 var_1304 = 0;
+u16 var_1305 = 0;
+u16 var_1306 = 0;
+u16 var_1307 = 0;
+u16 var_1308 = 0;
+u16 var_1309 = 0;
+u16 var_1310 = 0;
+u16 var_1311 = 0;
+u16 var_1312 = 0;
+u16 var_1313 = 0;
+u16 var_1314 = 0;
+u16 var_1315 = 0;
+u16 var_1316 = 0;
+u16 var_1317 = 0;
+u16 var_1318 = 0;
+u16 var_1319 = 0;
+u16 var_1320 = 0;
+u16 var_1321 = 0;
+u16 var_1322 = 0;
+u16 var_1323 = 0;
+u16 var_1324 = 0;
+u16 var_1325 = 0;
+u16 var_1326 = 0;
+u16 var_1327 = 0;
+u16 var_1328 = 0;
+u16 var_1329 = 0;
+u16 var_1330 = 0;
+u16 var_1331 = 0;
+u16 var_1332 = 0;
+u16 var_1333 = 0;
+u16 var_1334 = 0;
+u16 var_1335 = 0;
+u16 var_1336 = 0;
+u16 var_1337 = 0;
+u16 var_1338 = 0;
+u16 var_1339 = 0;
+u16 var_1340 = 0;
+u16 var_1341 = 0;
+u16 var_1342 = 0;
+u16 var_1343 = 0;
+u16 var_1344 = 0;
+u16 var_1345 = 0;
+u16 var_1346 = 0;
+u16 var_1347 = 0;
+u16 var_1348 = 0;
+u16 var_1349 = 0;
+u16 var_1350 = 0;
+u16 var_1351 = 0;
+u16 var_1352 = 0;
+u16 var_1353 = 0;
+u16 var_1354 = 0;
+u16 var_1355 = 0;
+u16 var_1356 = 0;
+u16 var_1357 = 0;
+u16 var_1358 = 0;
+u16 var_1359 = 0;
+u16 var_1360 = 0;
+u16 var_1361 = 0;
+u16 var_1362 = 0;
+u16 var_1363 = 0;
+u16 var_1364 = 0;
+u16 var_1365 = 0;
+u16 var_1366 = 0;
+u16 var_1367 = 0;
+u16 var_1368 = 0;
+u16 var_1369 = 0;
+u16 var_1370 = 0;
+u16 var_1371 = 0;
+u16 var_1372 = 0;
+u16 var_1373 = 0;
+u16 var_1374 = 0;
+u16 var_1375 = 0;
+u16 var_1376 = 0;
+u16 var_1377 = 0;
+u16 var_1378 = 0;
+u16 var_1379 = 0;
+u16 var_1380 = 0;
+u16 var_1381 = 0;
+u16 var_1382 = 0;
+u16 var_1383 = 0;
+u16 var_1384 = 0;
+u16 var_1385 = 0;
+u16 var_1386 = 0;
+u16 var_1387 = 0;
+u16 var_1388 = 0;
+u16 var_1389 = 0;
+u16 var_1390 = 0;
+u16 var_1391 = 0;
+u16 var_1392 = 0;
+u16 var_1393 = 0;
+u16 var_1394 = 0;
+u16 var_1395 = 0;
+u16 var_1396 = 0;
+u16 var_1397 = 0;
+u16 var_1398 = 0;
+u16 var_1399 = 0;
+u16 var_1400 = 0;
+u16 var_1401 = 0;
+u16 var_1402 = 0;
+u16 var_1403 = 0;
+u16 var_1404 = 0;
+u16 var_1405 = 0;
+u16 var_1406 = 0;
+u16 var_1407 = 0;
+u16 var_1408 = 0;
+u16 var_1409 = 0;
+u16 var_1410 = 0;
+u16 var_1411 = 0;
+u16 var_1412 = 0;
+u16 var_1413 = 0;
+u16 var_1414 = 0;
+u16 var_1415 = 0;
+u16 var_1416 = 0;
+u16 var_1417 = 0;
+u16 var_1418 = 0;
+u16 var_1419 = 0;
+u16 var_1420 = 0;
+u16 var_1421 = 0;
+u16 var_1422 = 0;
+u16 var_1423 = 0;
+u16 var_1424 = 0;
+u16 var_1425 = 0;
+u16 var_1426 = 0;
+u16 var_1427 = 0;
+u16 var_1428 = 0;
+u16 var_1429 = 0;
+u16 var_1430 = 0;
+u16 var_1431 = 0;
+u16 var_1432 = 0;
+u16 var_1433 = 0;
+u16 var_1434 = 0;
+u16 var_1435 = 0;
+u16 var_1436 = 0;
+u16 var_1437 = 0;
+u16 var_1438 = 0;
+u16 var_1439 = 0;
+u16 var_1440 = 0;
+u16 var_1441 = 0;
+u16 var_1442 = 0;
+u16 var_1443 = 0;
+u16 var_1444 = 0;
+u16 var_1445 = 0;
+u16 var_1446 = 0;
+u16 var_1447 = 0;
+u16 var_1448 = 0;
+u16 var_1449 = 0;
+u16 var_1450 = 0;
+u16 var_1451 = 0;
+u16 var_1452 = 0;
+u16 var_1453 = 0;
+u16 var_1454 = 0;
+u16 var_1455 = 0;
+u16 var_1456 = 0;
+u16 var_1457 = 0;
+u16 var_1458 = 0;
+u16 var_1459 = 0;
+u16 var_1460 = 0;
+u16 var_1461 = 0;
+u16 var_1462 = 0;
+u16 var_1463 = 0;
+u16 var_1464 = 0;
+u16 var_1465 = 0;
+u16 var_1466 = 0;
+u16 var_1467 = 0;
+u16 var_1468 = 0;
+u16 var_1469 = 0;
+u16 var_1470 = 0;
+u16 var_1471 = 0;
+u16 var_1472 = 0;
+u16 var_1473 = 0;
+u16 var_1474 = 0;
+u16 var_1475 = 0;
+u16 var_1476 = 0;
+u16 var_1477 = 0;
+u16 var_1478 = 0;
+u16 var_1479 = 0;
+u16 var_1480 = 0;
+u16 var_1481 = 0;
+u16 var_1482 = 0;
+u16 var_1483 = 0;
+u16 var_1484 = 0;
+u16 var_1485 = 0;
+u16 var_1486 = 0;
+u16 var_1487 = 0;
+u16 var_1488 = 0;
+u16 var_1489 = 0;
+u16 var_1490 = 0;
+u16 var_1491 = 0;
+u16 var_1492 = 0;
+u16 var_1493 = 0;
+u16 var_1494 = 0;
+u16 var_1495 = 0;
+u16 var_1496 = 0;
+u16 var_1497 = 0;
+u16 var_1498 = 0;
+u16 var_1499 = 0;
+u16 var_1500 = 0;
+u16 var_1501 = 0;
+u16 var_1502 = 0;
+u16 var_1503 = 0;
+u16 var_1504 = 0;
+u16 var_1505 = 0;
+u16 var_1506 = 0;
+u16 var_1507 = 0;
+u16 var_1508 = 0;
+u16 var_1509 = 0;
+u16 var_1510 = 0;
+u16 var_1511 = 0;
+u16 var_1512 = 0;
+u16 var_1513 = 0;
+u16 var_1514 = 0;
+u16 var_1515 = 0;
+u16 var_1516 = 0;
+u16 var_1517 = 0;
+u16 var_1518 = 0;
+u16 var_1519 = 0;
+u16 var_1520 = 0;
+u16 var_1521 = 0;
+u16 var_1522 = 0;
+u16 var_1523 = 0;
+u16 var_1524 = 0;
+u16 var_1525 = 0;
+u16 var_1526 = 0;
+u16 var_1527 = 0;
+u16 var_1528 = 0;
+u16 var_1529 = 0;
+u16 var_1530 = 0;
+u16 var_1531 = 0;
+u16 var_1532 = 0;
+u16 var_1533 = 0;
+u16 var_1534 = 0;
+u16 var_1535 = 0;
+u16 var_1536 = 0;
+u16 var_1537 = 0;
+u16 var_1538 = 0;
+u16 var_1539 = 0;
+u16 var_1540 = 0;
+u16 var_1541 = 0;
+u16 var_1542 = 0;
+u16 var_1543 = 0;
+u16 var_1544 = 0;
+u16 var_1545 = 0;
+u16 var_1546 = 0;
+u16 var_1547 = 0;
+u16 var_1548 = 0;
+u16 var_1549 = 0;
+u16 var_1550 = 0;
+u16 var_1551 = 0;
+u16 var_1552 = 0;
+u16 var_1553 = 0;
+u16 var_1554 = 0;
+u16 var_1555 = 0;
+u16 var_1556 = 0;
+u16 var_1557 = 0;
+u16 var_1558 = 0;
+u16 var_1559 = 0;
+u16 var_1560 = 0;
+u16 var_1561 = 0;
+u16 var_1562 = 0;
+u16 var_1563 = 0;
+u16 var_1564 = 0;
+u16 var_1565 = 0;
+u16 var_1566 = 0;
+u16 var_1567 = 0;
+u16 var_1568 = 0;
+u16 var_1569 = 0;
+u16 var_1570 = 0;
+u16 var_1571 = 0;
+u16 var_1572 = 0;
+u16 var_1573 = 0;
+u16 var_1574 = 0;
+u16 var_1575 = 0;
+u16 var_1576 = 0;
+u16 var_1577 = 0;
+u16 var_1578 = 0;
+u16 var_1579 = 0;
+u16 var_1580 = 0;
+u16 var_1581 = 0;
+u16 var_1582 = 0;
+u16 var_1583 = 0;
+u16 var_1584 = 0;
+u16 var_1585 = 0;
+u16 var_1586 = 0;
+u16 var_1587 = 0;
+u16 var_1588 = 0;
+u16 var_1589 = 0;
+u16 var_1590 = 0;
+u16 var_1591 = 0;
+u16 var_1592 = 0;
+u16 var_1593 = 0;
+u16 var_1594 = 0;
+u16 var_1595 = 0;
+u16 var_1596 = 0;
+u16 var_1597 = 0;
+u16 var_1598 = 0;
+u16 var_1599 = 0;
+u16 var_1600 = 0;
+u16 var_1601 = 0;
+u16 var_1602 = 0;
+u16 var_1603 = 0;
+u16 var_1604 = 0;
+u16 var_1605 = 0;
+u16 var_1606 = 0;
+u16 var_1607 = 0;
+u16 var_1608 = 0;
+u16 var_1609 = 0;
+u16 var_1610 = 0;
+u16 var_1611 = 0;
+u16 var_1612 = 0;
+u16 var_1613 = 0;
+u16 var_1614 = 0;
+u16 var_1615 = 0;
+u16 var_1616 = 0;
+u16 var_1617 = 0;
+u16 var_1618 = 0;
+u16 var_1619 = 0;
+u16 var_1620 = 0;
+u16 var_1621 = 0;
+u16 var_1622 = 0;
+u16 var_1623 = 0;
+u16 var_1624 = 0;
+u16 var_1625 = 0;
+u16 var_1626 = 0;
+u16 var_1627 = 0;
+u16 var_1628 = 0;
+u16 var_1629 = 0;
+u16 var_1630 = 0;
+u16 var_1631 = 0;
+u16 var_1632 = 0;
+u16 var_1633 = 0;
+u16 var_1634 = 0;
+u16 var_1635 = 0;
+u16 var_1636 = 0;
+u16 var_1637 = 0;
+u16 var_1638 = 0;
+u16 var_1639 = 0;
+u16 var_1640 = 0;
+u16 var_1641 = 0;
+u16 var_1642 = 0;
+u16 var_1643 = 0;
+u16 var_1644 = 0;
+u16 var_1645 = 0;
+u16 var_1646 = 0;
+u16 var_1647 = 0;
+u16 var_1648 = 0;
+u16 var_1649 = 0;
+u16 var_1650 = 0;
+u16 var_1651 = 0;
+u16 var_1652 = 0;
+u16 var_1653 = 0;
+u16 var_1654 = 0;
+u16 var_1655 = 0;
+u16 var_1656 = 0;
+u16 var_1657 = 0;
+u16 var_1658 = 0;
+u16 var_1659 = 0;
+u16 var_1660 = 0;
+u16 var_1661 = 0;
+u16 var_1662 = 0;
+u16 var_1663 = 0;
+u16 var_1664 = 0;
+u16 var_1665 = 0;
+u16 var_1666 = 0;
+u16 var_1667 = 0;
+u16 var_1668 = 0;
+u16 var_1669 = 0;
+u16 var_1670 = 0;
+u16 var_1671 = 0;
+u16 var_1672 = 0;
+u16 var_1673 = 0;
+u16 var_1674 = 0;
+u16 var_1675 = 0;
+u16 var_1676 = 0;
+u16 var_1677 = 0;
+u16 var_1678 = 0;
+u16 var_1679 = 0;
+u16 var_1680 = 0;
+u16 var_1681 = 0;
+u16 var_1682 = 0;
+u16 var_1683 = 0;
+u16 var_1684 = 0;
+u16 var_1685 = 0;
+u16 var_1686 = 0;
+u16 var_1687 = 0;
+u16 var_1688 = 0;
+u16 var_1689 = 0;
+u16 var_1690 = 0;
+u16 var_1691 = 0;
+u16 var_1692 = 0;
+u16 var_1693 = 0;
+u16 var_1694 = 0;
+u16 var_1695 = 0;
+u16 var_1696 = 0;
+u16 var_1697 = 0;
+u16 var_1698 = 0;
+u16 var_1699 = 0;
+u16 var_1700 = 0;
+u16 var_1701 = 0;
+u16 var_1702 = 0;
+u16 var_1703 = 0;
+u16 var_1704 = 0;
+u16 var_1705 = 0;
+u16 var_1706 = 0;
+u16 var_1707 = 0;
+u16 var_1708 = 0;
+u16 var_1709 = 0;
+u16 var_1710 = 0;
+u16 var_1711 = 0;
+u16 var_1712 = 0;
+u16 var_1713 = 0;
+u16 var_1714 = 0;
+u16 var_1715 = 0;
+u16 var_1716 = 0;
+u16 var_1717 = 0;
+u16 var_1718 = 0;
+u16 var_1719 = 0;
+u16 var_1720 = 0;
+u16 var_1721 = 0;
+u16 var_1722 = 0;
+u16 var_1723 = 0;
+u16 var_1724 = 0;
+u16 var_1725 = 0;
+u16 var_1726 = 0;
+u16 var_1727 = 0;
+u16 var_1728 = 0;
+u16 var_1729 = 0;
+u16 var_1730 = 0;
+u16 var_1731 = 0;
+u16 var_1732 = 0;
+u16 var_1733 = 0;
+u16 var_1734 = 0;
+u16 var_1735 = 0;
+u16 var_1736 = 0;
+u16 var_1737 = 0;
+u16 var_1738 = 0;
+u16 var_1739 = 0;
+u16 var_1740 = 0;
+u16 var_1741 = 0;
+u16 var_1742 = 0;
+u16 var_1743 = 0;
+u16 var_1744 = 0;
+u16 var_1745 = 0;
+u16 var_1746 = 0;
+u16 var_1747 = 0;
+u16 var_1748 = 0;
+u16 var_1749 = 0;
+u16 var_1750 = 0;
+u16 var_1751 = 0;
+u16 var_1752 = 0;
+u16 var_1753 = 0;
+u16 var_1754 = 0;
+u16 var_1755 = 0;
+u16 var_1756 = 0;
+u16 var_1757 = 0;
+u16 var_1758 = 0;
+u16 var_1759 = 0;
+u16 var_1760 = 0;
+u16 var_1761 = 0;
+u16 var_1762 = 0;
+u16 var_1763 = 0;
+u16 var_1764 = 0;
+u16 var_1765 = 0;
+u16 var_1766 = 0;
+u16 var_1767 = 0;
+u16 var_1768 = 0;
+u16 var_1769 = 0;
+u16 var_1770 = 0;
+u16 var_1771 = 0;
+u16 var_1772 = 0;
+u16 var_1773 = 0;
+u16 var_1774 = 0;
+u16 var_1775 = 0;
+u16 var_1776 = 0;
+u16 var_1777 = 0;
+u16 var_1778 = 0;
+u16 var_1779 = 0;
+u16 var_1780 = 0;
+u16 var_1781 = 0;
+u16 var_1782 = 0;
+u16 var_1783 = 0;
+u16 var_1784 = 0;
+u16 var_1785 = 0;
+u16 var_1786 = 0;
+u16 var_1787 = 0;
+u16 var_1788 = 0;
+u16 var_1789 = 0;
+u16 var_1790 = 0;
+u16 var_1791 = 0;
+u16 var_1792 = 0;
+u16 var_1793 = 0;
+u16 var_1794 = 0;
+u16 var_1795 = 0;
+u16 var_1796 = 0;
+u16 var_1797 = 0;
+u16 var_1798 = 0;
+u16 var_1799 = 0;
+u16 var_1800 = 0;
+u16 var_1801 = 0;
+u16 var_1802 = 0;
+u16 var_1803 = 0;
+u16 var_1804 = 0;
+u16 var_1805 = 0;
+u16 var_1806 = 0;
+u16 var_1807 = 0;
+u16 var_1808 = 0;
+u16 var_1809 = 0;
+u16 var_1810 = 0;
+u16 var_1811 = 0;
+u16 var_1812 = 0;
+u16 var_1813 = 0;
+u16 var_1814 = 0;
+u16 var_1815 = 0;
+u16 var_1816 = 0;
+u16 var_1817 = 0;
+u16 var_1818 = 0;
+u16 var_1819 = 0;
+u16 var_1820 = 0;
+u16 var_1821 = 0;
+u16 var_1822 = 0;
+u16 var_1823 = 0;
+u16 var_1824 = 0;
+u16 var_1825 = 0;
+u16 var_1826 = 0;
+u16 var_1827 = 0;
+u16 var_1828 = 0;
+u16 var_1829 = 0;
+u16 var_1830 = 0;
+u16 var_1831 = 0;
+u16 var_1832 = 0;
+u16 var_1833 = 0;
+u16 var_1834 = 0;
+u16 var_1835 = 0;
+u16 var_1836 = 0;
+u16 var_1837 = 0;
+u16 var_1838 = 0;
+u16 var_1839 = 0;
+u16 var_1840 = 0;
+u16 var_1841 = 0;
+u16 var_1842 = 0;
+u16 var_1843 = 0;
+u16 var_1844 = 0;
+u16 var_1845 = 0;
+u16 var_1846 = 0;
+u16 var_1847 = 0;
+u16 var_1848 = 0;
+u16 var_1849 = 0;
+u16 var_1850 = 0;
+u16 var_1851 = 0;
+u16 var_1852 = 0;
+u16 var_1853 = 0;
+u16 var_1854 = 0;
+u16 var_1855 = 0;
+u16 var_1856 = 0;
+u16 var_1857 = 0;
+u16 var_1858 = 0;
+u16 var_1859 = 0;
+u16 var_1860 = 0;
+u16 var_1861 = 0;
+u16 var_1862 = 0;
+u16 var_1863 = 0;
+u16 var_1864 = 0;
+u16 var_1865 = 0;
+u16 var_1866 = 0;
+u16 var_1867 = 0;
+u16 var_1868 = 0;
+u16 var_1869 = 0;
+u16 var_1870 = 0;
+u16 var_1871 = 0;
+u16 var_1872 = 0;
+u16 var_1873 = 0;
+u16 var_1874 = 0;
+u16 var_1875 = 0;
+u16 var_1876 = 0;
+u16 var_1877 = 0;
+u16 var_1878 = 0;
+u16 var_1879 = 0;
+u16 var_1880 = 0;
+u16 var_1881 = 0;
+u16 var_1882 = 0;
+u16 var_1883 = 0;
+u16 var_1884 = 0;
+u16 var_1885 = 0;
+u16 var_1886 = 0;
+u16 var_1887 = 0;
+u16 var_1888 = 0;
+u16 var_1889 = 0;
+u16 var_1890 = 0;
+u16 var_1891 = 0;
+u16 var_1892 = 0;
+u16 var_1893 = 0;
+u16 var_1894 = 0;
+u16 var_1895 = 0;
+u16 var_1896 = 0;
+u16 var_1897 = 0;
+u16 var_1898 = 0;
+u16 var_1899 = 0;
+u16 var_1900 = 0;
+u16 var_1901 = 0;
+u16 var_1902 = 0;
+u16 var_1903 = 0;
+u16 var_1904 = 0;
+u16 var_1905 = 0;
+u16 var_1906 = 0;
+u16 var_1907 = 0;
+u16 var_1908 = 0;
+u16 var_1909 = 0;
+u16 var_1910 = 0;
+u16 var_1911 = 0;
+u16 var_1912 = 0;
+u16 var_1913 = 0;
+u16 var_1914 = 0;
+u16 var_1915 = 0;
+u16 var_1916 = 0;
+u16 var_1917 = 0;
+u16 var_1918 = 0;
+u16 var_1919 = 0;
+u16 var_1920 = 0;
+u16 var_1921 = 0;
+u16 var_1922 = 0;
+u16 var_1923 = 0;
+u16 var_1924 = 0;
+u16 var_1925 = 0;
+u16 var_1926 = 0;
+u16 var_1927 = 0;
+u16 var_1928 = 0;
+u16 var_1929 = 0;
+u16 var_1930 = 0;
+u16 var_1931 = 0;
+u16 var_1932 = 0;
+u16 var_1933 = 0;
+u16 var_1934 = 0;
+u16 var_1935 = 0;
+u16 var_1936 = 0;
+u16 var_1937 = 0;
+u16 var_1938 = 0;
+u16 var_1939 = 0;
+u16 var_1940 = 0;
+u16 var_1941 = 0;
+u16 var_1942 = 0;
+u16 var_1943 = 0;
+u16 var_1944 = 0;
+u16 var_1945 = 0;
+u16 var_1946 = 0;
+u16 var_1947 = 0;
+u16 var_1948 = 0;
+u16 var_1949 = 0;
+u16 var_1950 = 0;
+u16 var_1951 = 0;
+u16 var_1952 = 0;
+u16 var_1953 = 0;
+u16 var_1954 = 0;
+u16 var_1955 = 0;
+u16 var_1956 = 0;
+u16 var_1957 = 0;
+u16 var_1958 = 0;
+u16 var_1959 = 0;
+u16 var_1960 = 0;
+u16 var_1961 = 0;
+u16 var_1962 = 0;
+u16 var_1963 = 0;
+u16 var_1964 = 0;
+u16 var_1965 = 0;
+u16 var_1966 = 0;
+u16 var_1967 = 0;
+u16 var_1968 = 0;
+u16 var_1969 = 0;
+u16 var_1970 = 0;
+u16 var_1971 = 0;
+u16 var_1972 = 0;
+u16 var_1973 = 0;
+u16 var_1974 = 0;
+u16 var_1975 = 0;
+u16 var_1976 = 0;
+u16 var_1977 = 0;
+u16 var_1978 = 0;
+u16 var_1979 = 0;
+u16 var_1980 = 0;
+u16 var_1981 = 0;
+u16 var_1982 = 0;
+u16 var_1983 = 0;
+u16 var_1984 = 0;
+u16 var_1985 = 0;
+u16 var_1986 = 0;
+u16 var_1987 = 0;
+u16 var_1988 = 0;
+u16 var_1989 = 0;
+u16 var_1990 = 0;
+u16 var_1991 = 0;
+u16 var_1992 = 0;
+u16 var_1993 = 0;
+u16 var_1994 = 0;
+u16 var_1995 = 0;
+u16 var_1996 = 0;
+u16 var_1997 = 0;
+u16 var_1998 = 0;
+u16 var_1999 = 0;
+u16 var_2000 = 0;
+u16 var_2001 = 0;
+u16 var_2002 = 0;
+u16 var_2003 = 0;
+u16 var_2004 = 0;
+u16 var_2005 = 0;
+u16 var_2006 = 0;
+u16 var_2007 = 0;
+u16 var_2008 = 0;
+u16 var_2009 = 0;
+u16 var_2010 = 0;
+u16 var_2011 = 0;
+u16 var_2012 = 0;
+u16 var_2013 = 0;
+u16 var_2014 = 0;
+u16 var_2015 = 0;
+u16 var_2016 = 0;
+u16 var_2017 = 0;
+u16 var_2018 = 0;
+u16 var_2019 = 0;
+u16 var_2020 = 0;
+u16 var_2021 = 0;
+u16 var_2022 = 0;
+u16 var_2023 = 0;
+u16 var_2024 = 0;
+u16 var_2025 = 0;
+u16 var_2026 = 0;
+u16 var_2027 = 0;
+u16 var_2028 = 0;
+u16 var_2029 = 0;
+u16 var_2030 = 0;
+u16 var_2031 = 0;
+u16 var_2032 = 0;
+u16 var_2033 = 0;
+u16 var_2034 = 0;
+u16 var_2035 = 0;
+u16 var_2036 = 0;
+u16 var_2037 = 0;
+u16 var_2038 = 0;
+u16 var_2039 = 0;
+u16 var_2040 = 0;
+u16 var_2041 = 0;
+u16 var_2042 = 0;
+u16 var_2043 = 0;
+u16 var_2044 = 0;
+u16 var_2045 = 0;
+u16 var_2046 = 0;
+u16 var_2047 = 0;
+u16 var_2048 = 0;
+u16 var_2049 = 0;
+u16 var_2050 = 0;
+u16 var_2051 = 0;
+u16 var_2052 = 0;
+u16 var_2053 = 0;
+u16 var_2054 = 0;
+u16 var_2055 = 0;
+u16 var_2056 = 0;
+u16 var_2057 = 0;
+u16 var_2058 = 0;
+u16 var_2059 = 0;
+u16 var_2060 = 0;
+u16 var_2061 = 0;
+u16 var_2062 = 0;
+u16 var_2063 = 0;
+u16 var_2064 = 0;
+u16 var_2065 = 0;
+u16 var_2066 = 0;
+u16 var_2067 = 0;
+u16 var_2068 = 0;
+u16 var_2069 = 0;
+u16 var_2070 = 0;
+u16 var_2071 = 0;
+u16 var_2072 = 0;
+u16 var_2073 = 0;
+u16 var_2074 = 0;
+u16 var_2075 = 0;
+u16 var_2076 = 0;
+u16 var_2077 = 0;
+u16 var_2078 = 0;
+u16 var_2079 = 0;
+u16 var_2080 = 0;
+u16 var_2081 = 0;
+u16 var_2082 = 0;
+u16 var_2083 = 0;
+u16 var_2084 = 0;
+u16 var_2085 = 0;
+u16 var_2086 = 0;
+u16 var_2087 = 0;
+u16 var_2088 = 0;
+u16 var_2089 = 0;
+u16 var_2090 = 0;
+u16 var_2091 = 0;
+u16 var_2092 = 0;
+u16 var_2093 = 0;
+u16 var_2094 = 0;
+u16 var_2095 = 0;
+u16 var_2096 = 0;
+u16 var_2097 = 0;
+u16 var_2098 = 0;
+u16 var_2099 = 0;
+u16 var_2100 = 0;
+u16 var_2101 = 0;
+u16 var_2102 = 0;
+u16 var_2103 = 0;
+u16 var_2104 = 0;
+u16 var_2105 = 0;
+u16 var_2106 = 0;
+u16 var_2107 = 0;
+u16 var_2108 = 0;
+u16 var_2109 = 0;
+u16 var_2110 = 0;
+u16 var_2111 = 0;
+u16 var_2112 = 0;
+u16 var_2113 = 0;
+u16 var_2114 = 0;
+u16 var_2115 = 0;
+u16 var_2116 = 0;
+u16 var_2117 = 0;
+u16 var_2118 = 0;
+u16 var_2119 = 0;
+u16 var_2120 = 0;
+u16 var_2121 = 0;
+u16 var_2122 = 0;
+u16 var_2123 = 0;
+u16 var_2124 = 0;
+u16 var_2125 = 0;
+u16 var_2126 = 0;
+u16 var_2127 = 0;
+u16 var_2128 = 0;
+u16 var_2129 = 0;
+u16 var_2130 = 0;
+u16 var_2131 = 0;
+u16 var_2132 = 0;
+u16 var_2133 = 0;
+u16 var_2134 = 0;
+u16 var_2135 = 0;
+u16 var_2136 = 0;
+u16 var_2137 = 0;
+u16 var_2138 = 0;
+u16 var_2139 = 0;
+u16 var_2140 = 0;
+u16 var_2141 = 0;
+u16 var_2142 = 0;
+u16 var_2143 = 0;
+u16 var_2144 = 0;
+u16 var_2145 = 0;
+u16 var_2146 = 0;
+u16 var_2147 = 0;
+u16 var_2148 = 0;
+u16 var_2149 = 0;
+u16 var_2150 = 0;
+u16 var_2151 = 0;
+u16 var_2152 = 0;
+u16 var_2153 = 0;
+u16 var_2154 = 0;
+u16 var_2155 = 0;
+u16 var_2156 = 0;
+u16 var_2157 = 0;
+u16 var_2158 = 0;
+u16 var_2159 = 0;
+u16 var_2160 = 0;
+u16 var_2161 = 0;
+u16 var_2162 = 0;
+u16 var_2163 = 0;
+u16 var_2164 = 0;
+u16 var_2165 = 0;
+u16 var_2166 = 0;
+u16 var_2167 = 0;
+u16 var_2168 = 0;
+u16 var_2169 = 0;
+u16 var_2170 = 0;
+u16 var_2171 = 0;
+u16 var_2172 = 0;
+u16 var_2173 = 0;
+u16 var_2174 = 0;
+u16 var_2175 = 0;
+u16 var_2176 = 0;
+u16 var_2177 = 0;
+u16 var_2178 = 0;
+u16 var_2179 = 0;
+u16 var_2180 = 0;
+u16 var_2181 = 0;
+u16 var_2182 = 0;
+u16 var_2183 = 0;
+u16 var_2184 = 0;
+u16 var_2185 = 0;
+u16 var_2186 = 0;
+u16 var_2187 = 0;
+u16 var_2188 = 0;
+u16 var_2189 = 0;
+u16 var_2190 = 0;
+u16 var_2191 = 0;
+u16 var_2192 = 0;
+u16 var_2193 = 0;
+u16 var_2194 = 0;
+u16 var_2195 = 0;
+u16 var_2196 = 0;
+u16 var_2197 = 0;
+u16 var_2198 = 0;
+u16 var_2199 = 0;
+u16 var_2200 = 0;
+u16 var_2201 = 0;
+u16 var_2202 = 0;
+u16 var_2203 = 0;
+u16 var_2204 = 0;
+u16 var_2205 = 0;
+u16 var_2206 = 0;
+u16 var_2207 = 0;
+u16 var_2208 = 0;
+u16 var_2209 = 0;
+u16 var_2210 = 0;
+u16 var_2211 = 0;
+u16 var_2212 = 0;
+u16 var_2213 = 0;
+u16 var_2214 = 0;
+u16 var_2215 = 0;
+u16 var_2216 = 0;
+u16 var_2217 = 0;
+u16 var_2218 = 0;
+u16 var_2219 = 0;
+u16 var_2220 = 0;
+u16 var_2221 = 0;
+u16 var_2222 = 0;
+u16 var_2223 = 0;
+u16 var_2224 = 0;
+u16 var_2225 = 0;
+u16 var_2226 = 0;
+u16 var_2227 = 0;
+u16 var_2228 = 0;
+u16 var_2229 = 0;
+u16 var_2230 = 0;
+u16 var_2231 = 0;
+u16 var_2232 = 0;
+u16 var_2233 = 0;
+u16 var_2234 = 0;
+u16 var_2235 = 0;
+u16 var_2236 = 0;
+u16 var_2237 = 0;
+u16 var_2238 = 0;
+u16 var_2239 = 0;
+u16 var_2240 = 0;
+u16 var_2241 = 0;
+u16 var_2242 = 0;
+u16 var_2243 = 0;
+u16 var_2244 = 0;
+u16 var_2245 = 0;
+u16 var_2246 = 0;
+u16 var_2247 = 0;
+u16 var_2248 = 0;
+u16 var_2249 = 0;
+u16 var_2250 = 0;
+u16 var_2251 = 0;
+u16 var_2252 = 0;
+u16 var_2253 = 0;
+u16 var_2254 = 0;
+u16 var_2255 = 0;
+u16 var_2256 = 0;
+u16 var_2257 = 0;
+u16 var_2258 = 0;
+u16 var_2259 = 0;
+u16 var_2260 = 0;
+u16 var_2261 = 0;
+u16 var_2262 = 0;
+u16 var_2263 = 0;
+u16 var_2264 = 0;
+u16 var_2265 = 0;
+u16 var_2266 = 0;
+u16 var_2267 = 0;
+u16 var_2268 = 0;
+u16 var_2269 = 0;
+u16 var_2270 = 0;
+u16 var_2271 = 0;
+u16 var_2272 = 0;
+u16 var_2273 = 0;
+u16 var_2274 = 0;
+u16 var_2275 = 0;
+u16 var_2276 = 0;
+u16 var_2277 = 0;
+u16 var_2278 = 0;
+u16 var_2279 = 0;
+u16 var_2280 = 0;
+u16 var_2281 = 0;
+u16 var_2282 = 0;
+u16 var_2283 = 0;
+u16 var_2284 = 0;
+u16 var_2285 = 0;
+u16 var_2286 = 0;
+u16 var_2287 = 0;
+u16 var_2288 = 0;
+u16 var_2289 = 0;
+u16 var_2290 = 0;
+u16 var_2291 = 0;
+u16 var_2292 = 0;
+u16 var_2293 = 0;
+u16 var_2294 = 0;
+u16 var_2295 = 0;
+u16 var_2296 = 0;
+u16 var_2297 = 0;
+u16 var_2298 = 0;
+u16 var_2299 = 0;
+u16 var_2300 = 0;
+u16 var_2301 = 0;
+u16 var_2302 = 0;
+u16 var_2303 = 0;
+u16 var_2304 = 0;
+u16 var_2305 = 0;
+u16 var_2306 = 0;
+u16 var_2307 = 0;
+u16 var_2308 = 0;
+u16 var_2309 = 0;
+u16 var_2310 = 0;
+u16 var_2311 = 0;
+u16 var_2312 = 0;
+u16 var_2313 = 0;
+u16 var_2314 = 0;
+u16 var_2315 = 0;
+u16 var_2316 = 0;
+u16 var_2317 = 0;
+u16 var_2318 = 0;
+u16 var_2319 = 0;
+u16 var_2320 = 0;
+u16 var_2321 = 0;
+u16 var_2322 = 0;
+u16 var_2323 = 0;
+u16 var_2324 = 0;
+u16 var_2325 = 0;
+u16 var_2326 = 0;
+u16 var_2327 = 0;
+u16 var_2328 = 0;
+u16 var_2329 = 0;
+u16 var_2330 = 0;
+u16 var_2331 = 0;
+u16 var_2332 = 0;
+u16 var_2333 = 0;
+u16 var_2334 = 0;
+u16 var_2335 = 0;
+u16 var_2336 = 0;
+u16 var_2337 = 0;
+u16 var_2338 = 0;
+u16 var_2339 = 0;
+u16 var_2340 = 0;
+u16 var_2341 = 0;
+u16 var_2342 = 0;
+u16 var_2343 = 0;
+u16 var_2344 = 0;
+u16 var_2345 = 0;
+u16 var_2346 = 0;
+u16 var_2347 = 0;
+u16 var_2348 = 0;
+u16 var_2349 = 0;
+u16 var_2350 = 0;
+u16 var_2351 = 0;
+u16 var_2352 = 0;
+u16 var_2353 = 0;
+u16 var_2354 = 0;
+u16 var_2355 = 0;
+u16 var_2356 = 0;
+u16 var_2357 = 0;
+u16 var_2358 = 0;
+u16 var_2359 = 0;
+u16 var_2360 = 0;
+u16 var_2361 = 0;
+u16 var_2362 = 0;
+u16 var_2363 = 0;
+u16 var_2364 = 0;
+u16 var_2365 = 0;
+u16 var_2366 = 0;
+u16 var_2367 = 0;
+u16 var_2368 = 0;
+u16 var_2369 = 0;
+u16 var_2370 = 0;
+u16 var_2371 = 0;
+u16 var_2372 = 0;
+u16 var_2373 = 0;
+u16 var_2374 = 0;
+u16 var_2375 = 0;
+u16 var_2376 = 0;
+u16 var_2377 = 0;
+u16 var_2378 = 0;
+u16 var_2379 = 0;
+u16 var_2380 = 0;
+u16 var_2381 = 0;
+u16 var_2382 = 0;
+u16 var_2383 = 0;
+u16 var_2384 = 0;
+u16 var_2385 = 0;
+u16 var_2386 = 0;
+u16 var_2387 = 0;
+u16 var_2388 = 0;
+u16 var_2389 = 0;
+u16 var_2390 = 0;
+u16 var_2391 = 0;
+u16 var_2392 = 0;
+u16 var_2393 = 0;
+u16 var_2394 = 0;
+u16 var_2395 = 0;
+u16 var_2396 = 0;
+u16 var_2397 = 0;
+u16 var_2398 = 0;
+u16 var_2399 = 0;
+u16 var_2400 = 0;
+u16 var_2401 = 0;
+u16 var_2402 = 0;
+u16 var_2403 = 0;
+u16 var_2404 = 0;
+u16 var_2405 = 0;
+u16 var_2406 = 0;
+u16 var_2407 = 0;
+u16 var_2408 = 0;
+u16 var_2409 = 0;
+u16 var_2410 = 0;
+u16 var_2411 = 0;
+u16 var_2412 = 0;
+u16 var_2413 = 0;
+u16 var_2414 = 0;
+u16 var_2415 = 0;
+u16 var_2416 = 0;
+u16 var_2417 = 0;
+u16 var_2418 = 0;
+u16 var_2419 = 0;
+u16 var_2420 = 0;
+u16 var_2421 = 0;
+u16 var_2422 = 0;
+u16 var_2423 = 0;
+u16 var_2424 = 0;
+u16 var_2425 = 0;
+u16 var_2426 = 0;
+u16 var_2427 = 0;
+u16 var_2428 = 0;
+u16 var_2429 = 0;
+u16 var_2430 = 0;
+u16 var_2431 = 0;
+u16 var_2432 = 0;
+u16 var_2433 = 0;
+u16 var_2434 = 0;
+u16 var_2435 = 0;
+u16 var_2436 = 0;
+u16 var_2437 = 0;
+u16 var_2438 = 0;
+u16 var_2439 = 0;
+u16 var_2440 = 0;
+u16 var_2441 = 0;
+u16 var_2442 = 0;
+u16 var_2443 = 0;
+u16 var_2444 = 0;
+u16 var_2445 = 0;
+u16 var_2446 = 0;
+u16 var_2447 = 0;
+u16 var_2448 = 0;
+u16 var_2449 = 0;
+u16 var_2450 = 0;
+u16 var_2451 = 0;
+u16 var_2452 = 0;
+u16 var_2453 = 0;
+u16 var_2454 = 0;
+u16 var_2455 = 0;
+u16 var_2456 = 0;
+u16 var_2457 = 0;
+u16 var_2458 = 0;
+u16 var_2459 = 0;
+u16 var_2460 = 0;
+u16 var_2461 = 0;
+u16 var_2462 = 0;
+u16 var_2463 = 0;
+u16 var_2464 = 0;
+u16 var_2465 = 0;
+u16 var_2466 = 0;
+u16 var_2467 = 0;
+u16 var_2468 = 0;
+u16 var_2469 = 0;
+u16 var_2470 = 0;
+u16 var_2471 = 0;
+u16 var_2472 = 0;
+u16 var_2473 = 0;
+u16 var_2474 = 0;
+u16 var_2475 = 0;
+u16 var_2476 = 0;
+u16 var_2477 = 0;
+u16 var_2478 = 0;
+u16 var_2479 = 0;
+u16 var_2480 = 0;
+u16 var_2481 = 0;
+u16 var_2482 = 0;
+u16 var_2483 = 0;
+u16 var_2484 = 0;
+u16 var_2485 = 0;
+u16 var_2486 = 0;
+u16 var_2487 = 0;
+u16 var_2488 = 0;
+u16 var_2489 = 0;
+u16 var_2490 = 0;
+u16 var_2491 = 0;
+u16 var_2492 = 0;
+u16 var_2493 = 0;
+u16 var_2494 = 0;
+u16 var_2495 = 0;
+u16 var_2496 = 0;
+u16 var_2497 = 0;
+u16 var_2498 = 0;
+u16 var_2499 = 0;
+u16 var_2500 = 0;
+u16 var_2501 = 0;
+u16 var_2502 = 0;
+u16 var_2503 = 0;
+u16 var_2504 = 0;
+u16 var_2505 = 0;
+u16 var_2506 = 0;
+u16 var_2507 = 0;
+u16 var_2508 = 0;
+u16 var_2509 = 0;
+u16 var_2510 = 0;
+u16 var_2511 = 0;
+u16 var_2512 = 0;
+u16 var_2513 = 0;
+u16 var_2514 = 0;
+u16 var_2515 = 0;
+u16 var_2516 = 0;
+u16 var_2517 = 0;
+u16 var_2518 = 0;
+u16 var_2519 = 0;
+u16 var_2520 = 0;
+u16 var_2521 = 0;
+u16 var_2522 = 0;
+u16 var_2523 = 0;
+u16 var_2524 = 0;
+u16 var_2525 = 0;
+u16 var_2526 = 0;
+u16 var_2527 = 0;
+u16 var_2528 = 0;
+u16 var_2529 = 0;
+u16 var_2530 = 0;
+u16 var_2531 = 0;
+u16 var_2532 = 0;
+u16 var_2533 = 0;
+u16 var_2534 = 0;
+u16 var_2535 = 0;
+u16 var_2536 = 0;
+u16 var_2537 = 0;
+u16 var_2538 = 0;
+u16 var_2539 = 0;
+u16 var_2540 = 0;
+u16 var_2541 = 0;
+u16 var_2542 = 0;
+u16 var_2543 = 0;
+u16 var_2544 = 0;
+u16 var_2545 = 0;
+u16 var_2546 = 0;
+u16 var_2547 = 0;
+u16 var_2548 = 0;
+u16 var_2549 = 0;
+u16 var_2550 = 0;
+u16 var_2551 = 0;
+u16 var_2552 = 0;
+u16 var_2553 = 0;
+u16 var_2554 = 0;
+u16 var_2555 = 0;
+u16 var_2556 = 0;
+u16 var_2557 = 0;
+u16 var_2558 = 0;
+u16 var_2559 = 0;
+u16 var_2560 = 0;
+u16 var_2561 = 0;
+u16 var_2562 = 0;
+u16 var_2563 = 0;
+u16 var_2564 = 0;
+u16 var_2565 = 0;
+u16 var_2566 = 0;
+u16 var_2567 = 0;
+u16 var_2568 = 0;
+u16 var_2569 = 0;
+u16 var_2570 = 0;
+u16 var_2571 = 0;
+u16 var_2572 = 0;
+u16 var_2573 = 0;
+u16 var_2574 = 0;
+u16 var_2575 = 0;
+u16 var_2576 = 0;
+u16 var_2577 = 0;
+u16 var_2578 = 0;
+u16 var_2579 = 0;
+u16 var_2580 = 0;
+u16 var_2581 = 0;
+u16 var_2582 = 0;
+u16 var_2583 = 0;
+u16 var_2584 = 0;
+u16 var_2585 = 0;
+u16 var_2586 = 0;
+u16 var_2587 = 0;
+u16 var_2588 = 0;
+u16 var_2589 = 0;
+u16 var_2590 = 0;
+u16 var_2591 = 0;
+u16 var_2592 = 0;
+u16 var_2593 = 0;
+u16 var_2594 = 0;
+u16 var_2595 = 0;
+u16 var_2596 = 0;
+u16 var_2597 = 0;
+u16 var_2598 = 0;
+u16 var_2599 = 0;
+u16 var_2600 = 0;
+u16 var_2601 = 0;
+u16 var_2602 = 0;
+u16 var_2603 = 0;
+u16 var_2604 = 0;
+u16 var_2605 = 0;
+u16 var_2606 = 0;
+u16 var_2607 = 0;
+u16 var_2608 = 0;
+u16 var_2609 = 0;
+u16 var_2610 = 0;
+u16 var_2611 = 0;
+u16 var_2612 = 0;
+u16 var_2613 = 0;
+u16 var_2614 = 0;
+u16 var_2615 = 0;
+u16 var_2616 = 0;
+u16 var_2617 = 0;
+u16 var_2618 = 0;
+u16 var_2619 = 0;
+u16 var_2620 = 0;
+u16 var_2621 = 0;
+u16 var_2622 = 0;
+u16 var_2623 = 0;
+u16 var_2624 = 0;
+u16 var_2625 = 0;
+u16 var_2626 = 0;
+u16 var_2627 = 0;
+u16 var_2628 = 0;
+u16 var_2629 = 0;
+u16 var_2630 = 0;
+u16 var_2631 = 0;
+u16 var_2632 = 0;
+u16 var_2633 = 0;
+u16 var_2634 = 0;
+u16 var_2635 = 0;
+u16 var_2636 = 0;
+u16 var_2637 = 0;
+u16 var_2638 = 0;
+u16 var_2639 = 0;
+u16 var_2640 = 0;
+u16 var_2641 = 0;
+u16 var_2642 = 0;
+u16 var_2643 = 0;
+u16 var_2644 = 0;
+u16 var_2645 = 0;
+u16 var_2646 = 0;
+u16 var_2647 = 0;
+u16 var_2648 = 0;
+u16 var_2649 = 0;
+u16 var_2650 = 0;
+u16 var_2651 = 0;
+u16 var_2652 = 0;
+u16 var_2653 = 0;
+u16 var_2654 = 0;
+u16 var_2655 = 0;
+u16 var_2656 = 0;
+u16 var_2657 = 0;
+u16 var_2658 = 0;
+u16 var_2659 = 0;
+u16 var_2660 = 0;
+u16 var_2661 = 0;
+u16 var_2662 = 0;
+u16 var_2663 = 0;
+u16 var_2664 = 0;
+u16 var_2665 = 0;
+u16 var_2666 = 0;
+u16 var_2667 = 0;
+u16 var_2668 = 0;
+u16 var_2669 = 0;
+u16 var_2670 = 0;
+u16 var_2671 = 0;
+u16 var_2672 = 0;
+u16 var_2673 = 0;
+u16 var_2674 = 0;
+u16 var_2675 = 0;
+u16 var_2676 = 0;
+u16 var_2677 = 0;
+u16 var_2678 = 0;
+u16 var_2679 = 0;
+u16 var_2680 = 0;
+u16 var_2681 = 0;
+u16 var_2682 = 0;
+u16 var_2683 = 0;
+u16 var_2684 = 0;
+u16 var_2685 = 0;
+u16 var_2686 = 0;
+u16 var_2687 = 0;
+u16 var_2688 = 0;
+u16 var_2689 = 0;
+u16 var_2690 = 0;
+u16 var_2691 = 0;
+u16 var_2692 = 0;
+u16 var_2693 = 0;
+u16 var_2694 = 0;
+u16 var_2695 = 0;
+u16 var_2696 = 0;
+u16 var_2697 = 0;
+u16 var_2698 = 0;
+u16 var_2699 = 0;
+u16 var_2700 = 0;
+u16 var_2701 = 0;
+u16 var_2702 = 0;
+u16 var_2703 = 0;
+u16 var_2704 = 0;
+u16 var_2705 = 0;
+u16 var_2706 = 0;
+u16 var_2707 = 0;
+u16 var_2708 = 0;
+u16 var_2709 = 0;
+u16 var_2710 = 0;
+u16 var_2711 = 0;
+u16 var_2712 = 0;
+u16 var_2713 = 0;
+u16 var_2714 = 0;
+u16 var_2715 = 0;
+u16 var_2716 = 0;
+u16 var_2717 = 0;
+u16 var_2718 = 0;
+u16 var_2719 = 0;
+u16 var_2720 = 0;
+u16 var_2721 = 0;
+u16 var_2722 = 0;
+u16 var_2723 = 0;
+u16 var_2724 = 0;
+u16 var_2725 = 0;
+u16 var_2726 = 0;
+u16 var_2727 = 0;
+u16 var_2728 = 0;
+u16 var_2729 = 0;
+u16 var_2730 = 0;
+u16 var_2731 = 0;
+u16 var_2732 = 0;
+u16 var_2733 = 0;
+u16 var_2734 = 0;
+u16 var_2735 = 0;
+u16 var_2736 = 0;
+u16 var_2737 = 0;
+u16 var_2738 = 0;
+u16 var_2739 = 0;
+u16 var_2740 = 0;
+u16 var_2741 = 0;
+u16 var_2742 = 0;
+u16 var_2743 = 0;
+u16 var_2744 = 0;
+u16 var_2745 = 0;
+u16 var_2746 = 0;
+u16 var_2747 = 0;
+u16 var_2748 = 0;
+u16 var_2749 = 0;
+u16 var_2750 = 0;
+u16 var_2751 = 0;
+u16 var_2752 = 0;
+u16 var_2753 = 0;
+u16 var_2754 = 0;
+u16 var_2755 = 0;
+u16 var_2756 = 0;
+u16 var_2757 = 0;
+u16 var_2758 = 0;
+u16 var_2759 = 0;
+u16 var_2760 = 0;
+u16 var_2761 = 0;
+u16 var_2762 = 0;
+u16 var_2763 = 0;
+u16 var_2764 = 0;
+u16 var_2765 = 0;
+u16 var_2766 = 0;
+u16 var_2767 = 0;
+u16 var_2768 = 0;
+u16 var_2769 = 0;
+u16 var_2770 = 0;
+u16 var_2771 = 0;
+u16 var_2772 = 0;
+u16 var_2773 = 0;
+u16 var_2774 = 0;
+u16 var_2775 = 0;
+u16 var_2776 = 0;
+u16 var_2777 = 0;
+u16 var_2778 = 0;
+u16 var_2779 = 0;
+u16 var_2780 = 0;
+u16 var_2781 = 0;
+u16 var_2782 = 0;
+u16 var_2783 = 0;
+u16 var_2784 = 0;
+u16 var_2785 = 0;
+u16 var_2786 = 0;
+u16 var_2787 = 0;
+u16 var_2788 = 0;
+u16 var_2789 = 0;
+u16 var_2790 = 0;
+u16 var_2791 = 0;
+u16 var_2792 = 0;
+u16 var_2793 = 0;
+u16 var_2794 = 0;
+u16 var_2795 = 0;
+u16 var_2796 = 0;
+u16 var_2797 = 0;
+u16 var_2798 = 0;
+u16 var_2799 = 0;
+u16 var_2800 = 0;
+u16 var_2801 = 0;
+u16 var_2802 = 0;
+u16 var_2803 = 0;
+u16 var_2804 = 0;
+u16 var_2805 = 0;
+u16 var_2806 = 0;
+u16 var_2807 = 0;
+u16 var_2808 = 0;
+u16 var_2809 = 0;
+u16 var_2810 = 0;
+u16 var_2811 = 0;
+u16 var_2812 = 0;
+u16 var_2813 = 0;
+u16 var_2814 = 0;
+u16 var_2815 = 0;
+u16 var_2816 = 0;
+u16 var_2817 = 0;
+u16 var_2818 = 0;
+u16 var_2819 = 0;
+u16 var_2820 = 0;
+u16 var_2821 = 0;
+u16 var_2822 = 0;
+u16 var_2823 = 0;
+u16 var_2824 = 0;
+u16 var_2825 = 0;
+u16 var_2826 = 0;
+u16 var_2827 = 0;
+u16 var_2828 = 0;
+u16 var_2829 = 0;
+u16 var_2830 = 0;
+u16 var_2831 = 0;
+u16 var_2832 = 0;
+u16 var_2833 = 0;
+u16 var_2834 = 0;
+u16 var_2835 = 0;
+u16 var_2836 = 0;
+u16 var_2837 = 0;
+u16 var_2838 = 0;
+u16 var_2839 = 0;
+u16 var_2840 = 0;
+u16 var_2841 = 0;
+u16 var_2842 = 0;
+u16 var_2843 = 0;
+u16 var_2844 = 0;
+u16 var_2845 = 0;
+u16 var_2846 = 0;
+u16 var_2847 = 0;
+u16 var_2848 = 0;
+u16 var_2849 = 0;
+u16 var_2850 = 0;
+u16 var_2851 = 0;
+u16 var_2852 = 0;
+u16 var_2853 = 0;
+u16 var_2854 = 0;
+u16 var_2855 = 0;
+u16 var_2856 = 0;
+u16 var_2857 = 0;
+u16 var_2858 = 0;
+u16 var_2859 = 0;
+u16 var_2860 = 0;
+u16 var_2861 = 0;
+u16 var_2862 = 0;
+u16 var_2863 = 0;
+u16 var_2864 = 0;
+u16 var_2865 = 0;
+u16 var_2866 = 0;
+u16 var_2867 = 0;
+u16 var_2868 = 0;
+u16 var_2869 = 0;
+u16 var_2870 = 0;
+u16 var_2871 = 0;
+u16 var_2872 = 0;
+u16 var_2873 = 0;
+u16 var_2874 = 0;
+u16 var_2875 = 0;
+u16 var_2876 = 0;
+u16 var_2877 = 0;
+u16 var_2878 = 0;
+u16 var_2879 = 0;
+u16 var_2880 = 0;
+u16 var_2881 = 0;
+u16 var_2882 = 0;
+u16 var_2883 = 0;
+u16 var_2884 = 0;
+u16 var_2885 = 0;
+u16 var_2886 = 0;
+u16 var_2887 = 0;
+u16 var_2888 = 0;
+u16 var_2889 = 0;
+u16 var_2890 = 0;
+u16 var_2891 = 0;
+u16 var_2892 = 0;
+u16 var_2893 = 0;
+u16 var_2894 = 0;
+u16 var_2895 = 0;
+u16 var_2896 = 0;
+u16 var_2897 = 0;
+u16 var_2898 = 0;
+u16 var_2899 = 0;
+u16 var_2900 = 0;
+u16 var_2901 = 0;
+u16 var_2902 = 0;
+u16 var_2903 = 0;
+u16 var_2904 = 0;
+u16 var_2905 = 0;
+u16 var_2906 = 0;
+u16 var_2907 = 0;
+u16 var_2908 = 0;
+u16 var_2909 = 0;
+u16 var_2910 = 0;
+u16 var_2911 = 0;
+u16 var_2912 = 0;
+u16 var_2913 = 0;
+u16 var_2914 = 0;
+u16 var_2915 = 0;
+u16 var_2916 = 0;
+u16 var_2917 = 0;
+u16 var_2918 = 0;
+u16 var_2919 = 0;
+u16 var_2920 = 0;
+u16 var_2921 = 0;
+u16 var_2922 = 0;
+u16 var_2923 = 0;
+u16 var_2924 = 0;
+u16 var_2925 = 0;
+u16 var_2926 = 0;
+u16 var_2927 = 0;
+u16 var_2928 = 0;
+u16 var_2929 = 0;
+u16 var_2930 = 0;
+u16 var_2931 = 0;
+u16 var_2932 = 0;
+u16 var_2933 = 0;
+u16 var_2934 = 0;
+u16 var_2935 = 0;
+u16 var_2936 = 0;
+u16 var_2937 = 0;
+u16 var_2938 = 0;
+u16 var_2939 = 0;
+u16 var_2940 = 0;
+u16 var_2941 = 0;
+u16 var_2942 = 0;
+u16 var_2943 = 0;
+u16 var_2944 = 0;
+u16 var_2945 = 0;
+u16 var_2946 = 0;
+u16 var_2947 = 0;
+u16 var_2948 = 0;
+u16 var_2949 = 0;
+u16 var_2950 = 0;
+u16 var_2951 = 0;
+u16 var_2952 = 0;
+u16 var_2953 = 0;
+u16 var_2954 = 0;
+u16 var_2955 = 0;
+u16 var_2956 = 0;
+u16 var_2957 = 0;
+u16 var_2958 = 0;
+u16 var_2959 = 0;
+u16 var_2960 = 0;
+u16 var_2961 = 0;
+u16 var_2962 = 0;
+u16 var_2963 = 0;
+u16 var_2964 = 0;
+u16 var_2965 = 0;
+u16 var_2966 = 0;
+u16 var_2967 = 0;
+u16 var_2968 = 0;
+u16 var_2969 = 0;
+u16 var_2970 = 0;
+u16 var_2971 = 0;
+u16 var_2972 = 0;
+u16 var_2973 = 0;
+u16 var_2974 = 0;
+u16 var_2975 = 0;
+u16 var_2976 = 0;
+u16 var_2977 = 0;
+u16 var_2978 = 0;
+u16 var_2979 = 0;
+u16 var_2980 = 0;
+u16 var_2981 = 0;
+u16 var_2982 = 0;
+u16 var_2983 = 0;
+u16 var_2984 = 0;
+u16 var_2985 = 0;
+u16 var_2986 = 0;
+u16 var_2987 = 0;
+u16 var_2988 = 0;
+u16 var_2989 = 0;
+u16 var_2990 = 0;
+u16 var_2991 = 0;
+u16 var_2992 = 0;
+u16 var_2993 = 0;
+u16 var_2994 = 0;
+u16 var_2995 = 0;
+u16 var_2996 = 0;
+u16 var_2997 = 0;
+u16 var_2998 = 0;
+u16 var_2999 = 0;
+u16 var_3000 = 0;
+u16 var_3001 = 0;
+u16 var_3002 = 0;
+u16 var_3003 = 0;
+u16 var_3004 = 0;
+u16 var_3005 = 0;
+u16 var_3006 = 0;
+u16 var_3007 = 0;
+u16 var_3008 = 0;
+u16 var_3009 = 0;
+u16 var_3010 = 0;
+u16 var_3011 = 0;
+u16 var_3012 = 0;
+u16 var_3013 = 0;
+u16 var_3014 = 0;
+u16 var_3015 = 0;
+u16 var_3016 = 0;
+u16 var_3017 = 0;
+u16 var_3018 = 0;
+u16 var_3019 = 0;
+u16 var_3020 = 0;
+u16 var_3021 = 0;
+u16 var_3022 = 0;
+u16 var_3023 = 0;
+u16 var_3024 = 0;
+u16 var_3025 = 0;
+u16 var_3026 = 0;
+u16 var_3027 = 0;
+u16 var_3028 = 0;
+u16 var_3029 = 0;
+u16 var_3030 = 0;
+u16 var_3031 = 0;
+u16 var_3032 = 0;
+u16 var_3033 = 0;
+u16 var_3034 = 0;
+u16 var_3035 = 0;
+u16 var_3036 = 0;
+u16 var_3037 = 0;
+u16 var_3038 = 0;
+u16 var_3039 = 0;
+u16 var_3040 = 0;
+u16 var_3041 = 0;
+u16 var_3042 = 0;
+u16 var_3043 = 0;
+u16 var_3044 = 0;
+u16 var_3045 = 0;
+u16 var_3046 = 0;
+u16 var_3047 = 0;
+u16 var_3048 = 0;
+u16 var_3049 = 0;
+u16 var_3050 = 0;
+u16 var_3051 = 0;
+u16 var_3052 = 0;
+u16 var_3053 = 0;
+u16 var_3054 = 0;
+u16 var_3055 = 0;
+u16 var_3056 = 0;
+u16 var_3057 = 0;
+u16 var_3058 = 0;
+u16 var_3059 = 0;
+u16 var_3060 = 0;
+u16 var_3061 = 0;
+u16 var_3062 = 0;
+u16 var_3063 = 0;
+u16 var_3064 = 0;
+u16 var_3065 = 0;
+u16 var_3066 = 0;
+u16 var_3067 = 0;
+u16 var_3068 = 0;
+u16 var_3069 = 0;
+u16 var_3070 = 0;
+u16 var_3071 = 0;
+u16 var_3072 = 0;
+u16 var_3073 = 0;
+u16 var_3074 = 0;
+u16 var_3075 = 0;
+u16 var_3076 = 0;
+u16 var_3077 = 0;
+u16 var_3078 = 0;
+u16 var_3079 = 0;
+u16 var_3080 = 0;
+u16 var_3081 = 0;
+u16 var_3082 = 0;
+u16 var_3083 = 0;
+u16 var_3084 = 0;
+u16 var_3085 = 0;
+u16 var_3086 = 0;
+u16 var_3087 = 0;
+u16 var_3088 = 0;
+u16 var_3089 = 0;
+u16 var_3090 = 0;
+u16 var_3091 = 0;
+u16 var_3092 = 0;
+u16 var_3093 = 0;
+u16 var_3094 = 0;
+u16 var_3095 = 0;
+u16 var_3096 = 0;
+u16 var_3097 = 0;
+u16 var_3098 = 0;
+u16 var_3099 = 0;
+u16 var_3100 = 0;
+u16 var_3101 = 0;
+u16 var_3102 = 0;
+u16 var_3103 = 0;
+u16 var_3104 = 0;
+u16 var_3105 = 0;
+u16 var_3106 = 0;
+u16 var_3107 = 0;
+u16 var_3108 = 0;
+u16 var_3109 = 0;
+u16 var_3110 = 0;
+u16 var_3111 = 0;
+u16 var_3112 = 0;
+u16 var_3113 = 0;
+u16 var_3114 = 0;
+u16 var_3115 = 0;
+u16 var_3116 = 0;
+u16 var_3117 = 0;
+u16 var_3118 = 0;
+u16 var_3119 = 0;
+u16 var_3120 = 0;
+u16 var_3121 = 0;
+u16 var_3122 = 0;
+u16 var_3123 = 0;
+u16 var_3124 = 0;
+u16 var_3125 = 0;
+u16 var_3126 = 0;
+u16 var_3127 = 0;
+u16 var_3128 = 0;
+u16 var_3129 = 0;
+u16 var_3130 = 0;
+u16 var_3131 = 0;
+u16 var_3132 = 0;
+u16 var_3133 = 0;
+u16 var_3134 = 0;
+u16 var_3135 = 0;
+u16 var_3136 = 0;
+u16 var_3137 = 0;
+u16 var_3138 = 0;
+u16 var_3139 = 0;
+u16 var_3140 = 0;
+u16 var_3141 = 0;
+u16 var_3142 = 0;
+u16 var_3143 = 0;
+u16 var_3144 = 0;
+u16 var_3145 = 0;
+u16 var_3146 = 0;
+u16 var_3147 = 0;
+u16 var_3148 = 0;
+u16 var_3149 = 0;
+u16 var_3150 = 0;
+u16 var_3151 = 0;
+u16 var_3152 = 0;
+u16 var_3153 = 0;
+u16 var_3154 = 0;
+u16 var_3155 = 0;
+u16 var_3156 = 0;
+u16 var_3157 = 0;
+u16 var_3158 = 0;
+u16 var_3159 = 0;
+u16 var_3160 = 0;
+u16 var_3161 = 0;
+u16 var_3162 = 0;
+u16 var_3163 = 0;
+u16 var_3164 = 0;
+u16 var_3165 = 0;
+u16 var_3166 = 0;
+u16 var_3167 = 0;
+u16 var_3168 = 0;
+u16 var_3169 = 0;
+u16 var_3170 = 0;
+u16 var_3171 = 0;
+u16 var_3172 = 0;
+u16 var_3173 = 0;
+u16 var_3174 = 0;
+u16 var_3175 = 0;
+u16 var_3176 = 0;
+u16 var_3177 = 0;
+u16 var_3178 = 0;
+u16 var_3179 = 0;
+u16 var_3180 = 0;
+u16 var_3181 = 0;
+u16 var_3182 = 0;
+u16 var_3183 = 0;
+u16 var_3184 = 0;
+u16 var_3185 = 0;
+u16 var_3186 = 0;
+u16 var_3187 = 0;
+u16 var_3188 = 0;
+u16 var_3189 = 0;
+u16 var_3190 = 0;
+u16 var_3191 = 0;
+u16 var_3192 = 0;
+u16 var_3193 = 0;
+u16 var_3194 = 0;
+u16 var_3195 = 0;
+u16 var_3196 = 0;
+u16 var_3197 = 0;
+u16 var_3198 = 0;
+u16 var_3199 = 0;
+u16 var_3200 = 0;
+u16 var_3201 = 0;
+u16 var_3202 = 0;
+u16 var_3203 = 0;
+u16 var_3204 = 0;
+u16 var_3205 = 0;
+u16 var_3206 = 0;
+u16 var_3207 = 0;
+u16 var_3208 = 0;
+u16 var_3209 = 0;
+u16 var_3210 = 0;
+u16 var_3211 = 0;
+u16 var_3212 = 0;
+u16 var_3213 = 0;
+u16 var_3214 = 0;
+u16 var_3215 = 0;
+u16 var_3216 = 0;
+u16 var_3217 = 0;
+u16 var_3218 = 0;
+u16 var_3219 = 0;
+u16 var_3220 = 0;
+u16 var_3221 = 0;
+u16 var_3222 = 0;
+u16 var_3223 = 0;
+u16 var_3224 = 0;
+u16 var_3225 = 0;
+u16 var_3226 = 0;
+u16 var_3227 = 0;
+u16 var_3228 = 0;
+u16 var_3229 = 0;
+u16 var_3230 = 0;
+u16 var_3231 = 0;
+u16 var_3232 = 0;
+u16 var_3233 = 0;
+u16 var_3234 = 0;
+u16 var_3235 = 0;
+u16 var_3236 = 0;
+u16 var_3237 = 0;
+u16 var_3238 = 0;
+u16 var_3239 = 0;
+u16 var_3240 = 0;
+u16 var_3241 = 0;
+u16 var_3242 = 0;
+u16 var_3243 = 0;
+u16 var_3244 = 0;
+u16 var_3245 = 0;
+u16 var_3246 = 0;
+u16 var_3247 = 0;
+u16 var_3248 = 0;
+u16 var_3249 = 0;
+u16 var_3250 = 0;
+u16 var_3251 = 0;
+u16 var_3252 = 0;
+u16 var_3253 = 0;
+u16 var_3254 = 0;
+u16 var_3255 = 0;
+u16 var_3256 = 0;
+u16 var_3257 = 0;
+u16 var_3258 = 0;
+u16 var_3259 = 0;
+u16 var_3260 = 0;
+u16 var_3261 = 0;
+u16 var_3262 = 0;
+u16 var_3263 = 0;
+u16 var_3264 = 0;
+u16 var_3265 = 0;
+u16 var_3266 = 0;
+u16 var_3267 = 0;
+u16 var_3268 = 0;
+u16 var_3269 = 0;
+u16 var_3270 = 0;
+u16 var_3271 = 0;
+u16 var_3272 = 0;
+u16 var_3273 = 0;
+u16 var_3274 = 0;
+u16 var_3275 = 0;
+u16 var_3276 = 0;
+u16 var_3277 = 0;
+u16 var_3278 = 0;
+u16 var_3279 = 0;
+u16 var_3280 = 0;
+u16 var_3281 = 0;
+u16 var_3282 = 0;
+u16 var_3283 = 0;
+u16 var_3284 = 0;
+u16 var_3285 = 0;
+u16 var_3286 = 0;
+u16 var_3287 = 0;
+u16 var_3288 = 0;
+u16 var_3289 = 0;
+u16 var_3290 = 0;
+u16 var_3291 = 0;
+u16 var_3292 = 0;
+u16 var_3293 = 0;
+u16 var_3294 = 0;
+u16 var_3295 = 0;
+u16 var_3296 = 0;
+u16 var_3297 = 0;
+u16 var_3298 = 0;
+u16 var_3299 = 0;
+u16 var_3300 = 0;
+u16 var_3301 = 0;
+u16 var_3302 = 0;
+u16 var_3303 = 0;
+u16 var_3304 = 0;
+u16 var_3305 = 0;
+u16 var_3306 = 0;
+u16 var_3307 = 0;
+u16 var_3308 = 0;
+u16 var_3309 = 0;
+u16 var_3310 = 0;
+u16 var_3311 = 0;
+u16 var_3312 = 0;
+u16 var_3313 = 0;
+u16 var_3314 = 0;
+u16 var_3315 = 0;
+u16 var_3316 = 0;
+u16 var_3317 = 0;
+u16 var_3318 = 0;
+u16 var_3319 = 0;
+u16 var_3320 = 0;
+u16 var_3321 = 0;
+u16 var_3322 = 0;
+u16 var_3323 = 0;
+u16 var_3324 = 0;
+u16 var_3325 = 0;
+u16 var_3326 = 0;
+u16 var_3327 = 0;
+u16 var_3328 = 0;
+u16 var_3329 = 0;
+u16 var_3330 = 0;
+u16 var_3331 = 0;
+u16 var_3332 = 0;
+u16 var_3333 = 0;
+u16 var_3334 = 0;
+u16 var_3335 = 0;
+u16 var_3336 = 0;
+u16 var_3337 = 0;
+u16 var_3338 = 0;
+u16 var_3339 = 0;
+u16 var_3340 = 0;
+u16 var_3341 = 0;
+u16 var_3342 = 0;
+u16 var_3343 = 0;
+u16 var_3344 = 0;
+u16 var_3345 = 0;
+u16 var_3346 = 0;
+u16 var_3347 = 0;
+u16 var_3348 = 0;
+u16 var_3349 = 0;
+u16 var_3350 = 0;
+u16 var_3351 = 0;
+u16 var_3352 = 0;
+u16 var_3353 = 0;
+u16 var_3354 = 0;
+u16 var_3355 = 0;
+u16 var_3356 = 0;
+u16 var_3357 = 0;
+u16 var_3358 = 0;
+u16 var_3359 = 0;
+u16 var_3360 = 0;
+u16 var_3361 = 0;
+u16 var_3362 = 0;
+u16 var_3363 = 0;
+u16 var_3364 = 0;
+u16 var_3365 = 0;
+u16 var_3366 = 0;
+u16 var_3367 = 0;
+u16 var_3368 = 0;
+u16 var_3369 = 0;
+u16 var_3370 = 0;
+u16 var_3371 = 0;
+u16 var_3372 = 0;
+u16 var_3373 = 0;
+u16 var_3374 = 0;
+u16 var_3375 = 0;
+u16 var_3376 = 0;
+u16 var_3377 = 0;
+u16 var_3378 = 0;
+u16 var_3379 = 0;
+u16 var_3380 = 0;
+u16 var_3381 = 0;
+u16 var_3382 = 0;
+u16 var_3383 = 0;
+u16 var_3384 = 0;
+u16 var_3385 = 0;
+u16 var_3386 = 0;
+u16 var_3387 = 0;
+u16 var_3388 = 0;
+u16 var_3389 = 0;
+u16 var_3390 = 0;
+u16 var_3391 = 0;
+u16 var_3392 = 0;
+u16 var_3393 = 0;
+u16 var_3394 = 0;
+u16 var_3395 = 0;
+u16 var_3396 = 0;
+u16 var_3397 = 0;
+u16 var_3398 = 0;
+u16 var_3399 = 0;
+u16 var_3400 = 0;
+u16 var_3401 = 0;
+u16 var_3402 = 0;
+u16 var_3403 = 0;
+u16 var_3404 = 0;
+u16 var_3405 = 0;
+u16 var_3406 = 0;
+u16 var_3407 = 0;
+u16 var_3408 = 0;
+u16 var_3409 = 0;
+u16 var_3410 = 0;
+u16 var_3411 = 0;
+u16 var_3412 = 0;
+u16 var_3413 = 0;
+u16 var_3414 = 0;
+u16 var_3415 = 0;
+u16 var_3416 = 0;
+u16 var_3417 = 0;
+u16 var_3418 = 0;
+u16 var_3419 = 0;
+u16 var_3420 = 0;
+u16 var_3421 = 0;
+u16 var_3422 = 0;
+u16 var_3423 = 0;
+u16 var_3424 = 0;
+u16 var_3425 = 0;
+u16 var_3426 = 0;
+u16 var_3427 = 0;
+u16 var_3428 = 0;
+u16 var_3429 = 0;
+u16 var_3430 = 0;
+u16 var_3431 = 0;
+u16 var_3432 = 0;
+u16 var_3433 = 0;
+u16 var_3434 = 0;
+u16 var_3435 = 0;
+u16 var_3436 = 0;
+u16 var_3437 = 0;
+u16 var_3438 = 0;
+u16 var_3439 = 0;
+u16 var_3440 = 0;
+u16 var_3441 = 0;
+u16 var_3442 = 0;
+u16 var_3443 = 0;
+u16 var_3444 = 0;
+u16 var_3445 = 0;
+u16 var_3446 = 0;
+u16 var_3447 = 0;
+u16 var_3448 = 0;
+u16 var_3449 = 0;
+u16 var_3450 = 0;
+u16 var_3451 = 0;
+u16 var_3452 = 0;
+u16 var_3453 = 0;
+u16 var_3454 = 0;
+u16 var_3455 = 0;
+u16 var_3456 = 0;
+u16 var_3457 = 0;
+u16 var_3458 = 0;
+u16 var_3459 = 0;
+u16 var_3460 = 0;
+u16 var_3461 = 0;
+u16 var_3462 = 0;
+u16 var_3463 = 0;
+u16 var_3464 = 0;
+u16 var_3465 = 0;
+u16 var_3466 = 0;
+u16 var_3467 = 0;
+u16 var_3468 = 0;
+u16 var_3469 = 0;
+u16 var_3470 = 0;
+u16 var_3471 = 0;
+u16 var_3472 = 0;
+u16 var_3473 = 0;
+u16 var_3474 = 0;
+u16 var_3475 = 0;
+u16 var_3476 = 0;
+u16 var_3477 = 0;
+u16 var_3478 = 0;
+u16 var_3479 = 0;
+u16 var_3480 = 0;
+u16 var_3481 = 0;
+u16 var_3482 = 0;
+u16 var_3483 = 0;
+u16 var_3484 = 0;
+u16 var_3485 = 0;
+u16 var_3486 = 0;
+u16 var_3487 = 0;
+u16 var_3488 = 0;
+u16 var_3489 = 0;
+u16 var_3490 = 0;
+u16 var_3491 = 0;
+u16 var_3492 = 0;
+u16 var_3493 = 0;
+u16 var_3494 = 0;
+u16 var_3495 = 0;
+u16 var_3496 = 0;
+u16 var_3497 = 0;
+u16 var_3498 = 0;
+u16 var_3499 = 0;
+u16 var_3500 = 0;
+u16 var_3501 = 0;
+u16 var_3502 = 0;
+u16 var_3503 = 0;
+u16 var_3504 = 0;
+u16 var_3505 = 0;
+u16 var_3506 = 0;
+u16 var_3507 = 0;
+u16 var_3508 = 0;
+u16 var_3509 = 0;
+u16 var_3510 = 0;
+u16 var_3511 = 0;
+u16 var_3512 = 0;
+u16 var_3513 = 0;
+u16 var_3514 = 0;
+u16 var_3515 = 0;
+u16 var_3516 = 0;
+u16 var_3517 = 0;
+u16 var_3518 = 0;
+u16 var_3519 = 0;
+u16 var_3520 = 0;
+u16 var_3521 = 0;
+u16 var_3522 = 0;
+u16 var_3523 = 0;
+u16 var_3524 = 0;
+u16 var_3525 = 0;
+u16 var_3526 = 0;
+u16 var_3527 = 0;
+u16 var_3528 = 0;
+u16 var_3529 = 0;
+u16 var_3530 = 0;
+u16 var_3531 = 0;
+u16 var_3532 = 0;
+u16 var_3533 = 0;
+u16 var_3534 = 0;
+u16 var_3535 = 0;
+u16 var_3536 = 0;
+u16 var_3537 = 0;
+u16 var_3538 = 0;
+u16 var_3539 = 0;
+u16 var_3540 = 0;
+u16 var_3541 = 0;
+u16 var_3542 = 0;
+u16 var_3543 = 0;
+u16 var_3544 = 0;
+u16 var_3545 = 0;
+u16 var_3546 = 0;
+u16 var_3547 = 0;
+u16 var_3548 = 0;
+u16 var_3549 = 0;
+u16 var_3550 = 0;
+u16 var_3551 = 0;
+u16 var_3552 = 0;
+u16 var_3553 = 0;
+u16 var_3554 = 0;
+u16 var_3555 = 0;
+u16 var_3556 = 0;
+u16 var_3557 = 0;
+u16 var_3558 = 0;
+u16 var_3559 = 0;
+u16 var_3560 = 0;
+u16 var_3561 = 0;
+u16 var_3562 = 0;
+u16 var_3563 = 0;
+u16 var_3564 = 0;
+u16 var_3565 = 0;
+u16 var_3566 = 0;
+u16 var_3567 = 0;
+u16 var_3568 = 0;
+u16 var_3569 = 0;
+u16 var_3570 = 0;
+u16 var_3571 = 0;
+u16 var_3572 = 0;
+u16 var_3573 = 0;
+u16 var_3574 = 0;
+u16 var_3575 = 0;
+u16 var_3576 = 0;
+u16 var_3577 = 0;
+u16 var_3578 = 0;
+u16 var_3579 = 0;
+u16 var_3580 = 0;
+u16 var_3581 = 0;
+u16 var_3582 = 0;
+u16 var_3583 = 0;
+u16 var_3584 = 0;
+u16 var_3585 = 0;
+u16 var_3586 = 0;
+u16 var_3587 = 0;
+u16 var_3588 = 0;
+u16 var_3589 = 0;
+u16 var_3590 = 0;
+u16 var_3591 = 0;
+u16 var_3592 = 0;
+u16 var_3593 = 0;
+u16 var_3594 = 0;
+u16 var_3595 = 0;
+u16 var_3596 = 0;
+u16 var_3597 = 0;
+u16 var_3598 = 0;
+u16 var_3599 = 0;
+u16 var_3600 = 0;
+u16 var_3601 = 0;
+u16 var_3602 = 0;
+u16 var_3603 = 0;
+u16 var_3604 = 0;
+u16 var_3605 = 0;
+u16 var_3606 = 0;
+u16 var_3607 = 0;
+u16 var_3608 = 0;
+u16 var_3609 = 0;
+u16 var_3610 = 0;
+u16 var_3611 = 0;
+u16 var_3612 = 0;
+u16 var_3613 = 0;
+u16 var_3614 = 0;
+u16 var_3615 = 0;
+u16 var_3616 = 0;
+u16 var_3617 = 0;
+u16 var_3618 = 0;
+u16 var_3619 = 0;
+u16 var_3620 = 0;
+u16 var_3621 = 0;
+u16 var_3622 = 0;
+u16 var_3623 = 0;
+u16 var_3624 = 0;
+u16 var_3625 = 0;
+u16 var_3626 = 0;
+u16 var_3627 = 0;
+u16 var_3628 = 0;
+u16 var_3629 = 0;
+u16 var_3630 = 0;
+u16 var_3631 = 0;
+u16 var_3632 = 0;
+u16 var_3633 = 0;
+u16 var_3634 = 0;
+u16 var_3635 = 0;
+u16 var_3636 = 0;
+u16 var_3637 = 0;
+u16 var_3638 = 0;
+u16 var_3639 = 0;
+u16 var_3640 = 0;
+u16 var_3641 = 0;
+u16 var_3642 = 0;
+u16 var_3643 = 0;
+u16 var_3644 = 0;
+u16 var_3645 = 0;
+u16 var_3646 = 0;
+u16 var_3647 = 0;
+u16 var_3648 = 0;
+u16 var_3649 = 0;
+u16 var_3650 = 0;
+u16 var_3651 = 0;
+u16 var_3652 = 0;
+u16 var_3653 = 0;
+u16 var_3654 = 0;
+u16 var_3655 = 0;
+u16 var_3656 = 0;
+u16 var_3657 = 0;
+u16 var_3658 = 0;
+u16 var_3659 = 0;
+u16 var_3660 = 0;
+u16 var_3661 = 0;
+u16 var_3662 = 0;
+u16 var_3663 = 0;
+u16 var_3664 = 0;
+u16 var_3665 = 0;
+u16 var_3666 = 0;
+u16 var_3667 = 0;
+u16 var_3668 = 0;
+u16 var_3669 = 0;
+u16 var_3670 = 0;
+u16 var_3671 = 0;
+u16 var_3672 = 0;
+u16 var_3673 = 0;
+u16 var_3674 = 0;
+u16 var_3675 = 0;
+u16 var_3676 = 0;
+u16 var_3677 = 0;
+u16 var_3678 = 0;
+u16 var_3679 = 0;
+u16 var_3680 = 0;
+u16 var_3681 = 0;
+u16 var_3682 = 0;
+u16 var_3683 = 0;
+u16 var_3684 = 0;
+u16 var_3685 = 0;
+u16 var_3686 = 0;
+u16 var_3687 = 0;
+u16 var_3688 = 0;
+u16 var_3689 = 0;
+u16 var_3690 = 0;
+u16 var_3691 = 0;
+u16 var_3692 = 0;
+u16 var_3693 = 0;
+u16 var_3694 = 0;
+u16 var_3695 = 0;
+u16 var_3696 = 0;
+u16 var_3697 = 0;
+u16 var_3698 = 0;
+u16 var_3699 = 0;
+u16 var_3700 = 0;
+u16 var_3701 = 0;
+u16 var_3702 = 0;
+u16 var_3703 = 0;
+u16 var_3704 = 0;
+u16 var_3705 = 0;
+u16 var_3706 = 0;
+u16 var_3707 = 0;
+u16 var_3708 = 0;
+u16 var_3709 = 0;
+u16 var_3710 = 0;
+u16 var_3711 = 0;
+u16 var_3712 = 0;
+u16 var_3713 = 0;
+u16 var_3714 = 0;
+u16 var_3715 = 0;
+u16 var_3716 = 0;
+u16 var_3717 = 0;
+u16 var_3718 = 0;
+u16 var_3719 = 0;
+u16 var_3720 = 0;
+u16 var_3721 = 0;
+u16 var_3722 = 0;
+u16 var_3723 = 0;
+u16 var_3724 = 0;
+u16 var_3725 = 0;
+u16 var_3726 = 0;
+u16 var_3727 = 0;
+u16 var_3728 = 0;
+u16 var_3729 = 0;
+u16 var_3730 = 0;
+u16 var_3731 = 0;
+u16 var_3732 = 0;
+u16 var_3733 = 0;
+u16 var_3734 = 0;
+u16 var_3735 = 0;
+u16 var_3736 = 0;
+u16 var_3737 = 0;
+u16 var_3738 = 0;
+u16 var_3739 = 0;
+u16 var_3740 = 0;
+u16 var_3741 = 0;
+u16 var_3742 = 0;
+u16 var_3743 = 0;
+u16 var_3744 = 0;
+u16 var_3745 = 0;
+u16 var_3746 = 0;
+u16 var_3747 = 0;
+u16 var_3748 = 0;
+u16 var_3749 = 0;
+u16 var_3750 = 0;
+u16 var_3751 = 0;
+u16 var_3752 = 0;
+u16 var_3753 = 0;
+u16 var_3754 = 0;
+u16 var_3755 = 0;
+u16 var_3756 = 0;
+u16 var_3757 = 0;
+u16 var_3758 = 0;
+u16 var_3759 = 0;
+u16 var_3760 = 0;
+u16 var_3761 = 0;
+u16 var_3762 = 0;
+u16 var_3763 = 0;
+u16 var_3764 = 0;
+u16 var_3765 = 0;
+u16 var_3766 = 0;
+u16 var_3767 = 0;
+u16 var_3768 = 0;
+u16 var_3769 = 0;
+u16 var_3770 = 0;
+u16 var_3771 = 0;
+u16 var_3772 = 0;
+u16 var_3773 = 0;
+u16 var_3774 = 0;
+u16 var_3775 = 0;
+u16 var_3776 = 0;
+u16 var_3777 = 0;
+u16 var_3778 = 0;
+u16 var_3779 = 0;
+u16 var_3780 = 0;
+u16 var_3781 = 0;
+u16 var_3782 = 0;
+u16 var_3783 = 0;
+u16 var_3784 = 0;
+u16 var_3785 = 0;
+u16 var_3786 = 0;
+u16 var_3787 = 0;
+u16 var_3788 = 0;
+u16 var_3789 = 0;
+u16 var_3790 = 0;
+u16 var_3791 = 0;
+u16 var_3792 = 0;
+u16 var_3793 = 0;
+u16 var_3794 = 0;
+u16 var_3795 = 0;
+u16 var_3796 = 0;
+u16 var_3797 = 0;
+u16 var_3798 = 0;
+u16 var_3799 = 0;
+u16 var_3800 = 0;
+u16 var_3801 = 0;
+u16 var_3802 = 0;
+u16 var_3803 = 0;
+u16 var_3804 = 0;
+u16 var_3805 = 0;
+u16 var_3806 = 0;
+u16 var_3807 = 0;
+u16 var_3808 = 0;
+u16 var_3809 = 0;
+u16 var_3810 = 0;
+u16 var_3811 = 0;
+u16 var_3812 = 0;
+u16 var_3813 = 0;
+u16 var_3814 = 0;
+u16 var_3815 = 0;
+u16 var_3816 = 0;
+u16 var_3817 = 0;
+u16 var_3818 = 0;
+u16 var_3819 = 0;
+u16 var_3820 = 0;
+u16 var_3821 = 0;
+u16 var_3822 = 0;
+u16 var_3823 = 0;
+u16 var_3824 = 0;
+u16 var_3825 = 0;
+u16 var_3826 = 0;
+u16 var_3827 = 0;
+u16 var_3828 = 0;
+u16 var_3829 = 0;
+u16 var_3830 = 0;
+u16 var_3831 = 0;
+u16 var_3832 = 0;
+u16 var_3833 = 0;
+u16 var_3834 = 0;
+u16 var_3835 = 0;
+u16 var_3836 = 0;
+u16 var_3837 = 0;
+u16 var_3838 = 0;
+u16 var_3839 = 0;
+u16 var_3840 = 0;
+u16 var_3841 = 0;
+u16 var_3842 = 0;
+u16 var_3843 = 0;
+u16 var_3844 = 0;
+u16 var_3845 = 0;
+u16 var_3846 = 0;
+u16 var_3847 = 0;
+u16 var_3848 = 0;
+u16 var_3849 = 0;
+u16 var_3850 = 0;
+u16 var_3851 = 0;
+u16 var_3852 = 0;
+u16 var_3853 = 0;
+u16 var_3854 = 0;
+u16 var_3855 = 0;
+u16 var_3856 = 0;
+u16 var_3857 = 0;
+u16 var_3858 = 0;
+u16 var_3859 = 0;
+u16 var_3860 = 0;
+u16 var_3861 = 0;
+u16 var_3862 = 0;
+u16 var_3863 = 0;
+u16 var_3864 = 0;
+u16 var_3865 = 0;
+u16 var_3866 = 0;
+u16 var_3867 = 0;
+u16 var_3868 = 0;
+u16 var_3869 = 0;
+u16 var_3870 = 0;
+u16 var_3871 = 0;
+u16 var_3872 = 0;
+u16 var_3873 = 0;
+u16 var_3874 = 0;
+u16 var_3875 = 0;
+u16 var_3876 = 0;
+u16 var_3877 = 0;
+u16 var_3878 = 0;
+u16 var_3879 = 0;
+u16 var_3880 = 0;
+u16 var_3881 = 0;
+u16 var_3882 = 0;
+u16 var_3883 = 0;
+u16 var_3884 = 0;
+u16 var_3885 = 0;
+u16 var_3886 = 0;
+u16 var_3887 = 0;
+u16 var_3888 = 0;
+u16 var_3889 = 0;
+u16 var_3890 = 0;
+u16 var_3891 = 0;
+u16 var_3892 = 0;
+u16 var_3893 = 0;
+u16 var_3894 = 0;
+u16 var_3895 = 0;
+u16 var_3896 = 0;
+u16 var_3897 = 0;
+u16 var_3898 = 0;
+u16 var_3899 = 0;
+u16 var_3900 = 0;
+u16 var_3901 = 0;
+u16 var_3902 = 0;
+u16 var_3903 = 0;
+u16 var_3904 = 0;
+u16 var_3905 = 0;
+u16 var_3906 = 0;
+u16 var_3907 = 0;
+u16 var_3908 = 0;
+u16 var_3909 = 0;
+u16 var_3910 = 0;
+u16 var_3911 = 0;
+u16 var_3912 = 0;
+u16 var_3913 = 0;
+u16 var_3914 = 0;
+u16 var_3915 = 0;
+u16 var_3916 = 0;
+u16 var_3917 = 0;
+u16 var_3918 = 0;
+u16 var_3919 = 0;
+u16 var_3920 = 0;
+u16 var_3921 = 0;
+u16 var_3922 = 0;
+u16 var_3923 = 0;
+u16 var_3924 = 0;
+u16 var_3925 = 0;
+u16 var_3926 = 0;
+u16 var_3927 = 0;
+u16 var_3928 = 0;
+u16 var_3929 = 0;
+u16 var_3930 = 0;
+u16 var_3931 = 0;
+u16 var_3932 = 0;
+u16 var_3933 = 0;
+u16 var_3934 = 0;
+u16 var_3935 = 0;
+u16 var_3936 = 0;
+u16 var_3937 = 0;
+u16 var_3938 = 0;
+u16 var_3939 = 0;
+u16 var_3940 = 0;
+u16 var_3941 = 0;
+u16 var_3942 = 0;
+u16 var_3943 = 0;
+u16 var_3944 = 0;
+u16 var_3945 = 0;
+u16 var_3946 = 0;
+u16 var_3947 = 0;
+u16 var_3948 = 0;
+u16 var_3949 = 0;
+u16 var_3950 = 0;
+u16 var_3951 = 0;
+u16 var_3952 = 0;
+u16 var_3953 = 0;
+u16 var_3954 = 0;
+u16 var_3955 = 0;
+u16 var_3956 = 0;
+u16 var_3957 = 0;
+u16 var_3958 = 0;
+u16 var_3959 = 0;
+u16 var_3960 = 0;
+u16 var_3961 = 0;
+u16 var_3962 = 0;
+u16 var_3963 = 0;
+u16 var_3964 = 0;
+u16 var_3965 = 0;
+u16 var_3966 = 0;
+u16 var_3967 = 0;
+u16 var_3968 = 0;
+u16 var_3969 = 0;
+u16 var_3970 = 0;
+u16 var_3971 = 0;
+u16 var_3972 = 0;
+u16 var_3973 = 0;
+u16 var_3974 = 0;
+u16 var_3975 = 0;
+u16 var_3976 = 0;
+u16 var_3977 = 0;
+u16 var_3978 = 0;
+u16 var_3979 = 0;
+u16 var_3980 = 0;
+u16 var_3981 = 0;
+u16 var_3982 = 0;
+u16 var_3983 = 0;
+u16 var_3984 = 0;
+u16 var_3985 = 0;
+u16 var_3986 = 0;
+u16 var_3987 = 0;
+u16 var_3988 = 0;
+u16 var_3989 = 0;
+u16 var_3990 = 0;
+u16 var_3991 = 0;
+u16 var_3992 = 0;
+u16 var_3993 = 0;
+u16 var_3994 = 0;
+u16 var_3995 = 0;
+u16 var_3996 = 0;
+u16 var_3997 = 0;
+u16 var_3998 = 0;
+u16 var_3999 = 0;
+u16 var_4000 = 0;
+u16 var_4001 = 0;
+u16 var_4002 = 0;
+u16 var_4003 = 0;
+u16 var_4004 = 0;
+u16 var_4005 = 0;
+u16 var_4006 = 0;
+u16 var_4007 = 0;
+u16 var_4008 = 0;
+u16 var_4009 = 0;
+u16 var_4010 = 0;
+u16 var_4011 = 0;
+u16 var_4012 = 0;
+u16 var_4013 = 0;
+u16 var_4014 = 0;
+u16 var_4015 = 0;
+u16 var_4016 = 0;
+u16 var_4017 = 0;
+u16 var_4018 = 0;
+u16 var_4019 = 0;
+u16 var_4020 = 0;
+u16 var_4021 = 0;
+u16 var_4022 = 0;
+u16 var_4023 = 0;
+u16 var_4024 = 0;
+u16 var_4025 = 0;
+u16 var_4026 = 0;
+u16 var_4027 = 0;
+u16 var_4028 = 0;
+u16 var_4029 = 0;
+u16 var_4030 = 0;
+u16 var_4031 = 0;
+u16 var_4032 = 0;
+u16 var_4033 = 0;
+u16 var_4034 = 0;
+u16 var_4035 = 0;
+u16 var_4036 = 0;
+u16 var_4037 = 0;
+u16 var_4038 = 0;
+u16 var_4039 = 0;
+u16 var_4040 = 0;
+u16 var_4041 = 0;
+u16 var_4042 = 0;
+u16 var_4043 = 0;
+u16 var_4044 = 0;
+u16 var_4045 = 0;
+u16 var_4046 = 0;
+u16 var_4047 = 0;
+u16 var_4048 = 0;
+u16 var_4049 = 0;
+u16 var_4050 = 0;
+u16 var_4051 = 0;
+u16 var_4052 = 0;
+u16 var_4053 = 0;
+u16 var_4054 = 0;
+u16 var_4055 = 0;
+u16 var_4056 = 0;
+u16 var_4057 = 0;
+u16 var_4058 = 0;
+u16 var_4059 = 0;
+u16 var_4060 = 0;
+u16 var_4061 = 0;
+u16 var_4062 = 0;
+u16 var_4063 = 0;
+u16 var_4064 = 0;
+u16 var_4065 = 0;
+u16 var_4066 = 0;
+u16 var_4067 = 0;
+u16 var_4068 = 0;
+u16 var_4069 = 0;
+u16 var_4070 = 0;
+u16 var_4071 = 0;
+u16 var_4072 = 0;
+u16 var_4073 = 0;
+u16 var_4074 = 0;
+u16 var_4075 = 0;
+u16 var_4076 = 0;
+u16 var_4077 = 0;
+u16 var_4078 = 0;
+u16 var_4079 = 0;
+u16 var_4080 = 0;
+u16 var_4081 = 0;
+u16 var_4082 = 0;
+u16 var_4083 = 0;
+u16 var_4084 = 0;
+u16 var_4085 = 0;
+u16 var_4086 = 0;
+u16 var_4087 = 0;
+u16 var_4088 = 0;
+u16 var_4089 = 0;
+u16 var_4090 = 0;
+u16 var_4091 = 0;
+u16 var_4092 = 0;
+u16 var_4093 = 0;
+u16 var_4094 = 0;
+u16 var_4095 = 0;
+u16 var_4096 = 0;
+u16 var_4097 = 0;
+u16 var_4098 = 0;
+u16 var_4099 = 0;
+u16 var_4100 = 0;
+u16 var_4101 = 0;
+u16 var_4102 = 0;
+u16 var_4103 = 0;
+u16 var_4104 = 0;
+u16 var_4105 = 0;
+u16 var_4106 = 0;
+u16 var_4107 = 0;
+u16 var_4108 = 0;
+u16 var_4109 = 0;
+u16 var_4110 = 0;
+u16 var_4111 = 0;
+u16 var_4112 = 0;
+u16 var_4113 = 0;
+u16 var_4114 = 0;
+u16 var_4115 = 0;
+u16 var_4116 = 0;
+u16 var_4117 = 0;
+u16 var_4118 = 0;
+u16 var_4119 = 0;
+u16 var_4120 = 0;
+u16 var_4121 = 0;
+u16 var_4122 = 0;
+u16 var_4123 = 0;
+u16 var_4124 = 0;
+u16 var_4125 = 0;
+u16 var_4126 = 0;
+u16 var_4127 = 0;
+u16 var_4128 = 0;
+u16 var_4129 = 0;
+u16 var_4130 = 0;
+u16 var_4131 = 0;
+u16 var_4132 = 0;
+u16 var_4133 = 0;
+u16 var_4134 = 0;
+u16 var_4135 = 0;
+u16 var_4136 = 0;
+u16 var_4137 = 0;
+u16 var_4138 = 0;
+u16 var_4139 = 0;
+u16 var_4140 = 0;
+u16 var_4141 = 0;
+u16 var_4142 = 0;
+u16 var_4143 = 0;
+u16 var_4144 = 0;
+u16 var_4145 = 0;
+u16 var_4146 = 0;
+u16 var_4147 = 0;
+u16 var_4148 = 0;
+u16 var_4149 = 0;
+u16 var_4150 = 0;
+u16 var_4151 = 0;
+u16 var_4152 = 0;
+u16 var_4153 = 0;
+u16 var_4154 = 0;
+u16 var_4155 = 0;
+u16 var_4156 = 0;
+u16 var_4157 = 0;
+u16 var_4158 = 0;
+u16 var_4159 = 0;
+u16 var_4160 = 0;
+u16 var_4161 = 0;
+u16 var_4162 = 0;
+u16 var_4163 = 0;
+u16 var_4164 = 0;
+u16 var_4165 = 0;
+u16 var_4166 = 0;
+u16 var_4167 = 0;
+u16 var_4168 = 0;
+u16 var_4169 = 0;
+u16 var_4170 = 0;
+u16 var_4171 = 0;
+u16 var_4172 = 0;
+u16 var_4173 = 0;
+u16 var_4174 = 0;
+u16 var_4175 = 0;
+u16 var_4176 = 0;
+u16 var_4177 = 0;
+u16 var_4178 = 0;
+u16 var_4179 = 0;
+u16 var_4180 = 0;
+u16 var_4181 = 0;
+u16 var_4182 = 0;
+u16 var_4183 = 0;
+u16 var_4184 = 0;
+u16 var_4185 = 0;
+u16 var_4186 = 0;
+u16 var_4187 = 0;
+u16 var_4188 = 0;
+u16 var_4189 = 0;
+u16 var_4190 = 0;
+u16 var_4191 = 0;
+u16 var_4192 = 0;
+u16 var_4193 = 0;
+u16 var_4194 = 0;
+u16 var_4195 = 0;
+u16 var_4196 = 0;
+u16 var_4197 = 0;
+u16 var_4198 = 0;
+u16 var_4199 = 0;
+u16 var_4200 = 0;
+u16 var_4201 = 0;
+u16 var_4202 = 0;
+u16 var_4203 = 0;
+u16 var_4204 = 0;
+u16 var_4205 = 0;
+u16 var_4206 = 0;
+u16 var_4207 = 0;
+u16 var_4208 = 0;
+u16 var_4209 = 0;
+u16 var_4210 = 0;
+u16 var_4211 = 0;
+u16 var_4212 = 0;
+u16 var_4213 = 0;
+u16 var_4214 = 0;
+u16 var_4215 = 0;
+u16 var_4216 = 0;
+u16 var_4217 = 0;
+u16 var_4218 = 0;
+u16 var_4219 = 0;
+u16 var_4220 = 0;
+u16 var_4221 = 0;
+u16 var_4222 = 0;
+u16 var_4223 = 0;
+u16 var_4224 = 0;
+u16 var_4225 = 0;
+u16 var_4226 = 0;
+u16 var_4227 = 0;
+u16 var_4228 = 0;
+u16 var_4229 = 0;
+u16 var_4230 = 0;
+u16 var_4231 = 0;
+u16 var_4232 = 0;
+u16 var_4233 = 0;
+u16 var_4234 = 0;
+u16 var_4235 = 0;
+u16 var_4236 = 0;
+u16 var_4237 = 0;
+u16 var_4238 = 0;
+u16 var_4239 = 0;
+u16 var_4240 = 0;
+u16 var_4241 = 0;
+u16 var_4242 = 0;
+u16 var_4243 = 0;
+u16 var_4244 = 0;
+u16 var_4245 = 0;
+u16 var_4246 = 0;
+u16 var_4247 = 0;
+u16 var_4248 = 0;
+u16 var_4249 = 0;
+u16 var_4250 = 0;
+u16 var_4251 = 0;
+u16 var_4252 = 0;
+u16 var_4253 = 0;
+u16 var_4254 = 0;
+u16 var_4255 = 0;
+u16 var_4256 = 0;
+u16 var_4257 = 0;
+u16 var_4258 = 0;
+u16 var_4259 = 0;
+u16 var_4260 = 0;
+u16 var_4261 = 0;
+u16 var_4262 = 0;
+u16 var_4263 = 0;
+u16 var_4264 = 0;
+u16 var_4265 = 0;
+u16 var_4266 = 0;
+u16 var_4267 = 0;
+u16 var_4268 = 0;
+u16 var_4269 = 0;
+u16 var_4270 = 0;
+u16 var_4271 = 0;
+u16 var_4272 = 0;
+u16 var_4273 = 0;
+u16 var_4274 = 0;
+u16 var_4275 = 0;
+u16 var_4276 = 0;
+u16 var_4277 = 0;
+u16 var_4278 = 0;
+u16 var_4279 = 0;
+u16 var_4280 = 0;
+u16 var_4281 = 0;
+u16 var_4282 = 0;
+u16 var_4283 = 0;
+u16 var_4284 = 0;
+u16 var_4285 = 0;
+u16 var_4286 = 0;
+u16 var_4287 = 0;
+u16 var_4288 = 0;
+u16 var_4289 = 0;
+u16 var_4290 = 0;
+u16 var_4291 = 0;
+u16 var_4292 = 0;
+u16 var_4293 = 0;
+u16 var_4294 = 0;
+u16 var_4295 = 0;
+u16 var_4296 = 0;
+u16 var_4297 = 0;
+u16 var_4298 = 0;
+u16 var_4299 = 0;
+u16 var_4300 = 0;
+u16 var_4301 = 0;
+u16 var_4302 = 0;
+u16 var_4303 = 0;
+u16 var_4304 = 0;
+u16 var_4305 = 0;
+u16 var_4306 = 0;
+u16 var_4307 = 0;
+u16 var_4308 = 0;
+u16 var_4309 = 0;
+u16 var_4310 = 0;
+u16 var_4311 = 0;
+u16 var_4312 = 0;
+u16 var_4313 = 0;
+u16 var_4314 = 0;
+u16 var_4315 = 0;
+u16 var_4316 = 0;
+u16 var_4317 = 0;
+u16 var_4318 = 0;
+u16 var_4319 = 0;
+u16 var_4320 = 0;
+u16 var_4321 = 0;
+u16 var_4322 = 0;
+u16 var_4323 = 0;
+u16 var_4324 = 0;
+u16 var_4325 = 0;
+u16 var_4326 = 0;
+u16 var_4327 = 0;
+u16 var_4328 = 0;
+u16 var_4329 = 0;
+u16 var_4330 = 0;
+u16 var_4331 = 0;
+u16 var_4332 = 0;
+u16 var_4333 = 0;
+u16 var_4334 = 0;
+u16 var_4335 = 0;
+u16 var_4336 = 0;
+u16 var_4337 = 0;
+u16 var_4338 = 0;
+u16 var_4339 = 0;
+u16 var_4340 = 0;
+u16 var_4341 = 0;
+u16 var_4342 = 0;
+u16 var_4343 = 0;
+u16 var_4344 = 0;
+u16 var_4345 = 0;
+u16 var_4346 = 0;
+u16 var_4347 = 0;
+u16 var_4348 = 0;
+u16 var_4349 = 0;
+u16 var_4350 = 0;
+u16 var_4351 = 0;
+u16 var_4352 = 0;
+u16 var_4353 = 0;
+u16 var_4354 = 0;
+u16 var_4355 = 0;
+u16 var_4356 = 0;
+u16 var_4357 = 0;
+u16 var_4358 = 0;
+u16 var_4359 = 0;
+u16 var_4360 = 0;
+u16 var_4361 = 0;
+u16 var_4362 = 0;
+u16 var_4363 = 0;
+u16 var_4364 = 0;
+u16 var_4365 = 0;
+u16 var_4366 = 0;
+u16 var_4367 = 0;
+u16 var_4368 = 0;
+u16 var_4369 = 0;
+u16 var_4370 = 0;
+u16 var_4371 = 0;
+u16 var_4372 = 0;
+u16 var_4373 = 0;
+u16 var_4374 = 0;
+u16 var_4375 = 0;
+u16 var_4376 = 0;
+u16 var_4377 = 0;
+u16 var_4378 = 0;
+u16 var_4379 = 0;
+u16 var_4380 = 0;
+u16 var_4381 = 0;
+u16 var_4382 = 0;
+u16 var_4383 = 0;
+u16 var_4384 = 0;
+u16 var_4385 = 0;
+u16 var_4386 = 0;
+u16 var_4387 = 0;
+u16 var_4388 = 0;
+u16 var_4389 = 0;
+u16 var_4390 = 0;
+u16 var_4391 = 0;
+u16 var_4392 = 0;
+u16 var_4393 = 0;
+u16 var_4394 = 0;
+u16 var_4395 = 0;
+u16 var_4396 = 0;
+u16 var_4397 = 0;
+u16 var_4398 = 0;
+u16 var_4399 = 0;
+u16 var_4400 = 0;
+u16 var_4401 = 0;
+u16 var_4402 = 0;
+u16 var_4403 = 0;
+u16 var_4404 = 0;
+u16 var_4405 = 0;
+u16 var_4406 = 0;
+u16 var_4407 = 0;
+u16 var_4408 = 0;
+u16 var_4409 = 0;
+u16 var_4410 = 0;
+u16 var_4411 = 0;
+u16 var_4412 = 0;
+u16 var_4413 = 0;
+u16 var_4414 = 0;
+u16 var_4415 = 0;
+u16 var_4416 = 0;
+u16 var_4417 = 0;
+u16 var_4418 = 0;
+u16 var_4419 = 0;
+u16 var_4420 = 0;
+u16 var_4421 = 0;
+u16 var_4422 = 0;
+u16 var_4423 = 0;
+u16 var_4424 = 0;
+u16 var_4425 = 0;
+u16 var_4426 = 0;
+u16 var_4427 = 0;
+u16 var_4428 = 0;
+u16 var_4429 = 0;
+u16 var_4430 = 0;
+u16 var_4431 = 0;
+u16 var_4432 = 0;
+u16 var_4433 = 0;
+u16 var_4434 = 0;
+u16 var_4435 = 0;
+u16 var_4436 = 0;
+u16 var_4437 = 0;
+u16 var_4438 = 0;
+u16 var_4439 = 0;
+u16 var_4440 = 0;
+u16 var_4441 = 0;
+u16 var_4442 = 0;
+u16 var_4443 = 0;
+u16 var_4444 = 0;
+u16 var_4445 = 0;
+u16 var_4446 = 0;
+u16 var_4447 = 0;
+u16 var_4448 = 0;
+u16 var_4449 = 0;
+u16 var_4450 = 0;
+u16 var_4451 = 0;
+u16 var_4452 = 0;
+u16 var_4453 = 0;
+u16 var_4454 = 0;
+u16 var_4455 = 0;
+u16 var_4456 = 0;
+u16 var_4457 = 0;
+u16 var_4458 = 0;
+u16 var_4459 = 0;
+u16 var_4460 = 0;
+u16 var_4461 = 0;
+u16 var_4462 = 0;
+u16 var_4463 = 0;
+u16 var_4464 = 0;
+u16 var_4465 = 0;
+u16 var_4466 = 0;
+u16 var_4467 = 0;
+u16 var_4468 = 0;
+u16 var_4469 = 0;
+u16 var_4470 = 0;
+u16 var_4471 = 0;
+u16 var_4472 = 0;
+u16 var_4473 = 0;
+u16 var_4474 = 0;
+u16 var_4475 = 0;
+u16 var_4476 = 0;
+u16 var_4477 = 0;
+u16 var_4478 = 0;
+u16 var_4479 = 0;
+u16 var_4480 = 0;
+u16 var_4481 = 0;
+u16 var_4482 = 0;
+u16 var_4483 = 0;
+u16 var_4484 = 0;
+u16 var_4485 = 0;
+u16 var_4486 = 0;
+u16 var_4487 = 0;
+u16 var_4488 = 0;
+u16 var_4489 = 0;
+u16 var_4490 = 0;
+u16 var_4491 = 0;
+u16 var_4492 = 0;
+u16 var_4493 = 0;
+u16 var_4494 = 0;
+u16 var_4495 = 0;
+u16 var_4496 = 0;
+u16 var_4497 = 0;
+u16 var_4498 = 0;
+u16 var_4499 = 0;
+u16 var_4500 = 0;
+u16 var_4501 = 0;
+u16 var_4502 = 0;
+u16 var_4503 = 0;
+u16 var_4504 = 0;
+u16 var_4505 = 0;
+u16 var_4506 = 0;
+u16 var_4507 = 0;
+u16 var_4508 = 0;
+u16 var_4509 = 0;
+u16 var_4510 = 0;
+u16 var_4511 = 0;
+u16 var_4512 = 0;
+u16 var_4513 = 0;
+u16 var_4514 = 0;
+u16 var_4515 = 0;
+u16 var_4516 = 0;
+u16 var_4517 = 0;
+u16 var_4518 = 0;
+u16 var_4519 = 0;
+u16 var_4520 = 0;
+u16 var_4521 = 0;
+u16 var_4522 = 0;
+u16 var_4523 = 0;
+u16 var_4524 = 0;
+u16 var_4525 = 0;
+u16 var_4526 = 0;
+u16 var_4527 = 0;
+u16 var_4528 = 0;
+u16 var_4529 = 0;
+u16 var_4530 = 0;
+u16 var_4531 = 0;
+u16 var_4532 = 0;
+u16 var_4533 = 0;
+u16 var_4534 = 0;
+u16 var_4535 = 0;
+u16 var_4536 = 0;
+u16 var_4537 = 0;
+u16 var_4538 = 0;
+u16 var_4539 = 0;
+u16 var_4540 = 0;
+u16 var_4541 = 0;
+u16 var_4542 = 0;
+u16 var_4543 = 0;
+u16 var_4544 = 0;
+u16 var_4545 = 0;
+u16 var_4546 = 0;
+u16 var_4547 = 0;
+u16 var_4548 = 0;
+u16 var_4549 = 0;
+u16 var_4550 = 0;
+u16 var_4551 = 0;
+u16 var_4552 = 0;
+u16 var_4553 = 0;
+u16 var_4554 = 0;
+u16 var_4555 = 0;
+u16 var_4556 = 0;
+u16 var_4557 = 0;
+u16 var_4558 = 0;
+u16 var_4559 = 0;
+u16 var_4560 = 0;
+u16 var_4561 = 0;
+u16 var_4562 = 0;
+u16 var_4563 = 0;
+u16 var_4564 = 0;
+u16 var_4565 = 0;
+u16 var_4566 = 0;
+u16 var_4567 = 0;
+u16 var_4568 = 0;
+u16 var_4569 = 0;
+u16 var_4570 = 0;
+u16 var_4571 = 0;
+u16 var_4572 = 0;
+u16 var_4573 = 0;
+u16 var_4574 = 0;
+u16 var_4575 = 0;
+u16 var_4576 = 0;
+u16 var_4577 = 0;
+u16 var_4578 = 0;
+u16 var_4579 = 0;
+u16 var_4580 = 0;
+u16 var_4581 = 0;
+u16 var_4582 = 0;
+u16 var_4583 = 0;
+u16 var_4584 = 0;
+u16 var_4585 = 0;
+u16 var_4586 = 0;
+u16 var_4587 = 0;
+u16 var_4588 = 0;
+u16 var_4589 = 0;
+u16 var_4590 = 0;
+u16 var_4591 = 0;
+u16 var_4592 = 0;
+u16 var_4593 = 0;
+u16 var_4594 = 0;
+u16 var_4595 = 0;
+u16 var_4596 = 0;
+u16 var_4597 = 0;
+u16 var_4598 = 0;
+u16 var_4599 = 0;
+u16 var_4600 = 0;
+u16 var_4601 = 0;
+u16 var_4602 = 0;
+u16 var_4603 = 0;
+u16 var_4604 = 0;
+u16 var_4605 = 0;
+u16 var_4606 = 0;
+u16 var_4607 = 0;
+u16 var_4608 = 0;
+u16 var_4609 = 0;
+u16 var_4610 = 0;
+u16 var_4611 = 0;
+u16 var_4612 = 0;
+u16 var_4613 = 0;
+u16 var_4614 = 0;
+u16 var_4615 = 0;
+u16 var_4616 = 0;
+u16 var_4617 = 0;
+u16 var_4618 = 0;
+u16 var_4619 = 0;
+u16 var_4620 = 0;
+u16 var_4621 = 0;
+u16 var_4622 = 0;
+u16 var_4623 = 0;
+u16 var_4624 = 0;
+u16 var_4625 = 0;
+u16 var_4626 = 0;
+u16 var_4627 = 0;
+u16 var_4628 = 0;
+u16 var_4629 = 0;
+u16 var_4630 = 0;
+u16 var_4631 = 0;
+u16 var_4632 = 0;
+u16 var_4633 = 0;
+u16 var_4634 = 0;
+u16 var_4635 = 0;
+u16 var_4636 = 0;
+u16 var_4637 = 0;
+u16 var_4638 = 0;
+u16 var_4639 = 0;
+u16 var_4640 = 0;
+u16 var_4641 = 0;
+u16 var_4642 = 0;
+u16 var_4643 = 0;
+u16 var_4644 = 0;
+u16 var_4645 = 0;
+u16 var_4646 = 0;
+u16 var_4647 = 0;
+u16 var_4648 = 0;
+u16 var_4649 = 0;
+u16 var_4650 = 0;
+u16 var_4651 = 0;
+u16 var_4652 = 0;
+u16 var_4653 = 0;
+u16 var_4654 = 0;
+u16 var_4655 = 0;
+u16 var_4656 = 0;
+u16 var_4657 = 0;
+u16 var_4658 = 0;
+u16 var_4659 = 0;
+u16 var_4660 = 0;
+u16 var_4661 = 0;
+u16 var_4662 = 0;
+u16 var_4663 = 0;
+u16 var_4664 = 0;
+u16 var_4665 = 0;
+u16 var_4666 = 0;
+u16 var_4667 = 0;
+u16 var_4668 = 0;
+u16 var_4669 = 0;
+u16 var_4670 = 0;
+u16 var_4671 = 0;
+u16 var_4672 = 0;
+u16 var_4673 = 0;
+u16 var_4674 = 0;
+u16 var_4675 = 0;
+u16 var_4676 = 0;
+u16 var_4677 = 0;
+u16 var_4678 = 0;
+u16 var_4679 = 0;
+u16 var_4680 = 0;
+u16 var_4681 = 0;
+u16 var_4682 = 0;
+u16 var_4683 = 0;
+u16 var_4684 = 0;
+u16 var_4685 = 0;
+u16 var_4686 = 0;
+u16 var_4687 = 0;
+u16 var_4688 = 0;
+u16 var_4689 = 0;
+u16 var_4690 = 0;
+u16 var_4691 = 0;
+u16 var_4692 = 0;
+u16 var_4693 = 0;
+u16 var_4694 = 0;
+u16 var_4695 = 0;
+u16 var_4696 = 0;
+u16 var_4697 = 0;
+u16 var_4698 = 0;
+u16 var_4699 = 0;
+u16 var_4700 = 0;
+u16 var_4701 = 0;
+u16 var_4702 = 0;
+u16 var_4703 = 0;
+u16 var_4704 = 0;
+u16 var_4705 = 0;
+u16 var_4706 = 0;
+u16 var_4707 = 0;
+u16 var_4708 = 0;
+u16 var_4709 = 0;
+u16 var_4710 = 0;
+u16 var_4711 = 0;
+u16 var_4712 = 0;
+u16 var_4713 = 0;
+u16 var_4714 = 0;
+u16 var_4715 = 0;
+u16 var_4716 = 0;
+u16 var_4717 = 0;
+u16 var_4718 = 0;
+u16 var_4719 = 0;
+u16 var_4720 = 0;
+u16 var_4721 = 0;
+u16 var_4722 = 0;
+u16 var_4723 = 0;
+u16 var_4724 = 0;
+u16 var_4725 = 0;
+u16 var_4726 = 0;
+u16 var_4727 = 0;
+u16 var_4728 = 0;
+u16 var_4729 = 0;
+u16 var_4730 = 0;
+u16 var_4731 = 0;
+u16 var_4732 = 0;
+u16 var_4733 = 0;
+u16 var_4734 = 0;
+u16 var_4735 = 0;
+u16 var_4736 = 0;
+u16 var_4737 = 0;
+u16 var_4738 = 0;
+u16 var_4739 = 0;
+u16 var_4740 = 0;
+u16 var_4741 = 0;
+u16 var_4742 = 0;
+u16 var_4743 = 0;
+u16 var_4744 = 0;
+u16 var_4745 = 0;
+u16 var_4746 = 0;
+u16 var_4747 = 0;
+u16 var_4748 = 0;
+u16 var_4749 = 0;
+u16 var_4750 = 0;
+u16 var_4751 = 0;
+u16 var_4752 = 0;
+u16 var_4753 = 0;
+u16 var_4754 = 0;
+u16 var_4755 = 0;
+u16 var_4756 = 0;
+u16 var_4757 = 0;
+u16 var_4758 = 0;
+u16 var_4759 = 0;
+u16 var_4760 = 0;
+u16 var_4761 = 0;
+u16 var_4762 = 0;
+u16 var_4763 = 0;
+u16 var_4764 = 0;
+u16 var_4765 = 0;
+u16 var_4766 = 0;
+u16 var_4767 = 0;
+u16 var_4768 = 0;
+u16 var_4769 = 0;
+u16 var_4770 = 0;
+u16 var_4771 = 0;
+u16 var_4772 = 0;
+u16 var_4773 = 0;
+u16 var_4774 = 0;
+u16 var_4775 = 0;
+u16 var_4776 = 0;
+u16 var_4777 = 0;
+u16 var_4778 = 0;
+u16 var_4779 = 0;
+u16 var_4780 = 0;
+u16 var_4781 = 0;
+u16 var_4782 = 0;
+u16 var_4783 = 0;
+u16 var_4784 = 0;
+u16 var_4785 = 0;
+u16 var_4786 = 0;
+u16 var_4787 = 0;
+u16 var_4788 = 0;
+u16 var_4789 = 0;
+u16 var_4790 = 0;
+u16 var_4791 = 0;
+u16 var_4792 = 0;
+u16 var_4793 = 0;
+u16 var_4794 = 0;
+u16 var_4795 = 0;
+u16 var_4796 = 0;
+u16 var_4797 = 0;
+u16 var_4798 = 0;
+u16 var_4799 = 0;
+u16 var_4800 = 0;
+u16 var_4801 = 0;
+u16 var_4802 = 0;
+u16 var_4803 = 0;
+u16 var_4804 = 0;
+u16 var_4805 = 0;
+u16 var_4806 = 0;
+u16 var_4807 = 0;
+u16 var_4808 = 0;
+u16 var_4809 = 0;
+u16 var_4810 = 0;
+u16 var_4811 = 0;
+u16 var_4812 = 0;
+u16 var_4813 = 0;
+u16 var_4814 = 0;
+u16 var_4815 = 0;
+u16 var_4816 = 0;
+u16 var_4817 = 0;
+u16 var_4818 = 0;
+u16 var_4819 = 0;
+u16 var_4820 = 0;
+u16 var_4821 = 0;
+u16 var_4822 = 0;
+u16 var_4823 = 0;
+u16 var_4824 = 0;
+u16 var_4825 = 0;
+u16 var_4826 = 0;
+u16 var_4827 = 0;
+u16 var_4828 = 0;
+u16 var_4829 = 0;
+u16 var_4830 = 0;
+u16 var_4831 = 0;
+u16 var_4832 = 0;
+u16 var_4833 = 0;
+u16 var_4834 = 0;
+u16 var_4835 = 0;
+u16 var_4836 = 0;
+u16 var_4837 = 0;
+u16 var_4838 = 0;
+u16 var_4839 = 0;
+u16 var_4840 = 0;
+u16 var_4841 = 0;
+u16 var_4842 = 0;
+u16 var_4843 = 0;
+u16 var_4844 = 0;
+u16 var_4845 = 0;
+u16 var_4846 = 0;
+u16 var_4847 = 0;
+u16 var_4848 = 0;
+u16 var_4849 = 0;
+u16 var_4850 = 0;
+u16 var_4851 = 0;
+u16 var_4852 = 0;
+u16 var_4853 = 0;
+u16 var_4854 = 0;
+u16 var_4855 = 0;
+u16 var_4856 = 0;
+u16 var_4857 = 0;
+u16 var_4858 = 0;
+u16 var_4859 = 0;
+u16 var_4860 = 0;
+u16 var_4861 = 0;
+u16 var_4862 = 0;
+u16 var_4863 = 0;
+u16 var_4864 = 0;
+u16 var_4865 = 0;
+u16 var_4866 = 0;
+u16 var_4867 = 0;
+u16 var_4868 = 0;
+u16 var_4869 = 0;
+u16 var_4870 = 0;
+u16 var_4871 = 0;
+u16 var_4872 = 0;
+u16 var_4873 = 0;
+u16 var_4874 = 0;
+u16 var_4875 = 0;
+u16 var_4876 = 0;
+u16 var_4877 = 0;
+u16 var_4878 = 0;
+u16 var_4879 = 0;
+u16 var_4880 = 0;
+u16 var_4881 = 0;
+u16 var_4882 = 0;
+u16 var_4883 = 0;
+u16 var_4884 = 0;
+u16 var_4885 = 0;
+u16 var_4886 = 0;
+u16 var_4887 = 0;
+u16 var_4888 = 0;
+u16 var_4889 = 0;
+u16 var_4890 = 0;
+u16 var_4891 = 0;
+u16 var_4892 = 0;
+u16 var_4893 = 0;
+u16 var_4894 = 0;
+u16 var_4895 = 0;
+u16 var_4896 = 0;
+u16 var_4897 = 0;
+u16 var_4898 = 0;
+u16 var_4899 = 0;
+u16 var_4900 = 0;
+u16 var_4901 = 0;
+u16 var_4902 = 0;
+u16 var_4903 = 0;
+u16 var_4904 = 0;
+u16 var_4905 = 0;
+u16 var_4906 = 0;
+u16 var_4907 = 0;
+u16 var_4908 = 0;
+u16 var_4909 = 0;
+u16 var_4910 = 0;
+u16 var_4911 = 0;
+u16 var_4912 = 0;
+u16 var_4913 = 0;
+u16 var_4914 = 0;
+u16 var_4915 = 0;
+u16 var_4916 = 0;
+u16 var_4917 = 0;
+u16 var_4918 = 0;
+u16 var_4919 = 0;
+u16 var_4920 = 0;
+u16 var_4921 = 0;
+u16 var_4922 = 0;
+u16 var_4923 = 0;
+u16 var_4924 = 0;
+u16 var_4925 = 0;
+u16 var_4926 = 0;
+u16 var_4927 = 0;
+u16 var_4928 = 0;
+u16 var_4929 = 0;
+u16 var_4930 = 0;
+u16 var_4931 = 0;
+u16 var_4932 = 0;
+u16 var_4933 = 0;
+u16 var_4934 = 0;
+u16 var_4935 = 0;
+u16 var_4936 = 0;
+u16 var_4937 = 0;
+u16 var_4938 = 0;
+u16 var_4939 = 0;
+u16 var_4940 = 0;
+u16 var_4941 = 0;
+u16 var_4942 = 0;
+u16 var_4943 = 0;
+u16 var_4944 = 0;
+u16 var_4945 = 0;
+u16 var_4946 = 0;
+u16 var_4947 = 0;
+u16 var_4948 = 0;
+u16 var_4949 = 0;
+u16 var_4950 = 0;
+u16 var_4951 = 0;
+u16 var_4952 = 0;
+u16 var_4953 = 0;
+u16 var_4954 = 0;
+u16 var_4955 = 0;
+u16 var_4956 = 0;
+u16 var_4957 = 0;
+u16 var_4958 = 0;
+u16 var_4959 = 0;
+u16 var_4960 = 0;
+u16 var_4961 = 0;
+u16 var_4962 = 0;
+u16 var_4963 = 0;
+u16 var_4964 = 0;
+u16 var_4965 = 0;
+u16 var_4966 = 0;
+u16 var_4967 = 0;
+u16 var_4968 = 0;
+u16 var_4969 = 0;
+u16 var_4970 = 0;
+u16 var_4971 = 0;
+u16 var_4972 = 0;
+u16 var_4973 = 0;
+u16 var_4974 = 0;
+u16 var_4975 = 0;
+u16 var_4976 = 0;
+u16 var_4977 = 0;
+u16 var_4978 = 0;
+u16 var_4979 = 0;
+u16 var_4980 = 0;
+u16 var_4981 = 0;
+u16 var_4982 = 0;
+u16 var_4983 = 0;
+u16 var_4984 = 0;
+u16 var_4985 = 0;
+u16 var_4986 = 0;
+u16 var_4987 = 0;
+u16 var_4988 = 0;
+u16 var_4989 = 0;
+u16 var_4990 = 0;
+u16 var_4991 = 0;
+u16 var_4992 = 0;
+u16 var_4993 = 0;
+u16 var_4994 = 0;
+u16 var_4995 = 0;
+u16 var_4996 = 0;
+u16 var_4997 = 0;
+u16 var_4998 = 0;
+u16 var_4999 = 0;
+u16 var_5000 = 0;
+u16 var_5001 = 0;
+u16 var_5002 = 0;
+u16 var_5003 = 0;
+u16 var_5004 = 0;
+u16 var_5005 = 0;
+u16 var_5006 = 0;
+u16 var_5007 = 0;
+u16 var_5008 = 0;
+u16 var_5009 = 0;
+u16 var_5010 = 0;
+u16 var_5011 = 0;
+u16 var_5012 = 0;
+u16 var_5013 = 0;
+u16 var_5014 = 0;
+u16 var_5015 = 0;
+u16 var_5016 = 0;
+u16 var_5017 = 0;
+u16 var_5018 = 0;
+u16 var_5019 = 0;
+u16 var_5020 = 0;
+u16 var_5021 = 0;
+u16 var_5022 = 0;
+u16 var_5023 = 0;
+u16 var_5024 = 0;
+u16 var_5025 = 0;
+u16 var_5026 = 0;
+u16 var_5027 = 0;
+u16 var_5028 = 0;
+u16 var_5029 = 0;
+u16 var_5030 = 0;
+u16 var_5031 = 0;
+u16 var_5032 = 0;
+u16 var_5033 = 0;
+u16 var_5034 = 0;
+u16 var_5035 = 0;
+u16 var_5036 = 0;
+u16 var_5037 = 0;
+u16 var_5038 = 0;
+u16 var_5039 = 0;
+u16 var_5040 = 0;
+u16 var_5041 = 0;
+u16 var_5042 = 0;
+u16 var_5043 = 0;
+u16 var_5044 = 0;
+u16 var_5045 = 0;
+u16 var_5046 = 0;
+u16 var_5047 = 0;
+u16 var_5048 = 0;
+u16 var_5049 = 0;
+u16 var_5050 = 0;
+u16 var_5051 = 0;
+u16 var_5052 = 0;
+u16 var_5053 = 0;
+u16 var_5054 = 0;
+u16 var_5055 = 0;
+u16 var_5056 = 0;
+u16 var_5057 = 0;
+u16 var_5058 = 0;
+u16 var_5059 = 0;
+u16 var_5060 = 0;
+u16 var_5061 = 0;
+u16 var_5062 = 0;
+u16 var_5063 = 0;
+u16 var_5064 = 0;
+u16 var_5065 = 0;
+u16 var_5066 = 0;
+u16 var_5067 = 0;
+u16 var_5068 = 0;
+u16 var_5069 = 0;
+u16 var_5070 = 0;
+u16 var_5071 = 0;
+u16 var_5072 = 0;
+u16 var_5073 = 0;
+u16 var_5074 = 0;
+u16 var_5075 = 0;
+u16 var_5076 = 0;
+u16 var_5077 = 0;
+u16 var_5078 = 0;
+u16 var_5079 = 0;
+u16 var_5080 = 0;
+u16 var_5081 = 0;
+u16 var_5082 = 0;
+u16 var_5083 = 0;
+u16 var_5084 = 0;
+u16 var_5085 = 0;
+u16 var_5086 = 0;
+u16 var_5087 = 0;
+u16 var_5088 = 0;
+u16 var_5089 = 0;
+u16 var_5090 = 0;
+u16 var_5091 = 0;
+u16 var_5092 = 0;
+u16 var_5093 = 0;
+u16 var_5094 = 0;
+u16 var_5095 = 0;
+u16 var_5096 = 0;
+u16 var_5097 = 0;
+u16 var_5098 = 0;
+u16 var_5099 = 0;
+u16 var_5100 = 0;
+u16 var_5101 = 0;
+u16 var_5102 = 0;
+u16 var_5103 = 0;
+u16 var_5104 = 0;
+u16 var_5105 = 0;
+u16 var_5106 = 0;
+u16 var_5107 = 0;
+u16 var_5108 = 0;
+u16 var_5109 = 0;
+u16 var_5110 = 0;
+u16 var_5111 = 0;
+u16 var_5112 = 0;
+u16 var_5113 = 0;
+u16 var_5114 = 0;
+u16 var_5115 = 0;
+u16 var_5116 = 0;
+u16 var_5117 = 0;
+u16 var_5118 = 0;
+u16 var_5119 = 0;
+u16 var_5120 = 0;
+u16 var_5121 = 0;
+u16 var_5122 = 0;
+u16 var_5123 = 0;
+u16 var_5124 = 0;
+u16 var_5125 = 0;
+u16 var_5126 = 0;
+u16 var_5127 = 0;
+u16 var_5128 = 0;
+u16 var_5129 = 0;
+u16 var_5130 = 0;
+u16 var_5131 = 0;
+u16 var_5132 = 0;
+u16 var_5133 = 0;
+u16 var_5134 = 0;
+u16 var_5135 = 0;
+u16 var_5136 = 0;
+u16 var_5137 = 0;
+u16 var_5138 = 0;
+u16 var_5139 = 0;
+u16 var_5140 = 0;
+u16 var_5141 = 0;
+u16 var_5142 = 0;
+u16 var_5143 = 0;
+u16 var_5144 = 0;
+u16 var_5145 = 0;
+u16 var_5146 = 0;
+u16 var_5147 = 0;
+u16 var_5148 = 0;
+u16 var_5149 = 0;
+u16 var_5150 = 0;
+u16 var_5151 = 0;
+u16 var_5152 = 0;
+u16 var_5153 = 0;
+u16 var_5154 = 0;
+u16 var_5155 = 0;
+u16 var_5156 = 0;
+u16 var_5157 = 0;
+u16 var_5158 = 0;
+u16 var_5159 = 0;
+u16 var_5160 = 0;
+u16 var_5161 = 0;
+u16 var_5162 = 0;
+u16 var_5163 = 0;
+u16 var_5164 = 0;
+u16 var_5165 = 0;
+u16 var_5166 = 0;
+u16 var_5167 = 0;
+u16 var_5168 = 0;
+u16 var_5169 = 0;
+u16 var_5170 = 0;
+u16 var_5171 = 0;
+u16 var_5172 = 0;
+u16 var_5173 = 0;
+u16 var_5174 = 0;
+u16 var_5175 = 0;
+u16 var_5176 = 0;
+u16 var_5177 = 0;
+u16 var_5178 = 0;
+u16 var_5179 = 0;
+u16 var_5180 = 0;
+u16 var_5181 = 0;
+u16 var_5182 = 0;
+u16 var_5183 = 0;
+u16 var_5184 = 0;
+u16 var_5185 = 0;
+u16 var_5186 = 0;
+u16 var_5187 = 0;
+u16 var_5188 = 0;
+u16 var_5189 = 0;
+u16 var_5190 = 0;
+u16 var_5191 = 0;
+u16 var_5192 = 0;
+u16 var_5193 = 0;
+u16 var_5194 = 0;
+u16 var_5195 = 0;
+u16 var_5196 = 0;
+u16 var_5197 = 0;
+u16 var_5198 = 0;
+u16 var_5199 = 0;
+u16 var_5200 = 0;
+u16 var_5201 = 0;
+u16 var_5202 = 0;
+u16 var_5203 = 0;
+u16 var_5204 = 0;
+u16 var_5205 = 0;
+u16 var_5206 = 0;
+u16 var_5207 = 0;
+u16 var_5208 = 0;
+u16 var_5209 = 0;
+u16 var_5210 = 0;
+u16 var_5211 = 0;
+u16 var_5212 = 0;
+u16 var_5213 = 0;
+u16 var_5214 = 0;
+u16 var_5215 = 0;
+u16 var_5216 = 0;
+u16 var_5217 = 0;
+u16 var_5218 = 0;
+u16 var_5219 = 0;
+u16 var_5220 = 0;
+u16 var_5221 = 0;
+u16 var_5222 = 0;
+u16 var_5223 = 0;
+u16 var_5224 = 0;
+u16 var_5225 = 0;
+u16 var_5226 = 0;
+u16 var_5227 = 0;
+u16 var_5228 = 0;
+u16 var_5229 = 0;
+u16 var_5230 = 0;
+u16 var_5231 = 0;
+u16 var_5232 = 0;
+u16 var_5233 = 0;
+u16 var_5234 = 0;
+u16 var_5235 = 0;
+u16 var_5236 = 0;
+u16 var_5237 = 0;
+u16 var_5238 = 0;
+u16 var_5239 = 0;
+u16 var_5240 = 0;
+u16 var_5241 = 0;
+u16 var_5242 = 0;
+u16 var_5243 = 0;
+u16 var_5244 = 0;
+u16 var_5245 = 0;
+u16 var_5246 = 0;
+u16 var_5247 = 0;
+u16 var_5248 = 0;
+u16 var_5249 = 0;
+u16 var_5250 = 0;
+u16 var_5251 = 0;
+u16 var_5252 = 0;
+u16 var_5253 = 0;
+u16 var_5254 = 0;
+u16 var_5255 = 0;
+u16 var_5256 = 0;
+u16 var_5257 = 0;
+u16 var_5258 = 0;
+u16 var_5259 = 0;
+u16 var_5260 = 0;
+u16 var_5261 = 0;
+u16 var_5262 = 0;
+u16 var_5263 = 0;
+u16 var_5264 = 0;
+u16 var_5265 = 0;
+u16 var_5266 = 0;
+u16 var_5267 = 0;
+u16 var_5268 = 0;
+u16 var_5269 = 0;
+u16 var_5270 = 0;
+u16 var_5271 = 0;
+u16 var_5272 = 0;
+u16 var_5273 = 0;
+u16 var_5274 = 0;
+u16 var_5275 = 0;
+u16 var_5276 = 0;
+u16 var_5277 = 0;
+u16 var_5278 = 0;
+u16 var_5279 = 0;
+u16 var_5280 = 0;
+u16 var_5281 = 0;
+u16 var_5282 = 0;
+u16 var_5283 = 0;
+u16 var_5284 = 0;
+u16 var_5285 = 0;
+u16 var_5286 = 0;
+u16 var_5287 = 0;
+u16 var_5288 = 0;
+u16 var_5289 = 0;
+u16 var_5290 = 0;
+u16 var_5291 = 0;
+u16 var_5292 = 0;
+u16 var_5293 = 0;
+u16 var_5294 = 0;
+u16 var_5295 = 0;
+u16 var_5296 = 0;
+u16 var_5297 = 0;
+u16 var_5298 = 0;
+u16 var_5299 = 0;
+u16 var_5300 = 0;
+u16 var_5301 = 0;
+u16 var_5302 = 0;
+u16 var_5303 = 0;
+u16 var_5304 = 0;
+u16 var_5305 = 0;
+u16 var_5306 = 0;
+u16 var_5307 = 0;
+u16 var_5308 = 0;
+u16 var_5309 = 0;
+u16 var_5310 = 0;
+u16 var_5311 = 0;
+u16 var_5312 = 0;
+u16 var_5313 = 0;
+u16 var_5314 = 0;
+u16 var_5315 = 0;
+u16 var_5316 = 0;
+u16 var_5317 = 0;
+u16 var_5318 = 0;
+u16 var_5319 = 0;
+u16 var_5320 = 0;
+u16 var_5321 = 0;
+u16 var_5322 = 0;
+u16 var_5323 = 0;
+u16 var_5324 = 0;
+u16 var_5325 = 0;
+u16 var_5326 = 0;
+u16 var_5327 = 0;
+u16 var_5328 = 0;
+u16 var_5329 = 0;
+u16 var_5330 = 0;
+u16 var_5331 = 0;
+u16 var_5332 = 0;
+u16 var_5333 = 0;
+u16 var_5334 = 0;
+u16 var_5335 = 0;
+u16 var_5336 = 0;
+u16 var_5337 = 0;
+u16 var_5338 = 0;
+u16 var_5339 = 0;
+u16 var_5340 = 0;
+u16 var_5341 = 0;
+u16 var_5342 = 0;
+u16 var_5343 = 0;
+u16 var_5344 = 0;
+u16 var_5345 = 0;
+u16 var_5346 = 0;
+u16 var_5347 = 0;
+u16 var_5348 = 0;
+u16 var_5349 = 0;
+u16 var_5350 = 0;
+u16 var_5351 = 0;
+u16 var_5352 = 0;
+u16 var_5353 = 0;
+u16 var_5354 = 0;
+u16 var_5355 = 0;
+u16 var_5356 = 0;
+u16 var_5357 = 0;
+u16 var_5358 = 0;
+u16 var_5359 = 0;
+u16 var_5360 = 0;
+u16 var_5361 = 0;
+u16 var_5362 = 0;
+u16 var_5363 = 0;
+u16 var_5364 = 0;
+u16 var_5365 = 0;
+u16 var_5366 = 0;
+u16 var_5367 = 0;
+u16 var_5368 = 0;
+u16 var_5369 = 0;
+u16 var_5370 = 0;
+u16 var_5371 = 0;
+u16 var_5372 = 0;
+u16 var_5373 = 0;
+u16 var_5374 = 0;
+u16 var_5375 = 0;
+u16 var_5376 = 0;
+u16 var_5377 = 0;
+u16 var_5378 = 0;
+u16 var_5379 = 0;
+u16 var_5380 = 0;
+u16 var_5381 = 0;
+u16 var_5382 = 0;
+u16 var_5383 = 0;
+u16 var_5384 = 0;
+u16 var_5385 = 0;
+u16 var_5386 = 0;
+u16 var_5387 = 0;
+u16 var_5388 = 0;
+u16 var_5389 = 0;
+u16 var_5390 = 0;
+u16 var_5391 = 0;
+u16 var_5392 = 0;
+u16 var_5393 = 0;
+u16 var_5394 = 0;
+u16 var_5395 = 0;
+u16 var_5396 = 0;
+u16 var_5397 = 0;
+u16 var_5398 = 0;
+u16 var_5399 = 0;
+u16 var_5400 = 0;
+u16 var_5401 = 0;
+u16 var_5402 = 0;
+u16 var_5403 = 0;
+u16 var_5404 = 0;
+u16 var_5405 = 0;
+u16 var_5406 = 0;
+u16 var_5407 = 0;
+u16 var_5408 = 0;
+u16 var_5409 = 0;
+u16 var_5410 = 0;
+u16 var_5411 = 0;
+u16 var_5412 = 0;
+u16 var_5413 = 0;
+u16 var_5414 = 0;
+u16 var_5415 = 0;
+u16 var_5416 = 0;
+u16 var_5417 = 0;
+u16 var_5418 = 0;
+u16 var_5419 = 0;
+u16 var_5420 = 0;
+u16 var_5421 = 0;
+u16 var_5422 = 0;
+u16 var_5423 = 0;
+u16 var_5424 = 0;
+u16 var_5425 = 0;
+u16 var_5426 = 0;
+u16 var_5427 = 0;
+u16 var_5428 = 0;
+u16 var_5429 = 0;
+u16 var_5430 = 0;
+u16 var_5431 = 0;
+u16 var_5432 = 0;
+u16 var_5433 = 0;
+u16 var_5434 = 0;
+u16 var_5435 = 0;
+u16 var_5436 = 0;
+u16 var_5437 = 0;
+u16 var_5438 = 0;
+u16 var_5439 = 0;
+u16 var_5440 = 0;
+u16 var_5441 = 0;
+u16 var_5442 = 0;
+u16 var_5443 = 0;
+u16 var_5444 = 0;
+u16 var_5445 = 0;
+u16 var_5446 = 0;
+u16 var_5447 = 0;
+u16 var_5448 = 0;
+u16 var_5449 = 0;
+u16 var_5450 = 0;
+u16 var_5451 = 0;
+u16 var_5452 = 0;
+u16 var_5453 = 0;
+u16 var_5454 = 0;
+u16 var_5455 = 0;
+u16 var_5456 = 0;
+u16 var_5457 = 0;
+u16 var_5458 = 0;
+u16 var_5459 = 0;
+u16 var_5460 = 0;
+u16 var_5461 = 0;
+u16 var_5462 = 0;
+u16 var_5463 = 0;
+u16 var_5464 = 0;
+u16 var_5465 = 0;
+u16 var_5466 = 0;
+u16 var_5467 = 0;
+u16 var_5468 = 0;
+u16 var_5469 = 0;
+u16 var_5470 = 0;
+u16 var_5471 = 0;
+u16 var_5472 = 0;
+u16 var_5473 = 0;
+u16 var_5474 = 0;
+u16 var_5475 = 0;
+u16 var_5476 = 0;
+u16 var_5477 = 0;
+u16 var_5478 = 0;
+u16 var_5479 = 0;
+u16 var_5480 = 0;
+u16 var_5481 = 0;
+u16 var_5482 = 0;
+u16 var_5483 = 0;
+u16 var_5484 = 0;
+u16 var_5485 = 0;
+u16 var_5486 = 0;
+u16 var_5487 = 0;
+u16 var_5488 = 0;
+u16 var_5489 = 0;
+u16 var_5490 = 0;
+u16 var_5491 = 0;
+u16 var_5492 = 0;
+u16 var_5493 = 0;
+u16 var_5494 = 0;
+u16 var_5495 = 0;
+u16 var_5496 = 0;
+u16 var_5497 = 0;
+u16 var_5498 = 0;
+u16 var_5499 = 0;
+u16 var_5500 = 0;
+u16 var_5501 = 0;
+u16 var_5502 = 0;
+u16 var_5503 = 0;
+u16 var_5504 = 0;
+u16 var_5505 = 0;
+u16 var_5506 = 0;
+u16 var_5507 = 0;
+u16 var_5508 = 0;
+u16 var_5509 = 0;
+u16 var_5510 = 0;
+u16 var_5511 = 0;
+u16 var_5512 = 0;
+u16 var_5513 = 0;
+u16 var_5514 = 0;
+u16 var_5515 = 0;
+u16 var_5516 = 0;
+u16 var_5517 = 0;
+u16 var_5518 = 0;
+u16 var_5519 = 0;
+u16 var_5520 = 0;
+u16 var_5521 = 0;
+u16 var_5522 = 0;
+u16 var_5523 = 0;
+u16 var_5524 = 0;
+u16 var_5525 = 0;
+u16 var_5526 = 0;
+u16 var_5527 = 0;
+u16 var_5528 = 0;
+u16 var_5529 = 0;
+u16 var_5530 = 0;
+u16 var_5531 = 0;
+u16 var_5532 = 0;
+u16 var_5533 = 0;
+u16 var_5534 = 0;
+u16 var_5535 = 0;
+u16 var_5536 = 0;
+u16 var_5537 = 0;
+u16 var_5538 = 0;
+u16 var_5539 = 0;
+u16 var_5540 = 0;
+u16 var_5541 = 0;
+u16 var_5542 = 0;
+u16 var_5543 = 0;
+u16 var_5544 = 0;
+u16 var_5545 = 0;
+u16 var_5546 = 0;
+u16 var_5547 = 0;
+u16 var_5548 = 0;
+u16 var_5549 = 0;
+u16 var_5550 = 0;
+u16 var_5551 = 0;
+u16 var_5552 = 0;
+u16 var_5553 = 0;
+u16 var_5554 = 0;
+u16 var_5555 = 0;
+u16 var_5556 = 0;
+u16 var_5557 = 0;
+u16 var_5558 = 0;
+u16 var_5559 = 0;
+u16 var_5560 = 0;
+u16 var_5561 = 0;
+u16 var_5562 = 0;
+u16 var_5563 = 0;
+u16 var_5564 = 0;
+u16 var_5565 = 0;
+u16 var_5566 = 0;
+u16 var_5567 = 0;
+u16 var_5568 = 0;
+u16 var_5569 = 0;
+u16 var_5570 = 0;
+u16 var_5571 = 0;
+u16 var_5572 = 0;
+u16 var_5573 = 0;
+u16 var_5574 = 0;
+u16 var_5575 = 0;
+u16 var_5576 = 0;
+u16 var_5577 = 0;
+u16 var_5578 = 0;
+u16 var_5579 = 0;
+u16 var_5580 = 0;
+u16 var_5581 = 0;
+u16 var_5582 = 0;
+u16 var_5583 = 0;
+u16 var_5584 = 0;
+u16 var_5585 = 0;
+u16 var_5586 = 0;
+u16 var_5587 = 0;
+u16 var_5588 = 0;
+u16 var_5589 = 0;
+u16 var_5590 = 0;
+u16 var_5591 = 0;
+u16 var_5592 = 0;
+u16 var_5593 = 0;
+u16 var_5594 = 0;
+u16 var_5595 = 0;
+u16 var_5596 = 0;
+u16 var_5597 = 0;
+u16 var_5598 = 0;
+u16 var_5599 = 0;
+u16 var_5600 = 0;
+u16 var_5601 = 0;
+u16 var_5602 = 0;
+u16 var_5603 = 0;
+u16 var_5604 = 0;
+u16 var_5605 = 0;
+u16 var_5606 = 0;
+u16 var_5607 = 0;
+u16 var_5608 = 0;
+u16 var_5609 = 0;
+u16 var_5610 = 0;
+u16 var_5611 = 0;
+u16 var_5612 = 0;
+u16 var_5613 = 0;
+u16 var_5614 = 0;
+u16 var_5615 = 0;
+u16 var_5616 = 0;
+u16 var_5617 = 0;
+u16 var_5618 = 0;
+u16 var_5619 = 0;
+u16 var_5620 = 0;
+u16 var_5621 = 0;
+u16 var_5622 = 0;
+u16 var_5623 = 0;
+u16 var_5624 = 0;
+u16 var_5625 = 0;
+u16 var_5626 = 0;
+u16 var_5627 = 0;
+u16 var_5628 = 0;
+u16 var_5629 = 0;
+u16 var_5630 = 0;
+u16 var_5631 = 0;
+u16 var_5632 = 0;
+u16 var_5633 = 0;
+u16 var_5634 = 0;
+u16 var_5635 = 0;
+u16 var_5636 = 0;
+u16 var_5637 = 0;
+u16 var_5638 = 0;
+u16 var_5639 = 0;
+u16 var_5640 = 0;
+u16 var_5641 = 0;
+u16 var_5642 = 0;
+u16 var_5643 = 0;
+u16 var_5644 = 0;
+u16 var_5645 = 0;
+u16 var_5646 = 0;
+u16 var_5647 = 0;
+u16 var_5648 = 0;
+u16 var_5649 = 0;
+u16 var_5650 = 0;
+u16 var_5651 = 0;
+u16 var_5652 = 0;
+u16 var_5653 = 0;
+u16 var_5654 = 0;
+u16 var_5655 = 0;
+u16 var_5656 = 0;
+u16 var_5657 = 0;
+u16 var_5658 = 0;
+u16 var_5659 = 0;
+u16 var_5660 = 0;
+u16 var_5661 = 0;
+u16 var_5662 = 0;
+u16 var_5663 = 0;
+u16 var_5664 = 0;
+u16 var_5665 = 0;
+u16 var_5666 = 0;
+u16 var_5667 = 0;
+u16 var_5668 = 0;
+u16 var_5669 = 0;
+u16 var_5670 = 0;
+u16 var_5671 = 0;
+u16 var_5672 = 0;
+u16 var_5673 = 0;
+u16 var_5674 = 0;
+u16 var_5675 = 0;
+u16 var_5676 = 0;
+u16 var_5677 = 0;
+u16 var_5678 = 0;
+u16 var_5679 = 0;
+u16 var_5680 = 0;
+u16 var_5681 = 0;
+u16 var_5682 = 0;
+u16 var_5683 = 0;
+u16 var_5684 = 0;
+u16 var_5685 = 0;
+u16 var_5686 = 0;
+u16 var_5687 = 0;
+u16 var_5688 = 0;
+u16 var_5689 = 0;
+u16 var_5690 = 0;
+u16 var_5691 = 0;
+u16 var_5692 = 0;
+u16 var_5693 = 0;
+u16 var_5694 = 0;
+u16 var_5695 = 0;
+u16 var_5696 = 0;
+u16 var_5697 = 0;
+u16 var_5698 = 0;
+u16 var_5699 = 0;
+u16 var_5700 = 0;
+u16 var_5701 = 0;
+u16 var_5702 = 0;
+u16 var_5703 = 0;
+u16 var_5704 = 0;
+u16 var_5705 = 0;
+u16 var_5706 = 0;
+u16 var_5707 = 0;
+u16 var_5708 = 0;
+u16 var_5709 = 0;
+u16 var_5710 = 0;
+u16 var_5711 = 0;
+u16 var_5712 = 0;
+u16 var_5713 = 0;
+u16 var_5714 = 0;
+u16 var_5715 = 0;
+u16 var_5716 = 0;
+u16 var_5717 = 0;
+u16 var_5718 = 0;
+u16 var_5719 = 0;
+u16 var_5720 = 0;
+u16 var_5721 = 0;
+u16 var_5722 = 0;
+u16 var_5723 = 0;
+u16 var_5724 = 0;
+u16 var_5725 = 0;
+u16 var_5726 = 0;
+u16 var_5727 = 0;
+u16 var_5728 = 0;
+u16 var_5729 = 0;
+u16 var_5730 = 0;
+u16 var_5731 = 0;
+u16 var_5732 = 0;
+u16 var_5733 = 0;
+u16 var_5734 = 0;
+u16 var_5735 = 0;
+u16 var_5736 = 0;
+u16 var_5737 = 0;
+u16 var_5738 = 0;
+u16 var_5739 = 0;
+u16 var_5740 = 0;
+u16 var_5741 = 0;
+u16 var_5742 = 0;
+u16 var_5743 = 0;
+u16 var_5744 = 0;
+u16 var_5745 = 0;
+u16 var_5746 = 0;
+u16 var_5747 = 0;
+u16 var_5748 = 0;
+u16 var_5749 = 0;
+u16 var_5750 = 0;
+u16 var_5751 = 0;
+u16 var_5752 = 0;
+u16 var_5753 = 0;
+u16 var_5754 = 0;
+u16 var_5755 = 0;
+u16 var_5756 = 0;
+u16 var_5757 = 0;
+u16 var_5758 = 0;
+u16 var_5759 = 0;
+u16 var_5760 = 0;
+u16 var_5761 = 0;
+u16 var_5762 = 0;
+u16 var_5763 = 0;
+u16 var_5764 = 0;
+u16 var_5765 = 0;
+u16 var_5766 = 0;
+u16 var_5767 = 0;
+u16 var_5768 = 0;
+u16 var_5769 = 0;
+u16 var_5770 = 0;
+u16 var_5771 = 0;
+u16 var_5772 = 0;
+u16 var_5773 = 0;
+u16 var_5774 = 0;
+u16 var_5775 = 0;
+u16 var_5776 = 0;
+u16 var_5777 = 0;
+u16 var_5778 = 0;
+u16 var_5779 = 0;
+u16 var_5780 = 0;
+u16 var_5781 = 0;
+u16 var_5782 = 0;
+u16 var_5783 = 0;
+u16 var_5784 = 0;
+u16 var_5785 = 0;
+u16 var_5786 = 0;
+u16 var_5787 = 0;
+u16 var_5788 = 0;
+u16 var_5789 = 0;
+u16 var_5790 = 0;
+u16 var_5791 = 0;
+u16 var_5792 = 0;
+u16 var_5793 = 0;
+u16 var_5794 = 0;
+u16 var_5795 = 0;
+u16 var_5796 = 0;
+u16 var_5797 = 0;
+u16 var_5798 = 0;
+u16 var_5799 = 0;
+u16 var_5800 = 0;
+u16 var_5801 = 0;
+u16 var_5802 = 0;
+u16 var_5803 = 0;
+u16 var_5804 = 0;
+u16 var_5805 = 0;
+u16 var_5806 = 0;
+u16 var_5807 = 0;
+u16 var_5808 = 0;
+u16 var_5809 = 0;
+u16 var_5810 = 0;
+u16 var_5811 = 0;
+u16 var_5812 = 0;
+u16 var_5813 = 0;
+u16 var_5814 = 0;
+u16 var_5815 = 0;
+u16 var_5816 = 0;
+u16 var_5817 = 0;
+u16 var_5818 = 0;
+u16 var_5819 = 0;
+u16 var_5820 = 0;
+u16 var_5821 = 0;
+u16 var_5822 = 0;
+u16 var_5823 = 0;
+u16 var_5824 = 0;
+u16 var_5825 = 0;
+u16 var_5826 = 0;
+u16 var_5827 = 0;
+u16 var_5828 = 0;
+u16 var_5829 = 0;
+u16 var_5830 = 0;
+u16 var_5831 = 0;
+u16 var_5832 = 0;
+u16 var_5833 = 0;
+u16 var_5834 = 0;
+u16 var_5835 = 0;
+u16 var_5836 = 0;
+u16 var_5837 = 0;
+u16 var_5838 = 0;
+u16 var_5839 = 0;
+u16 var_5840 = 0;
+u16 var_5841 = 0;
+u16 var_5842 = 0;
+u16 var_5843 = 0;
+u16 var_5844 = 0;
+u16 var_5845 = 0;
+u16 var_5846 = 0;
+u16 var_5847 = 0;
+u16 var_5848 = 0;
+u16 var_5849 = 0;
+u16 var_5850 = 0;
+u16 var_5851 = 0;
+u16 var_5852 = 0;
+u16 var_5853 = 0;
+u16 var_5854 = 0;
+u16 var_5855 = 0;
+u16 var_5856 = 0;
+u16 var_5857 = 0;
+u16 var_5858 = 0;
+u16 var_5859 = 0;
+u16 var_5860 = 0;
+u16 var_5861 = 0;
+u16 var_5862 = 0;
+u16 var_5863 = 0;
+u16 var_5864 = 0;
+u16 var_5865 = 0;
+u16 var_5866 = 0;
+u16 var_5867 = 0;
+u16 var_5868 = 0;
+u16 var_5869 = 0;
+u16 var_5870 = 0;
+u16 var_5871 = 0;
+u16 var_5872 = 0;
+u16 var_5873 = 0;
+u16 var_5874 = 0;
+u16 var_5875 = 0;
+u16 var_5876 = 0;
+u16 var_5877 = 0;
+u16 var_5878 = 0;
+u16 var_5879 = 0;
+u16 var_5880 = 0;
+u16 var_5881 = 0;
+u16 var_5882 = 0;
+u16 var_5883 = 0;
+u16 var_5884 = 0;
+u16 var_5885 = 0;
+u16 var_5886 = 0;
+u16 var_5887 = 0;
+u16 var_5888 = 0;
+u16 var_5889 = 0;
+u16 var_5890 = 0;
+u16 var_5891 = 0;
+u16 var_5892 = 0;
+u16 var_5893 = 0;
+u16 var_5894 = 0;
+u16 var_5895 = 0;
+u16 var_5896 = 0;
+u16 var_5897 = 0;
+u16 var_5898 = 0;
+u16 var_5899 = 0;
+u16 var_5900 = 0;
+u16 var_5901 = 0;
+u16 var_5902 = 0;
+u16 var_5903 = 0;
+u16 var_5904 = 0;
+u16 var_5905 = 0;
+u16 var_5906 = 0;
+u16 var_5907 = 0;
+u16 var_5908 = 0;
+u16 var_5909 = 0;
+u16 var_5910 = 0;
+u16 var_5911 = 0;
+u16 var_5912 = 0;
+u16 var_5913 = 0;
+u16 var_5914 = 0;
+u16 var_5915 = 0;
+u16 var_5916 = 0;
+u16 var_5917 = 0;
+u16 var_5918 = 0;
+u16 var_5919 = 0;
+u16 var_5920 = 0;
+u16 var_5921 = 0;
+u16 var_5922 = 0;
+u16 var_5923 = 0;
+u16 var_5924 = 0;
+u16 var_5925 = 0;
+u16 var_5926 = 0;
+u16 var_5927 = 0;
+u16 var_5928 = 0;
+u16 var_5929 = 0;
+u16 var_5930 = 0;
+u16 var_5931 = 0;
+u16 var_5932 = 0;
+u16 var_5933 = 0;
+u16 var_5934 = 0;
+u16 var_5935 = 0;
+u16 var_5936 = 0;
+u16 var_5937 = 0;
+u16 var_5938 = 0;
+u16 var_5939 = 0;
+u16 var_5940 = 0;
+u16 var_5941 = 0;
+u16 var_5942 = 0;
+u16 var_5943 = 0;
+u16 var_5944 = 0;
+u16 var_5945 = 0;
+u16 var_5946 = 0;
+u16 var_5947 = 0;
+u16 var_5948 = 0;
+u16 var_5949 = 0;
+u16 var_5950 = 0;
+u16 var_5951 = 0;
+u16 var_5952 = 0;
+u16 var_5953 = 0;
+u16 var_5954 = 0;
+u16 var_5955 = 0;
+u16 var_5956 = 0;
+u16 var_5957 = 0;
+u16 var_5958 = 0;
+u16 var_5959 = 0;
+u16 var_5960 = 0;
+u16 var_5961 = 0;
+u16 var_5962 = 0;
+u16 var_5963 = 0;
+u16 var_5964 = 0;
+u16 var_5965 = 0;
+u16 var_5966 = 0;
+u16 var_5967 = 0;
+u16 var_5968 = 0;
+u16 var_5969 = 0;
+u16 var_5970 = 0;
+u16 var_5971 = 0;
+u16 var_5972 = 0;
+u16 var_5973 = 0;
+u16 var_5974 = 0;
+u16 var_5975 = 0;
+u16 var_5976 = 0;
+u16 var_5977 = 0;
+u16 var_5978 = 0;
+u16 var_5979 = 0;
+u16 var_5980 = 0;
+u16 var_5981 = 0;
+u16 var_5982 = 0;
+u16 var_5983 = 0;
+u16 var_5984 = 0;
+u16 var_5985 = 0;
+u16 var_5986 = 0;
+u16 var_5987 = 0;
+u16 var_5988 = 0;
+u16 var_5989 = 0;
+u16 var_5990 = 0;
+u16 var_5991 = 0;
+u16 var_5992 = 0;
+u16 var_5993 = 0;
+u16 var_5994 = 0;
+u16 var_5995 = 0;
+u16 var_5996 = 0;
+u16 var_5997 = 0;
+u16 var_5998 = 0;
+u16 var_5999 = 0;
+u16 var_6000 = 0;
+u16 var_6001 = 0;
+u16 var_6002 = 0;
+u16 var_6003 = 0;
+u16 var_6004 = 0;
+u16 var_6005 = 0;
+u16 var_6006 = 0;
+u16 var_6007 = 0;
+u16 var_6008 = 0;
+u16 var_6009 = 0;
+u16 var_6010 = 0;
+u16 var_6011 = 0;
+u16 var_6012 = 0;
+u16 var_6013 = 0;
+u16 var_6014 = 0;
+u16 var_6015 = 0;
+u16 var_6016 = 0;
+u16 var_6017 = 0;
+u16 var_6018 = 0;
+u16 var_6019 = 0;
+u16 var_6020 = 0;
+u16 var_6021 = 0;
+u16 var_6022 = 0;
+u16 var_6023 = 0;
+u16 var_6024 = 0;
+u16 var_6025 = 0;
+u16 var_6026 = 0;
+u16 var_6027 = 0;
+u16 var_6028 = 0;
+u16 var_6029 = 0;
+u16 var_6030 = 0;
+u16 var_6031 = 0;
+u16 var_6032 = 0;
+u16 var_6033 = 0;
+u16 var_6034 = 0;
+u16 var_6035 = 0;
+u16 var_6036 = 0;
+u16 var_6037 = 0;
+u16 var_6038 = 0;
+u16 var_6039 = 0;
+u16 var_6040 = 0;
+u16 var_6041 = 0;
+u16 var_6042 = 0;
+u16 var_6043 = 0;
+u16 var_6044 = 0;
+u16 var_6045 = 0;
+u16 var_6046 = 0;
+u16 var_6047 = 0;
+u16 var_6048 = 0;
+u16 var_6049 = 0;
+u16 var_6050 = 0;
+u16 var_6051 = 0;
+u16 var_6052 = 0;
+u16 var_6053 = 0;
+u16 var_6054 = 0;
+u16 var_6055 = 0;
+u16 var_6056 = 0;
+u16 var_6057 = 0;
+u16 var_6058 = 0;
+u16 var_6059 = 0;
+u16 var_6060 = 0;
+u16 var_6061 = 0;
+u16 var_6062 = 0;
+u16 var_6063 = 0;
+u16 var_6064 = 0;
+u16 var_6065 = 0;
+u16 var_6066 = 0;
+u16 var_6067 = 0;
+u16 var_6068 = 0;
+u16 var_6069 = 0;
+u16 var_6070 = 0;
+u16 var_6071 = 0;
+u16 var_6072 = 0;
+u16 var_6073 = 0;
+u16 var_6074 = 0;
+u16 var_6075 = 0;
+u16 var_6076 = 0;
+u16 var_6077 = 0;
+u16 var_6078 = 0;
+u16 var_6079 = 0;
+u16 var_6080 = 0;
+u16 var_6081 = 0;
+u16 var_6082 = 0;
+u16 var_6083 = 0;
+u16 var_6084 = 0;
+u16 var_6085 = 0;
+u16 var_6086 = 0;
+u16 var_6087 = 0;
+u16 var_6088 = 0;
+u16 var_6089 = 0;
+u16 var_6090 = 0;
+u16 var_6091 = 0;
+u16 var_6092 = 0;
+u16 var_6093 = 0;
+u16 var_6094 = 0;
+u16 var_6095 = 0;
+u16 var_6096 = 0;
+u16 var_6097 = 0;
+u16 var_6098 = 0;
+u16 var_6099 = 0;
+u16 var_6100 = 0;
+u16 var_6101 = 0;
+u16 var_6102 = 0;
+u16 var_6103 = 0;
+u16 var_6104 = 0;
+u16 var_6105 = 0;
+u16 var_6106 = 0;
+u16 var_6107 = 0;
+u16 var_6108 = 0;
+u16 var_6109 = 0;
+u16 var_6110 = 0;
+u16 var_6111 = 0;
+u16 var_6112 = 0;
+u16 var_6113 = 0;
+u16 var_6114 = 0;
+u16 var_6115 = 0;
+u16 var_6116 = 0;
+u16 var_6117 = 0;
+u16 var_6118 = 0;
+u16 var_6119 = 0;
+u16 var_6120 = 0;
+u16 var_6121 = 0;
+u16 var_6122 = 0;
+u16 var_6123 = 0;
+u16 var_6124 = 0;
+u16 var_6125 = 0;
+u16 var_6126 = 0;
+u16 var_6127 = 0;
+u16 var_6128 = 0;
+u16 var_6129 = 0;
+u16 var_6130 = 0;
+u16 var_6131 = 0;
+u16 var_6132 = 0;
+u16 var_6133 = 0;
+u16 var_6134 = 0;
+u16 var_6135 = 0;
+u16 var_6136 = 0;
+u16 var_6137 = 0;
+u16 var_6138 = 0;
+u16 var_6139 = 0;
+u16 var_6140 = 0;
+u16 var_6141 = 0;
+u16 var_6142 = 0;
+u16 var_6143 = 0;
+u16 var_6144 = 0;
+u16 var_6145 = 0;
+u16 var_6146 = 0;
+u16 var_6147 = 0;
+u16 var_6148 = 0;
+u16 var_6149 = 0;
+u16 var_6150 = 0;
+u16 var_6151 = 0;
+u16 var_6152 = 0;
+u16 var_6153 = 0;
+u16 var_6154 = 0;
+u16 var_6155 = 0;
+u16 var_6156 = 0;
+u16 var_6157 = 0;
+u16 var_6158 = 0;
+u16 var_6159 = 0;
+u16 var_6160 = 0;
+u16 var_6161 = 0;
+u16 var_6162 = 0;
+u16 var_6163 = 0;
+u16 var_6164 = 0;
+u16 var_6165 = 0;
+u16 var_6166 = 0;
+u16 var_6167 = 0;
+u16 var_6168 = 0;
+u16 var_6169 = 0;
+u16 var_6170 = 0;
+u16 var_6171 = 0;
+u16 var_6172 = 0;
+u16 var_6173 = 0;
+u16 var_6174 = 0;
+u16 var_6175 = 0;
+u16 var_6176 = 0;
+u16 var_6177 = 0;
+u16 var_6178 = 0;
+u16 var_6179 = 0;
+u16 var_6180 = 0;
+u16 var_6181 = 0;
+u16 var_6182 = 0;
+u16 var_6183 = 0;
+u16 var_6184 = 0;
+u16 var_6185 = 0;
+u16 var_6186 = 0;
+u16 var_6187 = 0;
+u16 var_6188 = 0;
+u16 var_6189 = 0;
+u16 var_6190 = 0;
+u16 var_6191 = 0;
+u16 var_6192 = 0;
+u16 var_6193 = 0;
+u16 var_6194 = 0;
+u16 var_6195 = 0;
+u16 var_6196 = 0;
+u16 var_6197 = 0;
+u16 var_6198 = 0;
+u16 var_6199 = 0;
+u16 var_6200 = 0;
+u16 var_6201 = 0;
+u16 var_6202 = 0;
+u16 var_6203 = 0;
+u16 var_6204 = 0;
+u16 var_6205 = 0;
+u16 var_6206 = 0;
+u16 var_6207 = 0;
+u16 var_6208 = 0;
+u16 var_6209 = 0;
+u16 var_6210 = 0;
+u16 var_6211 = 0;
+u16 var_6212 = 0;
+u16 var_6213 = 0;
+u16 var_6214 = 0;
+u16 var_6215 = 0;
+u16 var_6216 = 0;
+u16 var_6217 = 0;
+u16 var_6218 = 0;
+u16 var_6219 = 0;
+u16 var_6220 = 0;
+u16 var_6221 = 0;
+u16 var_6222 = 0;
+u16 var_6223 = 0;
+u16 var_6224 = 0;
+u16 var_6225 = 0;
+u16 var_6226 = 0;
+u16 var_6227 = 0;
+u16 var_6228 = 0;
+u16 var_6229 = 0;
+u16 var_6230 = 0;
+u16 var_6231 = 0;
+u16 var_6232 = 0;
+u16 var_6233 = 0;
+u16 var_6234 = 0;
+u16 var_6235 = 0;
+u16 var_6236 = 0;
+u16 var_6237 = 0;
+u16 var_6238 = 0;
+u16 var_6239 = 0;
+u16 var_6240 = 0;
+u16 var_6241 = 0;
+u16 var_6242 = 0;
+u16 var_6243 = 0;
+u16 var_6244 = 0;
+u16 var_6245 = 0;
+u16 var_6246 = 0;
+u16 var_6247 = 0;
+u16 var_6248 = 0;
+u16 var_6249 = 0;
+u16 var_6250 = 0;
+u16 var_6251 = 0;
+u16 var_6252 = 0;
+u16 var_6253 = 0;
+u16 var_6254 = 0;
+u16 var_6255 = 0;
+u16 var_6256 = 0;
+u16 var_6257 = 0;
+u16 var_6258 = 0;
+u16 var_6259 = 0;
+u16 var_6260 = 0;
+u16 var_6261 = 0;
+u16 var_6262 = 0;
+u16 var_6263 = 0;
+u16 var_6264 = 0;
+u16 var_6265 = 0;
+u16 var_6266 = 0;
+u16 var_6267 = 0;
+u16 var_6268 = 0;
+u16 var_6269 = 0;
+u16 var_6270 = 0;
+u16 var_6271 = 0;
+u16 var_6272 = 0;
+u16 var_6273 = 0;
+u16 var_6274 = 0;
+u16 var_6275 = 0;
+u16 var_6276 = 0;
+u16 var_6277 = 0;
+u16 var_6278 = 0;
+u16 var_6279 = 0;
+u16 var_6280 = 0;
+u16 var_6281 = 0;
+u16 var_6282 = 0;
+u16 var_6283 = 0;
+u16 var_6284 = 0;
+u16 var_6285 = 0;
+u16 var_6286 = 0;
+u16 var_6287 = 0;
+u16 var_6288 = 0;
+u16 var_6289 = 0;
+u16 var_6290 = 0;
+u16 var_6291 = 0;
+u16 var_6292 = 0;
+u16 var_6293 = 0;
+u16 var_6294 = 0;
+u16 var_6295 = 0;
+u16 var_6296 = 0;
+u16 var_6297 = 0;
+u16 var_6298 = 0;
+u16 var_6299 = 0;
+u16 var_6300 = 0;
+u16 var_6301 = 0;
+u16 var_6302 = 0;
+u16 var_6303 = 0;
+u16 var_6304 = 0;
+u16 var_6305 = 0;
+u16 var_6306 = 0;
+u16 var_6307 = 0;
+u16 var_6308 = 0;
+u16 var_6309 = 0;
+u16 var_6310 = 0;
+u16 var_6311 = 0;
+u16 var_6312 = 0;
+u16 var_6313 = 0;
+u16 var_6314 = 0;
+u16 var_6315 = 0;
+u16 var_6316 = 0;
+u16 var_6317 = 0;
+u16 var_6318 = 0;
+u16 var_6319 = 0;
+u16 var_6320 = 0;
+u16 var_6321 = 0;
+u16 var_6322 = 0;
+u16 var_6323 = 0;
+u16 var_6324 = 0;
+u16 var_6325 = 0;
+u16 var_6326 = 0;
+u16 var_6327 = 0;
+u16 var_6328 = 0;
+u16 var_6329 = 0;
+u16 var_6330 = 0;
+u16 var_6331 = 0;
+u16 var_6332 = 0;
+u16 var_6333 = 0;
+u16 var_6334 = 0;
+u16 var_6335 = 0;
+u16 var_6336 = 0;
+u16 var_6337 = 0;
+u16 var_6338 = 0;
+u16 var_6339 = 0;
+u16 var_6340 = 0;
+u16 var_6341 = 0;
+u16 var_6342 = 0;
+u16 var_6343 = 0;
+u16 var_6344 = 0;
+u16 var_6345 = 0;
+u16 var_6346 = 0;
+u16 var_6347 = 0;
+u16 var_6348 = 0;
+u16 var_6349 = 0;
+u16 var_6350 = 0;
+u16 var_6351 = 0;
+u16 var_6352 = 0;
+u16 var_6353 = 0;
+u16 var_6354 = 0;
+u16 var_6355 = 0;
+u16 var_6356 = 0;
+u16 var_6357 = 0;
+u16 var_6358 = 0;
+u16 var_6359 = 0;
+u16 var_6360 = 0;
+u16 var_6361 = 0;
+u16 var_6362 = 0;
+u16 var_6363 = 0;
+u16 var_6364 = 0;
+u16 var_6365 = 0;
+u16 var_6366 = 0;
+u16 var_6367 = 0;
+u16 var_6368 = 0;
+u16 var_6369 = 0;
+u16 var_6370 = 0;
+u16 var_6371 = 0;
+u16 var_6372 = 0;
+u16 var_6373 = 0;
+u16 var_6374 = 0;
+u16 var_6375 = 0;
+u16 var_6376 = 0;
+u16 var_6377 = 0;
+u16 var_6378 = 0;
+u16 var_6379 = 0;
+u16 var_6380 = 0;
+u16 var_6381 = 0;
+u16 var_6382 = 0;
+u16 var_6383 = 0;
+u16 var_6384 = 0;
+u16 var_6385 = 0;
+u16 var_6386 = 0;
+u16 var_6387 = 0;
+u16 var_6388 = 0;
+u16 var_6389 = 0;
+u16 var_6390 = 0;
+u16 var_6391 = 0;
+u16 var_6392 = 0;
+u16 var_6393 = 0;
+u16 var_6394 = 0;
+u16 var_6395 = 0;
+u16 var_6396 = 0;
+u16 var_6397 = 0;
+u16 var_6398 = 0;
+u16 var_6399 = 0;
+u16 var_6400 = 0;
+u16 var_6401 = 0;
+u16 var_6402 = 0;
+u16 var_6403 = 0;
+u16 var_6404 = 0;
+u16 var_6405 = 0;
+u16 var_6406 = 0;
+u16 var_6407 = 0;
+u16 var_6408 = 0;
+u16 var_6409 = 0;
+u16 var_6410 = 0;
+u16 var_6411 = 0;
+u16 var_6412 = 0;
+u16 var_6413 = 0;
+u16 var_6414 = 0;
+u16 var_6415 = 0;
+u16 var_6416 = 0;
+u16 var_6417 = 0;
+u16 var_6418 = 0;
+u16 var_6419 = 0;
+u16 var_6420 = 0;
+u16 var_6421 = 0;
+u16 var_6422 = 0;
+u16 var_6423 = 0;
+u16 var_6424 = 0;
+u16 var_6425 = 0;
+u16 var_6426 = 0;
+u16 var_6427 = 0;
+u16 var_6428 = 0;
+u16 var_6429 = 0;
+u16 var_6430 = 0;
+u16 var_6431 = 0;
+u16 var_6432 = 0;
+u16 var_6433 = 0;
+u16 var_6434 = 0;
+u16 var_6435 = 0;
+u16 var_6436 = 0;
+u16 var_6437 = 0;
+u16 var_6438 = 0;
+u16 var_6439 = 0;
+u16 var_6440 = 0;
+u16 var_6441 = 0;
+u16 var_6442 = 0;
+u16 var_6443 = 0;
+u16 var_6444 = 0;
+u16 var_6445 = 0;
+u16 var_6446 = 0;
+u16 var_6447 = 0;
+u16 var_6448 = 0;
+u16 var_6449 = 0;
+u16 var_6450 = 0;
+u16 var_6451 = 0;
+u16 var_6452 = 0;
+u16 var_6453 = 0;
+u16 var_6454 = 0;
+u16 var_6455 = 0;
+u16 var_6456 = 0;
+u16 var_6457 = 0;
+u16 var_6458 = 0;
+u16 var_6459 = 0;
+u16 var_6460 = 0;
+u16 var_6461 = 0;
+u16 var_6462 = 0;
+u16 var_6463 = 0;
+u16 var_6464 = 0;
+u16 var_6465 = 0;
+u16 var_6466 = 0;
+u16 var_6467 = 0;
+u16 var_6468 = 0;
+u16 var_6469 = 0;
+u16 var_6470 = 0;
+u16 var_6471 = 0;
+u16 var_6472 = 0;
+u16 var_6473 = 0;
+u16 var_6474 = 0;
+u16 var_6475 = 0;
+u16 var_6476 = 0;
+u16 var_6477 = 0;
+u16 var_6478 = 0;
+u16 var_6479 = 0;
+u16 var_6480 = 0;
+u16 var_6481 = 0;
+u16 var_6482 = 0;
+u16 var_6483 = 0;
+u16 var_6484 = 0;
+u16 var_6485 = 0;
+u16 var_6486 = 0;
+u16 var_6487 = 0;
+u16 var_6488 = 0;
+u16 var_6489 = 0;
+u16 var_6490 = 0;
+u16 var_6491 = 0;
+u16 var_6492 = 0;
+u16 var_6493 = 0;
+u16 var_6494 = 0;
+u16 var_6495 = 0;
+u16 var_6496 = 0;
+u16 var_6497 = 0;
+u16 var_6498 = 0;
+u16 var_6499 = 0;
+u16 var_6500 = 0;
+u16 var_6501 = 0;
+u16 var_6502 = 0;
+u16 var_6503 = 0;
+u16 var_6504 = 0;
+u16 var_6505 = 0;
+u16 var_6506 = 0;
+u16 var_6507 = 0;
+u16 var_6508 = 0;
+u16 var_6509 = 0;
+u16 var_6510 = 0;
+u16 var_6511 = 0;
+u16 var_6512 = 0;
+u16 var_6513 = 0;
+u16 var_6514 = 0;
+u16 var_6515 = 0;
+u16 var_6516 = 0;
+u16 var_6517 = 0;
+u16 var_6518 = 0;
+u16 var_6519 = 0;
+u16 var_6520 = 0;
+u16 var_6521 = 0;
+u16 var_6522 = 0;
+u16 var_6523 = 0;
+u16 var_6524 = 0;
+u16 var_6525 = 0;
+u16 var_6526 = 0;
+u16 var_6527 = 0;
+u16 var_6528 = 0;
+u16 var_6529 = 0;
+u16 var_6530 = 0;
+u16 var_6531 = 0;
+u16 var_6532 = 0;
+u16 var_6533 = 0;
+u16 var_6534 = 0;
+u16 var_6535 = 0;
+u16 var_6536 = 0;
+u16 var_6537 = 0;
+u16 var_6538 = 0;
+u16 var_6539 = 0;
+u16 var_6540 = 0;
+u16 var_6541 = 0;
+u16 var_6542 = 0;
+u16 var_6543 = 0;
+u16 var_6544 = 0;
+u16 var_6545 = 0;
+u16 var_6546 = 0;
+u16 var_6547 = 0;
+u16 var_6548 = 0;
+u16 var_6549 = 0;
+u16 var_6550 = 0;
+u16 var_6551 = 0;
+u16 var_6552 = 0;
+u16 var_6553 = 0;
+u16 var_6554 = 0;
+u16 var_6555 = 0;
+u16 var_6556 = 0;
+u16 var_6557 = 0;
+u16 var_6558 = 0;
+u16 var_6559 = 0;
+u16 var_6560 = 0;
+u16 var_6561 = 0;
+u16 var_6562 = 0;
+u16 var_6563 = 0;
+u16 var_6564 = 0;
+u16 var_6565 = 0;
+u16 var_6566 = 0;
+u16 var_6567 = 0;
+u16 var_6568 = 0;
+u16 var_6569 = 0;
+u16 var_6570 = 0;
+u16 var_6571 = 0;
+u16 var_6572 = 0;
+u16 var_6573 = 0;
+u16 var_6574 = 0;
+u16 var_6575 = 0;
+u16 var_6576 = 0;
+u16 var_6577 = 0;
+u16 var_6578 = 0;
+u16 var_6579 = 0;
+u16 var_6580 = 0;
+u16 var_6581 = 0;
+u16 var_6582 = 0;
+u16 var_6583 = 0;
+u16 var_6584 = 0;
+u16 var_6585 = 0;
+u16 var_6586 = 0;
+u16 var_6587 = 0;
+u16 var_6588 = 0;
+u16 var_6589 = 0;
+u16 var_6590 = 0;
+u16 var_6591 = 0;
+u16 var_6592 = 0;
+u16 var_6593 = 0;
+u16 var_6594 = 0;
+u16 var_6595 = 0;
+u16 var_6596 = 0;
+u16 var_6597 = 0;
+u16 var_6598 = 0;
+u16 var_6599 = 0;
+u16 var_6600 = 0;
+u16 var_6601 = 0;
+u16 var_6602 = 0;
+u16 var_6603 = 0;
+u16 var_6604 = 0;
+u16 var_6605 = 0;
+u16 var_6606 = 0;
+u16 var_6607 = 0;
+u16 var_6608 = 0;
+u16 var_6609 = 0;
+u16 var_6610 = 0;
+u16 var_6611 = 0;
+u16 var_6612 = 0;
+u16 var_6613 = 0;
+u16 var_6614 = 0;
+u16 var_6615 = 0;
+u16 var_6616 = 0;
+u16 var_6617 = 0;
+u16 var_6618 = 0;
+u16 var_6619 = 0;
+u16 var_6620 = 0;
+u16 var_6621 = 0;
+u16 var_6622 = 0;
+u16 var_6623 = 0;
+u16 var_6624 = 0;
+u16 var_6625 = 0;
+u16 var_6626 = 0;
+u16 var_6627 = 0;
+u16 var_6628 = 0;
+u16 var_6629 = 0;
+u16 var_6630 = 0;
+u16 var_6631 = 0;
+u16 var_6632 = 0;
+u16 var_6633 = 0;
+u16 var_6634 = 0;
+u16 var_6635 = 0;
+u16 var_6636 = 0;
+u16 var_6637 = 0;
+u16 var_6638 = 0;
+u16 var_6639 = 0;
+u16 var_6640 = 0;
+u16 var_6641 = 0;
+u16 var_6642 = 0;
+u16 var_6643 = 0;
+u16 var_6644 = 0;
+u16 var_6645 = 0;
+u16 var_6646 = 0;
+u16 var_6647 = 0;
+u16 var_6648 = 0;
+u16 var_6649 = 0;
+u16 var_6650 = 0;
+u16 var_6651 = 0;
+u16 var_6652 = 0;
+u16 var_6653 = 0;
+u16 var_6654 = 0;
+u16 var_6655 = 0;
+u16 var_6656 = 0;
+u16 var_6657 = 0;
+u16 var_6658 = 0;
+u16 var_6659 = 0;
+u16 var_6660 = 0;
+u16 var_6661 = 0;
+u16 var_6662 = 0;
+u16 var_6663 = 0;
+u16 var_6664 = 0;
+u16 var_6665 = 0;
+u16 var_6666 = 0;
+u16 var_6667 = 0;
+u16 var_6668 = 0;
+u16 var_6669 = 0;
+u16 var_6670 = 0;
+u16 var_6671 = 0;
+u16 var_6672 = 0;
+u16 var_6673 = 0;
+u16 var_6674 = 0;
+u16 var_6675 = 0;
+u16 var_6676 = 0;
+u16 var_6677 = 0;
+u16 var_6678 = 0;
+u16 var_6679 = 0;
+u16 var_6680 = 0;
+u16 var_6681 = 0;
+u16 var_6682 = 0;
+u16 var_6683 = 0;
+u16 var_6684 = 0;
+u16 var_6685 = 0;
+u16 var_6686 = 0;
+u16 var_6687 = 0;
+u16 var_6688 = 0;
+u16 var_6689 = 0;
+u16 var_6690 = 0;
+u16 var_6691 = 0;
+u16 var_6692 = 0;
+u16 var_6693 = 0;
+u16 var_6694 = 0;
+u16 var_6695 = 0;
+u16 var_6696 = 0;
+u16 var_6697 = 0;
+u16 var_6698 = 0;
+u16 var_6699 = 0;
+u16 var_6700 = 0;
+u16 var_6701 = 0;
+u16 var_6702 = 0;
+u16 var_6703 = 0;
+u16 var_6704 = 0;
+u16 var_6705 = 0;
+u16 var_6706 = 0;
+u16 var_6707 = 0;
+u16 var_6708 = 0;
+u16 var_6709 = 0;
+u16 var_6710 = 0;
+u16 var_6711 = 0;
+u16 var_6712 = 0;
+u16 var_6713 = 0;
+u16 var_6714 = 0;
+u16 var_6715 = 0;
+u16 var_6716 = 0;
+u16 var_6717 = 0;
+u16 var_6718 = 0;
+u16 var_6719 = 0;
+u16 var_6720 = 0;
+u16 var_6721 = 0;
+u16 var_6722 = 0;
+u16 var_6723 = 0;
+u16 var_6724 = 0;
+u16 var_6725 = 0;
+u16 var_6726 = 0;
+u16 var_6727 = 0;
+u16 var_6728 = 0;
+u16 var_6729 = 0;
+u16 var_6730 = 0;
+u16 var_6731 = 0;
+u16 var_6732 = 0;
+u16 var_6733 = 0;
+u16 var_6734 = 0;
+u16 var_6735 = 0;
+u16 var_6736 = 0;
+u16 var_6737 = 0;
+u16 var_6738 = 0;
+u16 var_6739 = 0;
+u16 var_6740 = 0;
+u16 var_6741 = 0;
+u16 var_6742 = 0;
+u16 var_6743 = 0;
+u16 var_6744 = 0;
+u16 var_6745 = 0;
+u16 var_6746 = 0;
+u16 var_6747 = 0;
+u16 var_6748 = 0;
+u16 var_6749 = 0;
+u16 var_6750 = 0;
+u16 var_6751 = 0;
+u16 var_6752 = 0;
+u16 var_6753 = 0;
+u16 var_6754 = 0;
+u16 var_6755 = 0;
+u16 var_6756 = 0;
+u16 var_6757 = 0;
+u16 var_6758 = 0;
+u16 var_6759 = 0;
+u16 var_6760 = 0;
+u16 var_6761 = 0;
+u16 var_6762 = 0;
+u16 var_6763 = 0;
+u16 var_6764 = 0;
+u16 var_6765 = 0;
+u16 var_6766 = 0;
+u16 var_6767 = 0;
+u16 var_6768 = 0;
+u16 var_6769 = 0;
+u16 var_6770 = 0;
+u16 var_6771 = 0;
+u16 var_6772 = 0;
+u16 var_6773 = 0;
+u16 var_6774 = 0;
+u16 var_6775 = 0;
+u16 var_6776 = 0;
+u16 var_6777 = 0;
+u16 var_6778 = 0;
+u16 var_6779 = 0;
+u16 var_6780 = 0;
+u16 var_6781 = 0;
+u16 var_6782 = 0;
+u16 var_6783 = 0;
+u16 var_6784 = 0;
+u16 var_6785 = 0;
+u16 var_6786 = 0;
+u16 var_6787 = 0;
+u16 var_6788 = 0;
+u16 var_6789 = 0;
+u16 var_6790 = 0;
+u16 var_6791 = 0;
+u16 var_6792 = 0;
+u16 var_6793 = 0;
+u16 var_6794 = 0;
+u16 var_6795 = 0;
+u16 var_6796 = 0;
+u16 var_6797 = 0;
+u16 var_6798 = 0;
+u16 var_6799 = 0;
+u16 var_6800 = 0;
+u16 var_6801 = 0;
+u16 var_6802 = 0;
+u16 var_6803 = 0;
+u16 var_6804 = 0;
+u16 var_6805 = 0;
+u16 var_6806 = 0;
+u16 var_6807 = 0;
+u16 var_6808 = 0;
+u16 var_6809 = 0;
+u16 var_6810 = 0;
+u16 var_6811 = 0;
+u16 var_6812 = 0;
+u16 var_6813 = 0;
+u16 var_6814 = 0;
+u16 var_6815 = 0;
+u16 var_6816 = 0;
+u16 var_6817 = 0;
+u16 var_6818 = 0;
+u16 var_6819 = 0;
+u16 var_6820 = 0;
+u16 var_6821 = 0;
+u16 var_6822 = 0;
+u16 var_6823 = 0;
+u16 var_6824 = 0;
+u16 var_6825 = 0;
+u16 var_6826 = 0;
+u16 var_6827 = 0;
+u16 var_6828 = 0;
+u16 var_6829 = 0;
+u16 var_6830 = 0;
+u16 var_6831 = 0;
+u16 var_6832 = 0;
+u16 var_6833 = 0;
+u16 var_6834 = 0;
+u16 var_6835 = 0;
+u16 var_6836 = 0;
+u16 var_6837 = 0;
+u16 var_6838 = 0;
+u16 var_6839 = 0;
+u16 var_6840 = 0;
+u16 var_6841 = 0;
+u16 var_6842 = 0;
+u16 var_6843 = 0;
+u16 var_6844 = 0;
+u16 var_6845 = 0;
+u16 var_6846 = 0;
+u16 var_6847 = 0;
+u16 var_6848 = 0;
+u16 var_6849 = 0;
+u16 var_6850 = 0;
+u16 var_6851 = 0;
+u16 var_6852 = 0;
+u16 var_6853 = 0;
+u16 var_6854 = 0;
+u16 var_6855 = 0;
+u16 var_6856 = 0;
+u16 var_6857 = 0;
+u16 var_6858 = 0;
+u16 var_6859 = 0;
+u16 var_6860 = 0;
+u16 var_6861 = 0;
+u16 var_6862 = 0;
+u16 var_6863 = 0;
+u16 var_6864 = 0;
+u16 var_6865 = 0;
+u16 var_6866 = 0;
+u16 var_6867 = 0;
+u16 var_6868 = 0;
+u16 var_6869 = 0;
+u16 var_6870 = 0;
+u16 var_6871 = 0;
+u16 var_6872 = 0;
+u16 var_6873 = 0;
+u16 var_6874 = 0;
+u16 var_6875 = 0;
+u16 var_6876 = 0;
+u16 var_6877 = 0;
+u16 var_6878 = 0;
+u16 var_6879 = 0;
+u16 var_6880 = 0;
+u16 var_6881 = 0;
+u16 var_6882 = 0;
+u16 var_6883 = 0;
+u16 var_6884 = 0;
+u16 var_6885 = 0;
+u16 var_6886 = 0;
+u16 var_6887 = 0;
+u16 var_6888 = 0;
+u16 var_6889 = 0;
+u16 var_6890 = 0;
+u16 var_6891 = 0;
+u16 var_6892 = 0;
+u16 var_6893 = 0;
+u16 var_6894 = 0;
+u16 var_6895 = 0;
+u16 var_6896 = 0;
+u16 var_6897 = 0;
+u16 var_6898 = 0;
+u16 var_6899 = 0;
+u16 var_6900 = 0;
+u16 var_6901 = 0;
+u16 var_6902 = 0;
+u16 var_6903 = 0;
+u16 var_6904 = 0;
+u16 var_6905 = 0;
+u16 var_6906 = 0;
+u16 var_6907 = 0;
+u16 var_6908 = 0;
+u16 var_6909 = 0;
+u16 var_6910 = 0;
+u16 var_6911 = 0;
+u16 var_6912 = 0;
+u16 var_6913 = 0;
+u16 var_6914 = 0;
+u16 var_6915 = 0;
+u16 var_6916 = 0;
+u16 var_6917 = 0;
+u16 var_6918 = 0;
+u16 var_6919 = 0;
+u16 var_6920 = 0;
+u16 var_6921 = 0;
+u16 var_6922 = 0;
+u16 var_6923 = 0;
+u16 var_6924 = 0;
+u16 var_6925 = 0;
+u16 var_6926 = 0;
+u16 var_6927 = 0;
+u16 var_6928 = 0;
+u16 var_6929 = 0;
+u16 var_6930 = 0;
+u16 var_6931 = 0;
+u16 var_6932 = 0;
+u16 var_6933 = 0;
+u16 var_6934 = 0;
+u16 var_6935 = 0;
+u16 var_6936 = 0;
+u16 var_6937 = 0;
+u16 var_6938 = 0;
+u16 var_6939 = 0;
+u16 var_6940 = 0;
+u16 var_6941 = 0;
+u16 var_6942 = 0;
+u16 var_6943 = 0;
+u16 var_6944 = 0;
+u16 var_6945 = 0;
+u16 var_6946 = 0;
+u16 var_6947 = 0;
+u16 var_6948 = 0;
+u16 var_6949 = 0;
+u16 var_6950 = 0;
+u16 var_6951 = 0;
+u16 var_6952 = 0;
+u16 var_6953 = 0;
+u16 var_6954 = 0;
+u16 var_6955 = 0;
+u16 var_6956 = 0;
+u16 var_6957 = 0;
+u16 var_6958 = 0;
+u16 var_6959 = 0;
+u16 var_6960 = 0;
+u16 var_6961 = 0;
+u16 var_6962 = 0;
+u16 var_6963 = 0;
+u16 var_6964 = 0;
+u16 var_6965 = 0;
+u16 var_6966 = 0;
+u16 var_6967 = 0;
+u16 var_6968 = 0;
+u16 var_6969 = 0;
+u16 var_6970 = 0;
+u16 var_6971 = 0;
+u16 var_6972 = 0;
+u16 var_6973 = 0;
+u16 var_6974 = 0;
+u16 var_6975 = 0;
+u16 var_6976 = 0;
+u16 var_6977 = 0;
+u16 var_6978 = 0;
+u16 var_6979 = 0;
+u16 var_6980 = 0;
+u16 var_6981 = 0;
+u16 var_6982 = 0;
+u16 var_6983 = 0;
+u16 var_6984 = 0;
+u16 var_6985 = 0;
+u16 var_6986 = 0;
+u16 var_6987 = 0;
+u16 var_6988 = 0;
+u16 var_6989 = 0;
+u16 var_6990 = 0;
+u16 var_6991 = 0;
+u16 var_6992 = 0;
+u16 var_6993 = 0;
+u16 var_6994 = 0;
+u16 var_6995 = 0;
+u16 var_6996 = 0;
+u16 var_6997 = 0;
+u16 var_6998 = 0;
+u16 var_6999 = 0;
+u16 var_7000 = 0;
+u16 var_7001 = 0;
+u16 var_7002 = 0;
+u16 var_7003 = 0;
+u16 var_7004 = 0;
+u16 var_7005 = 0;
+u16 var_7006 = 0;
+u16 var_7007 = 0;
+u16 var_7008 = 0;
+u16 var_7009 = 0;
+u16 var_7010 = 0;
+u16 var_7011 = 0;
+u16 var_7012 = 0;
+u16 var_7013 = 0;
+u16 var_7014 = 0;
+u16 var_7015 = 0;
+u16 var_7016 = 0;
+u16 var_7017 = 0;
+u16 var_7018 = 0;
+u16 var_7019 = 0;
+u16 var_7020 = 0;
+u16 var_7021 = 0;
+u16 var_7022 = 0;
+u16 var_7023 = 0;
+u16 var_7024 = 0;
+u16 var_7025 = 0;
+u16 var_7026 = 0;
+u16 var_7027 = 0;
+u16 var_7028 = 0;
+u16 var_7029 = 0;
+u16 var_7030 = 0;
+u16 var_7031 = 0;
+u16 var_7032 = 0;
+u16 var_7033 = 0;
+u16 var_7034 = 0;
+u16 var_7035 = 0;
+u16 var_7036 = 0;
+u16 var_7037 = 0;
+u16 var_7038 = 0;
+u16 var_7039 = 0;
+u16 var_7040 = 0;
+u16 var_7041 = 0;
+u16 var_7042 = 0;
+u16 var_7043 = 0;
+u16 var_7044 = 0;
+u16 var_7045 = 0;
+u16 var_7046 = 0;
+u16 var_7047 = 0;
+u16 var_7048 = 0;
+u16 var_7049 = 0;
+u16 var_7050 = 0;
+u16 var_7051 = 0;
+u16 var_7052 = 0;
+u16 var_7053 = 0;
+u16 var_7054 = 0;
+u16 var_7055 = 0;
+u16 var_7056 = 0;
+u16 var_7057 = 0;
+u16 var_7058 = 0;
+u16 var_7059 = 0;
+u16 var_7060 = 0;
+u16 var_7061 = 0;
+u16 var_7062 = 0;
+u16 var_7063 = 0;
+u16 var_7064 = 0;
+u16 var_7065 = 0;
+u16 var_7066 = 0;
+u16 var_7067 = 0;
+u16 var_7068 = 0;
+u16 var_7069 = 0;
+u16 var_7070 = 0;
+u16 var_7071 = 0;
+u16 var_7072 = 0;
+u16 var_7073 = 0;
+u16 var_7074 = 0;
+u16 var_7075 = 0;
+u16 var_7076 = 0;
+u16 var_7077 = 0;
+u16 var_7078 = 0;
+u16 var_7079 = 0;
+u16 var_7080 = 0;
+u16 var_7081 = 0;
+u16 var_7082 = 0;
+u16 var_7083 = 0;
+u16 var_7084 = 0;
+u16 var_7085 = 0;
+u16 var_7086 = 0;
+u16 var_7087 = 0;
+u16 var_7088 = 0;
+u16 var_7089 = 0;
+u16 var_7090 = 0;
+u16 var_7091 = 0;
+u16 var_7092 = 0;
+u16 var_7093 = 0;
+u16 var_7094 = 0;
+u16 var_7095 = 0;
+u16 var_7096 = 0;
+u16 var_7097 = 0;
+u16 var_7098 = 0;
+u16 var_7099 = 0;
+u16 var_7100 = 0;
+u16 var_7101 = 0;
+u16 var_7102 = 0;
+u16 var_7103 = 0;
+u16 var_7104 = 0;
+u16 var_7105 = 0;
+u16 var_7106 = 0;
+u16 var_7107 = 0;
+u16 var_7108 = 0;
+u16 var_7109 = 0;
+u16 var_7110 = 0;
+u16 var_7111 = 0;
+u16 var_7112 = 0;
+u16 var_7113 = 0;
+u16 var_7114 = 0;
+u16 var_7115 = 0;
+u16 var_7116 = 0;
+u16 var_7117 = 0;
+u16 var_7118 = 0;
+u16 var_7119 = 0;
+u16 var_7120 = 0;
+u16 var_7121 = 0;
+u16 var_7122 = 0;
+u16 var_7123 = 0;
+u16 var_7124 = 0;
+u16 var_7125 = 0;
+u16 var_7126 = 0;
+u16 var_7127 = 0;
+u16 var_7128 = 0;
+u16 var_7129 = 0;
+u16 var_7130 = 0;
+u16 var_7131 = 0;
+u16 var_7132 = 0;
+u16 var_7133 = 0;
+u16 var_7134 = 0;
+u16 var_7135 = 0;
+u16 var_7136 = 0;
+u16 var_7137 = 0;
+u16 var_7138 = 0;
+u16 var_7139 = 0;
+u16 var_7140 = 0;
+u16 var_7141 = 0;
+u16 var_7142 = 0;
+u16 var_7143 = 0;
+u16 var_7144 = 0;
+u16 var_7145 = 0;
+u16 var_7146 = 0;
+u16 var_7147 = 0;
+u16 var_7148 = 0;
+u16 var_7149 = 0;
+u16 var_7150 = 0;
+u16 var_7151 = 0;
+u16 var_7152 = 0;
+u16 var_7153 = 0;
+u16 var_7154 = 0;
+u16 var_7155 = 0;
+u16 var_7156 = 0;
+u16 var_7157 = 0;
+u16 var_7158 = 0;
+u16 var_7159 = 0;
+u16 var_7160 = 0;
+u16 var_7161 = 0;
+u16 var_7162 = 0;
+u16 var_7163 = 0;
+u16 var_7164 = 0;
+u16 var_7165 = 0;
+u16 var_7166 = 0;
+u16 var_7167 = 0;
+u16 var_7168 = 0;
+u16 var_7169 = 0;
+u16 var_7170 = 0;
+u16 var_7171 = 0;
+u16 var_7172 = 0;
+u16 var_7173 = 0;
+u16 var_7174 = 0;
+u16 var_7175 = 0;
+u16 var_7176 = 0;
+u16 var_7177 = 0;
+u16 var_7178 = 0;
+u16 var_7179 = 0;
+u16 var_7180 = 0;
+u16 var_7181 = 0;
+u16 var_7182 = 0;
+u16 var_7183 = 0;
+u16 var_7184 = 0;
+u16 var_7185 = 0;
+u16 var_7186 = 0;
+u16 var_7187 = 0;
+u16 var_7188 = 0;
+u16 var_7189 = 0;
+u16 var_7190 = 0;
+u16 var_7191 = 0;
+u16 var_7192 = 0;
+u16 var_7193 = 0;
+u16 var_7194 = 0;
+u16 var_7195 = 0;
+u16 var_7196 = 0;
+u16 var_7197 = 0;
+u16 var_7198 = 0;
+u16 var_7199 = 0;
+u16 var_7200 = 0;
+u16 var_7201 = 0;
+u16 var_7202 = 0;
+u16 var_7203 = 0;
+u16 var_7204 = 0;
+u16 var_7205 = 0;
+u16 var_7206 = 0;
+u16 var_7207 = 0;
+u16 var_7208 = 0;
+u16 var_7209 = 0;
+u16 var_7210 = 0;
+u16 var_7211 = 0;
+u16 var_7212 = 0;
+u16 var_7213 = 0;
+u16 var_7214 = 0;
+u16 var_7215 = 0;
+u16 var_7216 = 0;
+u16 var_7217 = 0;
+u16 var_7218 = 0;
+u16 var_7219 = 0;
+u16 var_7220 = 0;
+u16 var_7221 = 0;
+u16 var_7222 = 0;
+u16 var_7223 = 0;
+u16 var_7224 = 0;
+u16 var_7225 = 0;
+u16 var_7226 = 0;
+u16 var_7227 = 0;
+u16 var_7228 = 0;
+u16 var_7229 = 0;
+u16 var_7230 = 0;
+u16 var_7231 = 0;
+u16 var_7232 = 0;
+u16 var_7233 = 0;
+u16 var_7234 = 0;
+u16 var_7235 = 0;
+u16 var_7236 = 0;
+u16 var_7237 = 0;
+u16 var_7238 = 0;
+u16 var_7239 = 0;
+u16 var_7240 = 0;
+u16 var_7241 = 0;
+u16 var_7242 = 0;
+u16 var_7243 = 0;
+u16 var_7244 = 0;
+u16 var_7245 = 0;
+u16 var_7246 = 0;
+u16 var_7247 = 0;
+u16 var_7248 = 0;
+u16 var_7249 = 0;
+u16 var_7250 = 0;
+u16 var_7251 = 0;
+u16 var_7252 = 0;
+u16 var_7253 = 0;
+u16 var_7254 = 0;
+u16 var_7255 = 0;
+u16 var_7256 = 0;
+u16 var_7257 = 0;
+u16 var_7258 = 0;
+u16 var_7259 = 0;
+u16 var_7260 = 0;
+u16 var_7261 = 0;
+u16 var_7262 = 0;
+u16 var_7263 = 0;
+u16 var_7264 = 0;
+u16 var_7265 = 0;
+u16 var_7266 = 0;
+u16 var_7267 = 0;
+u16 var_7268 = 0;
+u16 var_7269 = 0;
+u16 var_7270 = 0;
+u16 var_7271 = 0;
+u16 var_7272 = 0;
+u16 var_7273 = 0;
+u16 var_7274 = 0;
+u16 var_7275 = 0;
+u16 var_7276 = 0;
+u16 var_7277 = 0;
+u16 var_7278 = 0;
+u16 var_7279 = 0;
+u16 var_7280 = 0;
+u16 var_7281 = 0;
+u16 var_7282 = 0;
+u16 var_7283 = 0;
+u16 var_7284 = 0;
+u16 var_7285 = 0;
+u16 var_7286 = 0;
+u16 var_7287 = 0;
+u16 var_7288 = 0;
+u16 var_7289 = 0;
+u16 var_7290 = 0;
+u16 var_7291 = 0;
+u16 var_7292 = 0;
+u16 var_7293 = 0;
+u16 var_7294 = 0;
+u16 var_7295 = 0;
+u16 var_7296 = 0;
+u16 var_7297 = 0;
+u16 var_7298 = 0;
+u16 var_7299 = 0;
+u16 var_7300 = 0;
+u16 var_7301 = 0;
+u16 var_7302 = 0;
+u16 var_7303 = 0;
+u16 var_7304 = 0;
+u16 var_7305 = 0;
+u16 var_7306 = 0;
+u16 var_7307 = 0;
+u16 var_7308 = 0;
+u16 var_7309 = 0;
+u16 var_7310 = 0;
+u16 var_7311 = 0;
+u16 var_7312 = 0;
+u16 var_7313 = 0;
+u16 var_7314 = 0;
+u16 var_7315 = 0;
+u16 var_7316 = 0;
+u16 var_7317 = 0;
+u16 var_7318 = 0;
+u16 var_7319 = 0;
+u16 var_7320 = 0;
+u16 var_7321 = 0;
+u16 var_7322 = 0;
+u16 var_7323 = 0;
+u16 var_7324 = 0;
+u16 var_7325 = 0;
+u16 var_7326 = 0;
+u16 var_7327 = 0;
+u16 var_7328 = 0;
+u16 var_7329 = 0;
+u16 var_7330 = 0;
+u16 var_7331 = 0;
+u16 var_7332 = 0;
+u16 var_7333 = 0;
+u16 var_7334 = 0;
+u16 var_7335 = 0;
+u16 var_7336 = 0;
+u16 var_7337 = 0;
+u16 var_7338 = 0;
+u16 var_7339 = 0;
+u16 var_7340 = 0;
+u16 var_7341 = 0;
+u16 var_7342 = 0;
+u16 var_7343 = 0;
+u16 var_7344 = 0;
+u16 var_7345 = 0;
+u16 var_7346 = 0;
+u16 var_7347 = 0;
+u16 var_7348 = 0;
+u16 var_7349 = 0;
+u16 var_7350 = 0;
+u16 var_7351 = 0;
+u16 var_7352 = 0;
+u16 var_7353 = 0;
+u16 var_7354 = 0;
+u16 var_7355 = 0;
+u16 var_7356 = 0;
+u16 var_7357 = 0;
+u16 var_7358 = 0;
+u16 var_7359 = 0;
+u16 var_7360 = 0;
+u16 var_7361 = 0;
+u16 var_7362 = 0;
+u16 var_7363 = 0;
+u16 var_7364 = 0;
+u16 var_7365 = 0;
+u16 var_7366 = 0;
+u16 var_7367 = 0;
+u16 var_7368 = 0;
+u16 var_7369 = 0;
+u16 var_7370 = 0;
+u16 var_7371 = 0;
+u16 var_7372 = 0;
+u16 var_7373 = 0;
+u16 var_7374 = 0;
+u16 var_7375 = 0;
+u16 var_7376 = 0;
+u16 var_7377 = 0;
+u16 var_7378 = 0;
+u16 var_7379 = 0;
+u16 var_7380 = 0;
+u16 var_7381 = 0;
+u16 var_7382 = 0;
+u16 var_7383 = 0;
+u16 var_7384 = 0;
+u16 var_7385 = 0;
+u16 var_7386 = 0;
+u16 var_7387 = 0;
+u16 var_7388 = 0;
+u16 var_7389 = 0;
+u16 var_7390 = 0;
+u16 var_7391 = 0;
+u16 var_7392 = 0;
+u16 var_7393 = 0;
+u16 var_7394 = 0;
+u16 var_7395 = 0;
+u16 var_7396 = 0;
+u16 var_7397 = 0;
+u16 var_7398 = 0;
+u16 var_7399 = 0;
+u16 var_7400 = 0;
+u16 var_7401 = 0;
+u16 var_7402 = 0;
+u16 var_7403 = 0;
+u16 var_7404 = 0;
+u16 var_7405 = 0;
+u16 var_7406 = 0;
+u16 var_7407 = 0;
+u16 var_7408 = 0;
+u16 var_7409 = 0;
+u16 var_7410 = 0;
+u16 var_7411 = 0;
+u16 var_7412 = 0;
+u16 var_7413 = 0;
+u16 var_7414 = 0;
+u16 var_7415 = 0;
+u16 var_7416 = 0;
+u16 var_7417 = 0;
+u16 var_7418 = 0;
+u16 var_7419 = 0;
+u16 var_7420 = 0;
+u16 var_7421 = 0;
+u16 var_7422 = 0;
+u16 var_7423 = 0;
+u16 var_7424 = 0;
+u16 var_7425 = 0;
+u16 var_7426 = 0;
+u16 var_7427 = 0;
+u16 var_7428 = 0;
+u16 var_7429 = 0;
+u16 var_7430 = 0;
+u16 var_7431 = 0;
+u16 var_7432 = 0;
+u16 var_7433 = 0;
+u16 var_7434 = 0;
+u16 var_7435 = 0;
+u16 var_7436 = 0;
+u16 var_7437 = 0;
+u16 var_7438 = 0;
+u16 var_7439 = 0;
+u16 var_7440 = 0;
+u16 var_7441 = 0;
+u16 var_7442 = 0;
+u16 var_7443 = 0;
+u16 var_7444 = 0;
+u16 var_7445 = 0;
+u16 var_7446 = 0;
+u16 var_7447 = 0;
+u16 var_7448 = 0;
+u16 var_7449 = 0;
+u16 var_7450 = 0;
+u16 var_7451 = 0;
+u16 var_7452 = 0;
+u16 var_7453 = 0;
+u16 var_7454 = 0;
+u16 var_7455 = 0;
+u16 var_7456 = 0;
+u16 var_7457 = 0;
+u16 var_7458 = 0;
+u16 var_7459 = 0;
+u16 var_7460 = 0;
+u16 var_7461 = 0;
+u16 var_7462 = 0;
+u16 var_7463 = 0;
+u16 var_7464 = 0;
+u16 var_7465 = 0;
+u16 var_7466 = 0;
+u16 var_7467 = 0;
+u16 var_7468 = 0;
+u16 var_7469 = 0;
+u16 var_7470 = 0;
+u16 var_7471 = 0;
+u16 var_7472 = 0;
+u16 var_7473 = 0;
+u16 var_7474 = 0;
+u16 var_7475 = 0;
+u16 var_7476 = 0;
+u16 var_7477 = 0;
+u16 var_7478 = 0;
+u16 var_7479 = 0;
+u16 var_7480 = 0;
+u16 var_7481 = 0;
+u16 var_7482 = 0;
+u16 var_7483 = 0;
+u16 var_7484 = 0;
+u16 var_7485 = 0;
+u16 var_7486 = 0;
+u16 var_7487 = 0;
+u16 var_7488 = 0;
+u16 var_7489 = 0;
+u16 var_7490 = 0;
+u16 var_7491 = 0;
+u16 var_7492 = 0;
+u16 var_7493 = 0;
+u16 var_7494 = 0;
+u16 var_7495 = 0;
+u16 var_7496 = 0;
+u16 var_7497 = 0;
+u16 var_7498 = 0;
+u16 var_7499 = 0;
+u16 var_7500 = 0;
+u16 var_7501 = 0;
+u16 var_7502 = 0;
+u16 var_7503 = 0;
+u16 var_7504 = 0;
+u16 var_7505 = 0;
+u16 var_7506 = 0;
+u16 var_7507 = 0;
+u16 var_7508 = 0;
+u16 var_7509 = 0;
+u16 var_7510 = 0;
+u16 var_7511 = 0;
+u16 var_7512 = 0;
+u16 var_7513 = 0;
+u16 var_7514 = 0;
+u16 var_7515 = 0;
+u16 var_7516 = 0;
+u16 var_7517 = 0;
+u16 var_7518 = 0;
+u16 var_7519 = 0;
+u16 var_7520 = 0;
+u16 var_7521 = 0;
+u16 var_7522 = 0;
+u16 var_7523 = 0;
+u16 var_7524 = 0;
+u16 var_7525 = 0;
+u16 var_7526 = 0;
+u16 var_7527 = 0;
+u16 var_7528 = 0;
+u16 var_7529 = 0;
+u16 var_7530 = 0;
+u16 var_7531 = 0;
+u16 var_7532 = 0;
+u16 var_7533 = 0;
+u16 var_7534 = 0;
+u16 var_7535 = 0;
+u16 var_7536 = 0;
+u16 var_7537 = 0;
+u16 var_7538 = 0;
+u16 var_7539 = 0;
+u16 var_7540 = 0;
+u16 var_7541 = 0;
+u16 var_7542 = 0;
+u16 var_7543 = 0;
+u16 var_7544 = 0;
+u16 var_7545 = 0;
+u16 var_7546 = 0;
+u16 var_7547 = 0;
+u16 var_7548 = 0;
+u16 var_7549 = 0;
+u16 var_7550 = 0;
+u16 var_7551 = 0;
+u16 var_7552 = 0;
+u16 var_7553 = 0;
+u16 var_7554 = 0;
+u16 var_7555 = 0;
+u16 var_7556 = 0;
+u16 var_7557 = 0;
+u16 var_7558 = 0;
+u16 var_7559 = 0;
+u16 var_7560 = 0;
+u16 var_7561 = 0;
+u16 var_7562 = 0;
+u16 var_7563 = 0;
+u16 var_7564 = 0;
+u16 var_7565 = 0;
+u16 var_7566 = 0;
+u16 var_7567 = 0;
+u16 var_7568 = 0;
+u16 var_7569 = 0;
+u16 var_7570 = 0;
+u16 var_7571 = 0;
+u16 var_7572 = 0;
+u16 var_7573 = 0;
+u16 var_7574 = 0;
+u16 var_7575 = 0;
+u16 var_7576 = 0;
+u16 var_7577 = 0;
+u16 var_7578 = 0;
+u16 var_7579 = 0;
+u16 var_7580 = 0;
+u16 var_7581 = 0;
+u16 var_7582 = 0;
+u16 var_7583 = 0;
+u16 var_7584 = 0;
+u16 var_7585 = 0;
+u16 var_7586 = 0;
+u16 var_7587 = 0;
+u16 var_7588 = 0;
+u16 var_7589 = 0;
+u16 var_7590 = 0;
+u16 var_7591 = 0;
+u16 var_7592 = 0;
+u16 var_7593 = 0;
+u16 var_7594 = 0;
+u16 var_7595 = 0;
+u16 var_7596 = 0;
+u16 var_7597 = 0;
+u16 var_7598 = 0;
+u16 var_7599 = 0;
+u16 var_7600 = 0;
+u16 var_7601 = 0;
+u16 var_7602 = 0;
+u16 var_7603 = 0;
+u16 var_7604 = 0;
+u16 var_7605 = 0;
+u16 var_7606 = 0;
+u16 var_7607 = 0;
+u16 var_7608 = 0;
+u16 var_7609 = 0;
+u16 var_7610 = 0;
+u16 var_7611 = 0;
+u16 var_7612 = 0;
+u16 var_7613 = 0;
+u16 var_7614 = 0;
+u16 var_7615 = 0;
+u16 var_7616 = 0;
+u16 var_7617 = 0;
+u16 var_7618 = 0;
+u16 var_7619 = 0;
+u16 var_7620 = 0;
+u16 var_7621 = 0;
+u16 var_7622 = 0;
+u16 var_7623 = 0;
+u16 var_7624 = 0;
+u16 var_7625 = 0;
+u16 var_7626 = 0;
+u16 var_7627 = 0;
+u16 var_7628 = 0;
+u16 var_7629 = 0;
+u16 var_7630 = 0;
+u16 var_7631 = 0;
+u16 var_7632 = 0;
+u16 var_7633 = 0;
+u16 var_7634 = 0;
+u16 var_7635 = 0;
+u16 var_7636 = 0;
+u16 var_7637 = 0;
+u16 var_7638 = 0;
+u16 var_7639 = 0;
+u16 var_7640 = 0;
+u16 var_7641 = 0;
+u16 var_7642 = 0;
+u16 var_7643 = 0;
+u16 var_7644 = 0;
+u16 var_7645 = 0;
+u16 var_7646 = 0;
+u16 var_7647 = 0;
+u16 var_7648 = 0;
+u16 var_7649 = 0;
+u16 var_7650 = 0;
+u16 var_7651 = 0;
+u16 var_7652 = 0;
+u16 var_7653 = 0;
+u16 var_7654 = 0;
+u16 var_7655 = 0;
+u16 var_7656 = 0;
+u16 var_7657 = 0;
+u16 var_7658 = 0;
+u16 var_7659 = 0;
+u16 var_7660 = 0;
+u16 var_7661 = 0;
+u16 var_7662 = 0;
+u16 var_7663 = 0;
+u16 var_7664 = 0;
+u16 var_7665 = 0;
+u16 var_7666 = 0;
+u16 var_7667 = 0;
+u16 var_7668 = 0;
+u16 var_7669 = 0;
+u16 var_7670 = 0;
+u16 var_7671 = 0;
+u16 var_7672 = 0;
+u16 var_7673 = 0;
+u16 var_7674 = 0;
+u16 var_7675 = 0;
+u16 var_7676 = 0;
+u16 var_7677 = 0;
+u16 var_7678 = 0;
+u16 var_7679 = 0;
+u16 var_7680 = 0;
+u16 var_7681 = 0;
+u16 var_7682 = 0;
+u16 var_7683 = 0;
+u16 var_7684 = 0;
+u16 var_7685 = 0;
+u16 var_7686 = 0;
+u16 var_7687 = 0;
+u16 var_7688 = 0;
+u16 var_7689 = 0;
+u16 var_7690 = 0;
+u16 var_7691 = 0;
+u16 var_7692 = 0;
+u16 var_7693 = 0;
+u16 var_7694 = 0;
+u16 var_7695 = 0;
+u16 var_7696 = 0;
+u16 var_7697 = 0;
+u16 var_7698 = 0;
+u16 var_7699 = 0;
+u16 var_7700 = 0;
+u16 var_7701 = 0;
+u16 var_7702 = 0;
+u16 var_7703 = 0;
+u16 var_7704 = 0;
+u16 var_7705 = 0;
+u16 var_7706 = 0;
+u16 var_7707 = 0;
+u16 var_7708 = 0;
+u16 var_7709 = 0;
+u16 var_7710 = 0;
+u16 var_7711 = 0;
+u16 var_7712 = 0;
+u16 var_7713 = 0;
+u16 var_7714 = 0;
+u16 var_7715 = 0;
+u16 var_7716 = 0;
+u16 var_7717 = 0;
+u16 var_7718 = 0;
+u16 var_7719 = 0;
+u16 var_7720 = 0;
+u16 var_7721 = 0;
+u16 var_7722 = 0;
+u16 var_7723 = 0;
+u16 var_7724 = 0;
+u16 var_7725 = 0;
+u16 var_7726 = 0;
+u16 var_7727 = 0;
+u16 var_7728 = 0;
+u16 var_7729 = 0;
+u16 var_7730 = 0;
+u16 var_7731 = 0;
+u16 var_7732 = 0;
+u16 var_7733 = 0;
+u16 var_7734 = 0;
+u16 var_7735 = 0;
+u16 var_7736 = 0;
+u16 var_7737 = 0;
+u16 var_7738 = 0;
+u16 var_7739 = 0;
+u16 var_7740 = 0;
+u16 var_7741 = 0;
+u16 var_7742 = 0;
+u16 var_7743 = 0;
+u16 var_7744 = 0;
+u16 var_7745 = 0;
+u16 var_7746 = 0;
+u16 var_7747 = 0;
+u16 var_7748 = 0;
+u16 var_7749 = 0;
+u16 var_7750 = 0;
+u16 var_7751 = 0;
+u16 var_7752 = 0;
+u16 var_7753 = 0;
+u16 var_7754 = 0;
+u16 var_7755 = 0;
+u16 var_7756 = 0;
+u16 var_7757 = 0;
+u16 var_7758 = 0;
+u16 var_7759 = 0;
+u16 var_7760 = 0;
+u16 var_7761 = 0;
+u16 var_7762 = 0;
+u16 var_7763 = 0;
+u16 var_7764 = 0;
+u16 var_7765 = 0;
+u16 var_7766 = 0;
+u16 var_7767 = 0;
+u16 var_7768 = 0;
+u16 var_7769 = 0;
+u16 var_7770 = 0;
+u16 var_7771 = 0;
+u16 var_7772 = 0;
+u16 var_7773 = 0;
+u16 var_7774 = 0;
+u16 var_7775 = 0;
+u16 var_7776 = 0;
+u16 var_7777 = 0;
+u16 var_7778 = 0;
+u16 var_7779 = 0;
+u16 var_7780 = 0;
+u16 var_7781 = 0;
+u16 var_7782 = 0;
+u16 var_7783 = 0;
+u16 var_7784 = 0;
+u16 var_7785 = 0;
+u16 var_7786 = 0;
+u16 var_7787 = 0;
+u16 var_7788 = 0;
+u16 var_7789 = 0;
+u16 var_7790 = 0;
+u16 var_7791 = 0;
+u16 var_7792 = 0;
+u16 var_7793 = 0;
+u16 var_7794 = 0;
+u16 var_7795 = 0;
+u16 var_7796 = 0;
+u16 var_7797 = 0;
+u16 var_7798 = 0;
+u16 var_7799 = 0;
+u16 var_7800 = 0;
+u16 var_7801 = 0;
+u16 var_7802 = 0;
+u16 var_7803 = 0;
+u16 var_7804 = 0;
+u16 var_7805 = 0;
+u16 var_7806 = 0;
+u16 var_7807 = 0;
+u16 var_7808 = 0;
+u16 var_7809 = 0;
+u16 var_7810 = 0;
+u16 var_7811 = 0;
+u16 var_7812 = 0;
+u16 var_7813 = 0;
+u16 var_7814 = 0;
+u16 var_7815 = 0;
+u16 var_7816 = 0;
+u16 var_7817 = 0;
+u16 var_7818 = 0;
+u16 var_7819 = 0;
+u16 var_7820 = 0;
+u16 var_7821 = 0;
+u16 var_7822 = 0;
+u16 var_7823 = 0;
+u16 var_7824 = 0;
+u16 var_7825 = 0;
+u16 var_7826 = 0;
+u16 var_7827 = 0;
+u16 var_7828 = 0;
+u16 var_7829 = 0;
+u16 var_7830 = 0;
+u16 var_7831 = 0;
+u16 var_7832 = 0;
+u16 var_7833 = 0;
+u16 var_7834 = 0;
+u16 var_7835 = 0;
+u16 var_7836 = 0;
+u16 var_7837 = 0;
+u16 var_7838 = 0;
+u16 var_7839 = 0;
+u16 var_7840 = 0;
+u16 var_7841 = 0;
+u16 var_7842 = 0;
+u16 var_7843 = 0;
+u16 var_7844 = 0;
+u16 var_7845 = 0;
+u16 var_7846 = 0;
+u16 var_7847 = 0;
+u16 var_7848 = 0;
+u16 var_7849 = 0;
+u16 var_7850 = 0;
+u16 var_7851 = 0;
+u16 var_7852 = 0;
+u16 var_7853 = 0;
+u16 var_7854 = 0;
+u16 var_7855 = 0;
+u16 var_7856 = 0;
+u16 var_7857 = 0;
+u16 var_7858 = 0;
+u16 var_7859 = 0;
+u16 var_7860 = 0;
+u16 var_7861 = 0;
+u16 var_7862 = 0;
+u16 var_7863 = 0;
+u16 var_7864 = 0;
+u16 var_7865 = 0;
+u16 var_7866 = 0;
+u16 var_7867 = 0;
+u16 var_7868 = 0;
+u16 var_7869 = 0;
+u16 var_7870 = 0;
+u16 var_7871 = 0;
+u16 var_7872 = 0;
+u16 var_7873 = 0;
+u16 var_7874 = 0;
+u16 var_7875 = 0;
+u16 var_7876 = 0;
+u16 var_7877 = 0;
+u16 var_7878 = 0;
+u16 var_7879 = 0;
+u16 var_7880 = 0;
+u16 var_7881 = 0;
+u16 var_7882 = 0;
+u16 var_7883 = 0;
+u16 var_7884 = 0;
+u16 var_7885 = 0;
+u16 var_7886 = 0;
+u16 var_7887 = 0;
+u16 var_7888 = 0;
+u16 var_7889 = 0;
+u16 var_7890 = 0;
+u16 var_7891 = 0;
+u16 var_7892 = 0;
+u16 var_7893 = 0;
+u16 var_7894 = 0;
+u16 var_7895 = 0;
+u16 var_7896 = 0;
+u16 var_7897 = 0;
+u16 var_7898 = 0;
+u16 var_7899 = 0;
+u16 var_7900 = 0;
+u16 var_7901 = 0;
+u16 var_7902 = 0;
+u16 var_7903 = 0;
+u16 var_7904 = 0;
+u16 var_7905 = 0;
+u16 var_7906 = 0;
+u16 var_7907 = 0;
+u16 var_7908 = 0;
+u16 var_7909 = 0;
+u16 var_7910 = 0;
+u16 var_7911 = 0;
+u16 var_7912 = 0;
+u16 var_7913 = 0;
+u16 var_7914 = 0;
+u16 var_7915 = 0;
+u16 var_7916 = 0;
+u16 var_7917 = 0;
+u16 var_7918 = 0;
+u16 var_7919 = 0;
+u16 var_7920 = 0;
+u16 var_7921 = 0;
+u16 var_7922 = 0;
+u16 var_7923 = 0;
+u16 var_7924 = 0;
+u16 var_7925 = 0;
+u16 var_7926 = 0;
+u16 var_7927 = 0;
+u16 var_7928 = 0;
+u16 var_7929 = 0;
+u16 var_7930 = 0;
+u16 var_7931 = 0;
+u16 var_7932 = 0;
+u16 var_7933 = 0;
+u16 var_7934 = 0;
+u16 var_7935 = 0;
+u16 var_7936 = 0;
+
+fn main() -> void { }
diff --git a/test/codegen/bad_rom_overflow.c02 b/test/codegen/bad_rom_overflow.c02
new file mode 100644
index 0000000..77cc32c
--- /dev/null
+++ b/test/codegen/bad_rom_overflow.c02
@@ -0,0 +1,2 @@
+u8 *x = "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ";
+fn main() -> void {}
\ No newline at end of file
diff --git a/test/codegen/golden/bad_ram_overflow.golden b/test/codegen/golden/bad_ram_overflow.golden
new file mode 100644
index 0000000..b60821e
--- /dev/null
+++ b/test/codegen/golden/bad_ram_overflow.golden
@@ -0,0 +1,2 @@
+Global variables overflowed RAM.
+Code generation failed.
diff --git a/test/codegen/golden/bad_rom_overflow.golden b/test/codegen/golden/bad_rom_overflow.golden
new file mode 100644
index 0000000..e10a0e7
--- /dev/null
+++ b/test/codegen/golden/bad_rom_overflow.golden
@@ -0,0 +1,2 @@
+Data section generation failed: output exceeds 32 KB ROM.
+Code generation failed.
diff --git a/test/codegen/golden/struct_under_ram_budget.golden b/test/codegen/golden/struct_under_ram_budget.golden
new file mode 100644
index 0000000..e69de29
diff --git a/test/codegen/struct_under_ram_budget.c02 b/test/codegen/struct_under_ram_budget.c02
new file mode 100644
index 0000000..4320343
--- /dev/null
+++ b/test/codegen/struct_under_ram_budget.c02
@@ -0,0 +1,12 @@
+struct S0 { u16 a; u16 b; }
+struct S1 { S0 a; S0 b; }
+struct S2 { S1 a; S1 b; }
+struct S3 { S2 a; S2 b; }
+struct S4 { S3 a; S3 b; }
+struct P16 { u8 a0; u8 a1; u8 a2; u8 a3; u8 a4; u8 a5; u8 a6; u8 a7; u8 a8; u8 a9; u8 a10; u8 a11; u8 a12; u8 a13; u8 a14; u8 a15; }
+struct P15 { u8 a0; u8 a1; u8 a2; u8 a3; u8 a4; u8 a5; u8 a6; u8 a7; u8 a8; u8 a9; u8 a10; u8 a11; u8 a12; u8 a13; u8 a14; }
+struct P127 { P16 a; P16 b; P16 c; P16 d; P16 e; P16 f; P15 g; }
+struct S5 { S4 a; S4 b; u16 x; u16 y; u16 z; P127 padding; S0 q; S0 r; u16 s; }
+// S5 size = 255 bytes (64 + 64 + 2 + 2 + 2 + 111 + 4 + 4 + 2) which is the limit
+
+fn main() -> void { }
diff --git a/test/emu/dec_dereffed_ptr.c02 b/test/emu/dec_dereffed_ptr.c02
new file mode 100644
index 0000000..0395c34
--- /dev/null
+++ b/test/emu/dec_dereffed_ptr.c02
@@ -0,0 +1,11 @@
+// DESC: decrementing a value through a pointer should store to the original address
+// EXPECT: mem8[0x6000] == 49
+reg u8 PORTB @ 0x6000;
+
+fn main() -> void {
+  u8 x = 50;
+  u8 *y = &x;
+
+  --*y;
+  PORTB = *y;
+}
\ No newline at end of file
diff --git a/test/emu/dec_register.c02 b/test/emu/dec_register.c02
new file mode 100644
index 0000000..ea4bf1c
--- /dev/null
+++ b/test/emu/dec_register.c02
@@ -0,0 +1,8 @@
+// DESC: decrementing a register should store to the register address
+// EXPECT: mem8[0x6000] == 0
+reg u8 PORTB @ 0x6000;
+
+fn main() -> void {
+  PORTB = 1;
+  --PORTB;
+}
\ No newline at end of file
diff --git a/test/emu/dec_struct_field.c02 b/test/emu/dec_struct_field.c02
new file mode 100644
index 0000000..0d9907a
--- /dev/null
+++ b/test/emu/dec_struct_field.c02
@@ -0,0 +1,13 @@
+// DESC: decrementing a struct value should store to the original address
+// EXPECT: mem8[0x6000] == 49
+reg u8 PORTB @ 0x6000;
+
+struct Point {
+  u8 x;
+  u8 y;
+}
+
+fn main() -> void {
+  Point p1 = Point { .x = 50, .y = 40 };
+  PORTB = --p1.x;
+}
\ No newline at end of file
diff --git a/test/emu/inc_dereffed_ptr.c02 b/test/emu/inc_dereffed_ptr.c02
new file mode 100644
index 0000000..a93f9dc
--- /dev/null
+++ b/test/emu/inc_dereffed_ptr.c02
@@ -0,0 +1,11 @@
+// DESC: incrementing a value through a pointer should store to the original address
+// EXPECT: mem8[0x6000] == 49
+reg u8 PORTB @ 0x6000;
+
+fn main() -> void {
+  u8 x = 48;
+  u8 *y = &x;
+
+  ++*y;
+  PORTB = *y;
+}
\ No newline at end of file
diff --git a/test/emu/inc_register.c02 b/test/emu/inc_register.c02
new file mode 100644
index 0000000..f3ac7fb
--- /dev/null
+++ b/test/emu/inc_register.c02
@@ -0,0 +1,7 @@
+// DESC: incrementing a register should store to the register address
+// EXPECT: mem8[0x6000] == 1
+reg u8 PORTB @ 0x6000;
+
+fn main() -> void {
+  ++PORTB;
+}
\ No newline at end of file
diff --git a/test/emu/inc_struct_field.c02 b/test/emu/inc_struct_field.c02
new file mode 100644
index 0000000..efc5135
--- /dev/null
+++ b/test/emu/inc_struct_field.c02
@@ -0,0 +1,13 @@
+// DESC: incrementing a struct value should store to the original address
+// EXPECT: mem8[0x6000] == 49
+reg u8 PORTB @ 0x6000;
+
+struct Point {
+  u8 x;
+  u8 y;
+}
+
+fn main() -> void {
+  Point p1 = Point { .x = 48, .y = 40 };
+  PORTB = ++p1.x;
+}
\ No newline at end of file
diff --git a/test/emu/nested_field_assign.c02 b/test/emu/nested_field_assign.c02
new file mode 100644
index 0000000..d062c15
--- /dev/null
+++ b/test/emu/nested_field_assign.c02
@@ -0,0 +1,13 @@
+// DESC: Assign value to nested struct
+// EXPECT: mem8[0x6000] == 42
+
+reg u8 PORTB @ 0x6000;
+
+struct Inner { u8 v; }
+struct Outer { Inner in; }
+
+fn main() -> void {
+  Outer o = Outer{ .in = Inner{ .v = 1 } };
+  o.in.v = 42;
+  PORTB = o.in.v;
+}
\ No newline at end of file